diff --git a/.gitignore b/.gitignore index 84bceab..17b8620 100644 --- a/.gitignore +++ b/.gitignore @@ -43,3 +43,21 @@ snapshots/ # OS/editor noise .DS_Store Thumbs.db + +.venv-m26/ +artifacts/ + +data/native_cortex/tokens/*.bin + +.venv-m26/ +artifacts/ +data/native_cortex/splits/*.jsonl +data/native_cortex/tokens/*.bin + +data/native_cortex/prime_bridge/ + +data/native_cortex/splits/ + +data/native_cortex/tokens/ + +data/native_cortex/verifier_semantics/ diff --git a/README.md b/README.md index bb26880..1972967 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,6 @@ --- -## 2. What Thinking System Is Governing pattern: diff --git a/core/cognition/__init__.py b/core/cognition/__init__.py new file mode 100644 index 0000000..103d981 --- /dev/null +++ b/core/cognition/__init__.py @@ -0,0 +1,99 @@ +"""PRIME M21 persistent adaptive cognition.""" + +from .engine import ( + CognitionSnapshot, + MegaPrimeCognition, +) +from .episodic import ( + EpisodeRecord, + EpisodicMemory, +) +from .memory import ( + SemanticMemoryEntry, + VerifiedConstructionMemory, + expand_references, +) +from .meta import ( + MetaLearningLedger, + ProposalSourceStats, +) +from .planner import ( + VerifiedPlan, + VerifiedPlanner, +) +from .proposal_field import ( + DistributedProposalField, + RankedCandidate, +) +from .schema import ( + SchemaMiner, + SchemaProposal, +) +from .study import ( + ActiveStudySelector, + StudyAction, + StudyProposal, +) +from .transfer import ( + TransferEngine, + TransferProposal, +) +from .world_model import ( + TransitionAuthorization, + TransitionCandidate, + TransitionVerifier, + VerifiedWorldModel, +) + +__all__ = [ + "ActiveStudySelector", + "CognitionSnapshot", + "DistributedProposalField", + "EpisodeRecord", + "EpisodicMemory", + "MegaPrimeCognition", + "MetaLearningLedger", + "ProposalSourceStats", + "RankedCandidate", + "SchemaMiner", + "SchemaProposal", + "SemanticMemoryEntry", + "StudyAction", + "StudyProposal", + "TransferEngine", + "TransferProposal", + "TransitionAuthorization", + "TransitionCandidate", + "TransitionVerifier", + "VerifiedConstructionMemory", + "VerifiedPlan", + "VerifiedPlanner", + "VerifiedWorldModel", + "expand_references", +] + +from .hypothesis_ecology import ( + HypothesisAllocation, + WeightedEvidenceEpoch, + allocate_hypothesis_mass, +) + +from .causal_program import ( + CONFIGURATIONS, + CausalProgram, + ProgramOp, + program_lookup, + program_universe, +) +from .causal_certificate import ( + CausalAuthorization, + CausalAuthorityLedger, + compatible_program_ids, + minimal_certificate, + universe_hash, +) +from .causal_memory import ( + CausalMemoryEntry, + CausalProgramMemory, + CausalSchema, +) diff --git a/core/cognition/causal_certificate.py b/core/cognition/causal_certificate.py new file mode 100644 index 0000000..e31d1d5 --- /dev/null +++ b/core/cognition/causal_certificate.py @@ -0,0 +1,352 @@ +"""Logical intervention certificates and causal authority.""" + +from __future__ import annotations + +from dataclasses import dataclass +from functools import lru_cache +import hashlib +import json +from itertools import combinations + +from .causal_program import ( + CONFIGURATIONS, + CausalProgram, + program_lookup, + program_universe, +) + + +ZERO_HASH = ( + "0" + * 64 +) + + +def _canonical( + payload: dict, +) -> bytes: + return json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + + +@lru_cache(maxsize=1) +def universe_hash() -> str: + payload = [ + { + "program_id": ( + program.program_id + ), + "label": ( + program.label + ), + "signature": list( + program.signature + ), + } + for program + in program_universe() + ] + + return hashlib.sha256( + _canonical( + { + "programs": payload + } + ) + ).hexdigest() + + +def compatible_program_ids( + observations: dict[ + tuple[int, ...], + int, + ], +) -> tuple[str, ...]: + rows = [] + + for program in ( + program_universe() + ): + if all( + program.evaluate( + configuration + ) + == outcome + for configuration, outcome + in observations.items() + ): + rows.append( + program.program_id + ) + + return tuple( + rows + ) + + +@lru_cache(maxsize=None) +def minimal_certificate( + program_id: str, +) -> tuple[ + tuple[int, ...], + ..., +]: + lookup = ( + program_lookup() + ) + + target = lookup[ + program_id + ] + + others = tuple( + program + for program + in program_universe() + if ( + program.program_id + != program_id + ) + ) + + for size in range( + 1, + len(CONFIGURATIONS) + + 1, + ): + for indices in combinations( + range( + len( + CONFIGURATIONS + ) + ), + size, + ): + if all( + any( + target.evaluate( + CONFIGURATIONS[ + index + ] + ) + != other.evaluate( + CONFIGURATIONS[ + index + ] + ) + for index + in indices + ) + for other + in others + ): + return tuple( + CONFIGURATIONS[ + index + ] + for index + in indices + ) + + raise RuntimeError( + "no distinguishing certificate" + ) + + +@dataclass(frozen=True) +class CausalAuthorization: + program_id: str + verdict: bool + observation_count: int + compatible_program_ids: tuple[ + str, + ..., + ] + universe_hash: str + receipt_hash: str + + +class CausalAuthorityLedger: + FORMAT = ( + "prime-m24-causal-authority-v1" + ) + + def __init__(self) -> None: + self.records: list[ + dict + ] = [] + + @property + def head_hash(self) -> str: + if not self.records: + return ZERO_HASH + + return self.records[ + -1 + ][ + "receipt_hash" + ] + + def authorize( + self, + program_id: str, + observations: dict[ + tuple[int, ...], + int, + ], + ) -> CausalAuthorization: + lookup = ( + program_lookup() + ) + + if program_id not in lookup: + raise KeyError( + "unknown causal program" + ) + + compatible = ( + compatible_program_ids( + observations + ) + ) + + verdict = ( + compatible + == ( + program_id, + ) + ) + + payload = { + "format": self.FORMAT, + "sequence": len( + self.records + ), + "program_id": ( + program_id + ), + "observations": [ + { + "configuration": list( + configuration + ), + "outcome": ( + outcome + ), + } + for ( + configuration, + outcome, + ) + in sorted( + observations.items() + ) + ], + "compatible_program_ids": list( + compatible + ), + "universe_hash": ( + universe_hash() + ), + "verdict": verdict, + "parent_hash": ( + self.head_hash + ), + } + + receipt_hash = ( + hashlib.sha256( + _canonical( + payload + ) + ).hexdigest() + ) + + record = { + **payload, + "receipt_hash": ( + receipt_hash + ), + } + + self.records.append( + record + ) + + return CausalAuthorization( + program_id=( + program_id + ), + verdict=verdict, + observation_count=len( + observations + ), + compatible_program_ids=( + compatible + ), + universe_hash=( + payload[ + "universe_hash" + ] + ), + receipt_hash=( + receipt_hash + ), + ) + + def verify_chain( + self, + ) -> bool: + parent = ZERO_HASH + + for sequence, record in ( + enumerate( + self.records + ) + ): + if ( + record[ + "sequence" + ] + != sequence + ): + return False + + if ( + record[ + "parent_hash" + ] + != parent + ): + return False + + payload = { + key: value + for key, value + in record.items() + if key + != "receipt_hash" + } + + expected = ( + hashlib.sha256( + _canonical( + payload + ) + ).hexdigest() + ) + + if ( + expected + != record[ + "receipt_hash" + ] + ): + return False + + parent = expected + + return True diff --git a/core/cognition/causal_ecology.py b/core/cognition/causal_ecology.py new file mode 100644 index 0000000..ec9f1e7 --- /dev/null +++ b/core/cognition/causal_ecology.py @@ -0,0 +1,412 @@ +"""Universal weighted causal hypothesis ecology for PRIME M25.""" + +from __future__ import annotations + +from dataclasses import dataclass +from fractions import Fraction + +from .causal_memory import ( + CausalProgramMemory, + schema_descriptor, +) +from .causal_program import ( + CONFIGURATIONS, + program_lookup, + program_universe, +) + + +BASE_MASS = 1024 + + +@dataclass(frozen=True) +class CausalMassField: + mass_by_id: dict[str, int] + base_mass: int + universal_mass: int + bonus_mass: int + total_mass: int + memory_program_count: int + schema_count: int + + def mass( + self, + program_id: str, + ) -> int: + return self.mass_by_id[ + program_id + ] + + def rank( + self, + program_id: str, + ) -> int: + lookup = program_lookup() + + ordered = sorted( + self.mass_by_id, + key=lambda pid: ( + -self.mass_by_id[pid], + lookup[pid].label, + ), + ) + + return ( + ordered.index( + program_id + ) + + 1 + ) + + +def build_causal_mass_field( + memory: ( + CausalProgramMemory + | None + ), +) -> CausalMassField: + universe = ( + program_universe() + ) + + mass_by_id = { + program.program_id: ( + BASE_MASS + ) + for program + in universe + } + + universal_mass = ( + BASE_MASS + * len(universe) + ) + + if memory is None: + return CausalMassField( + mass_by_id=mass_by_id, + base_mass=BASE_MASS, + universal_mass=( + universal_mass + ), + bonus_mass=0, + total_mass=( + universal_mass + ), + memory_program_count=0, + schema_count=0, + ) + + raw_bonus = { + program.program_id: 0 + for program + in universe + } + + # Exact verified causal experience. + for program_id, entry in ( + memory.entries.items() + ): + if program_id not in ( + raw_bonus + ): + continue + + recency = max( + 0, + 16 + - ( + memory.sequence + - entry.last_sequence + ), + ) + + raw_bonus[ + program_id + ] += max( + 0, + ( + 4096 + + 1536 + * entry.times_verified + + 768 + * entry.successful_reuses + - 1024 + * entry.failed_reuses + + 128 + * recency + ), + ) + + schemas = ( + memory.schemas() + ) + + # Schema knowledge can raise an unseen program without + # making the schema itself authoritative. + for schema in schemas: + for program in universe: + if ( + schema_descriptor( + program + ) + != ( + schema.operator, + schema.normalized_offsets, + ) + ): + continue + + raw_bonus[ + program.program_id + ] += ( + 2048 + * schema.support + ) + + raw_total = sum( + raw_bonus.values() + ) + + # Safety mixture: + # + # total prior-derived mass <= universal baseline mass. + # + # Thus universal support is never less than half the + # pre-observation proposal mass. + bonus_budget = min( + universal_mass, + raw_total, + ) + + scaled_bonus = { + program_id: 0 + for program_id + in raw_bonus + } + + if ( + raw_total > 0 + and bonus_budget > 0 + ): + for program_id, raw in ( + raw_bonus.items() + ): + scaled_bonus[ + program_id + ] = ( + raw + * bonus_budget + // raw_total + ) + + for program_id, bonus in ( + scaled_bonus.items() + ): + mass_by_id[ + program_id + ] += bonus + + bonus_mass = sum( + scaled_bonus.values() + ) + + return CausalMassField( + mass_by_id=mass_by_id, + base_mass=BASE_MASS, + universal_mass=( + universal_mass + ), + bonus_mass=( + bonus_mass + ), + total_mass=( + universal_mass + + bonus_mass + ), + memory_program_count=len( + memory.entries + ), + schema_count=len( + schemas + ), + ) + + +@dataclass(frozen=True) +class EpistemicStudy: + configuration: tuple[int, ...] + zero_mass: int + one_mass: int + surviving_mass: int + primitive_cost: int + information_product: int + value_per_cost: Fraction + worst_case_mass: int + zero_count: int + one_count: int + + +class WeightedCausalStudySelector: + """Select globally useful interventions. + + Prior mass alters experiment order only. + + Exact hypothesis elimination and causal authority remain + separate. + """ + + def choose( + self, + *, + surviving_program_ids: set[ + str + ], + observations: dict[ + tuple[int, ...], + int, + ], + mass_field: CausalMassField, + intervention_cost, + ) -> EpistemicStudy: + if len( + surviving_program_ids + ) <= 1: + raise ValueError( + "study requested after identification" + ) + + lookup = ( + program_lookup() + ) + + rows = [] + + for configuration in ( + CONFIGURATIONS + ): + if ( + configuration + in observations + ): + continue + + zero_ids = [] + one_ids = [] + + zero_mass = 0 + one_mass = 0 + + for program_id in ( + surviving_program_ids + ): + outcome = ( + lookup[ + program_id + ].evaluate( + configuration + ) + ) + + if outcome: + one_ids.append( + program_id + ) + + one_mass += ( + mass_field.mass( + program_id + ) + ) + + else: + zero_ids.append( + program_id + ) + + zero_mass += ( + mass_field.mass( + program_id + ) + ) + + if ( + zero_mass == 0 + or one_mass == 0 + ): + continue + + cost = max( + 1, + int( + intervention_cost( + configuration + ) + ), + ) + + # For deterministic binary observations, + # expected eliminated probability mass is proportional + # to m0*m1/M. M is constant across candidate studies. + information_product = ( + zero_mass + * one_mass + ) + + rows.append( + EpistemicStudy( + configuration=( + configuration + ), + zero_mass=( + zero_mass + ), + one_mass=( + one_mass + ), + surviving_mass=( + zero_mass + + one_mass + ), + primitive_cost=( + cost + ), + information_product=( + information_product + ), + value_per_cost=Fraction( + information_product, + cost, + ), + worst_case_mass=max( + zero_mass, + one_mass, + ), + zero_count=len( + zero_ids + ), + one_count=len( + one_ids + ), + ) + ) + + if not rows: + raise RuntimeError( + "no discriminating causal intervention remains" + ) + + rows.sort( + key=lambda row: ( + -row.value_per_cost, + row.worst_case_mass, + -min( + row.zero_count, + row.one_count, + ), + row.primitive_cost, + row.configuration, + ) + ) + + return rows[0] diff --git a/core/cognition/causal_memory.py b/core/cognition/causal_memory.py new file mode 100644 index 0000000..fa14bc4 --- /dev/null +++ b/core/cognition/causal_memory.py @@ -0,0 +1,322 @@ +"""Persistent causal-program memory for PRIME M24.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .causal_certificate import ( + CausalAuthorization, +) +from .causal_program import ( + CausalProgram, + ProgramOp, + program_lookup, + program_universe, +) + + +@dataclass +class CausalMemoryEntry: + program_id: str + times_verified: int = 0 + successful_reuses: int = 0 + failed_reuses: int = 0 + last_sequence: int = 0 + + +@dataclass(frozen=True) +class CausalSchema: + operator: ProgramOp + normalized_offsets: tuple[ + int, + ..., + ] + support: int + + +def schema_descriptor( + program: CausalProgram, +): + if ( + program.op + not in ( + ProgramOp.AND, + ProgramOp.OR, + ProgramOp.XOR, + ProgramOp.EQ, + ) + ): + return None + + minimum = min( + program.variables + ) + + offsets = tuple( + variable + - minimum + for variable + in program.variables + ) + + return ( + program.op, + offsets, + ) + + +class CausalProgramMemory: + def __init__(self) -> None: + self.entries: dict[ + str, + CausalMemoryEntry, + ] = {} + + self.sequence = 0 + + def ingest( + self, + authorization: ( + CausalAuthorization + ), + ) -> None: + if not authorization.verdict: + raise PermissionError( + "rejected causal program " + "cannot enter semantic memory" + ) + + if ( + authorization.program_id + not in program_lookup() + ): + raise KeyError( + "unknown causal program" + ) + + self.sequence += 1 + + entry = ( + self.entries.setdefault( + authorization.program_id, + CausalMemoryEntry( + program_id=( + authorization.program_id + ) + ), + ) + ) + + entry.times_verified += 1 + + entry.last_sequence = ( + self.sequence + ) + + def record_reuse( + self, + program_id: str, + *, + success: bool, + ) -> None: + entry = ( + self.entries.get( + program_id + ) + ) + + if entry is None: + return + + if success: + entry.successful_reuses += 1 + else: + entry.failed_reuses += 1 + + def schemas( + self, + ) -> tuple[ + CausalSchema, + ..., + ]: + lookup = ( + program_lookup() + ) + + groups: dict[ + tuple[ + ProgramOp, + tuple[int, ...], + ], + set[str], + ] = {} + + for program_id in ( + self.entries + ): + program = lookup[ + program_id + ] + + descriptor = ( + schema_descriptor( + program + ) + ) + + if descriptor is None: + continue + + groups.setdefault( + descriptor, + set(), + ).add( + program_id + ) + + rows = [] + + for ( + operator, + offsets, + ), examples in groups.items(): + if len(examples) < 2: + continue + + rows.append( + CausalSchema( + operator=operator, + normalized_offsets=( + offsets + ), + support=len( + examples + ), + ) + ) + + rows.sort( + key=lambda row: ( + -row.support, + row.operator.value, + row.normalized_offsets, + ) + ) + + return tuple( + rows + ) + + def _schema_generated_ids( + self, + ) -> dict[str, int]: + universe = ( + program_universe() + ) + + scores: dict[ + str, + int, + ] = {} + + for schema in ( + self.schemas() + ): + for program in universe: + descriptor = ( + schema_descriptor( + program + ) + ) + + if descriptor != ( + schema.operator, + schema.normalized_offsets, + ): + continue + + scores[ + program.program_id + ] = max( + scores.get( + program.program_id, + 0, + ), + ( + 175 + + 70 + * schema.support + ), + ) + + return scores + + def priority_program_ids( + self, + *, + limit: int = 8, + ) -> tuple[str, ...]: + scores: dict[ + str, + int, + ] = {} + + for program_id, entry in ( + self.entries.items() + ): + age = ( + self.sequence + - entry.last_sequence + ) + + scores[ + program_id + ] = ( + 220 + + 80 + * entry.times_verified + + 35 + * entry.successful_reuses + - 55 + * entry.failed_reuses + + max( + 0, + 40 + - 5 + * age + ) + ) + + for ( + program_id, + schema_score, + ) in ( + self._schema_generated_ids().items() + ): + scores[ + program_id + ] = max( + scores.get( + program_id, + 0, + ), + schema_score, + ) + + ordered = sorted( + scores, + key=lambda program_id: ( + -scores[ + program_id + ], + program_lookup()[ + program_id + ].label, + ), + ) + + return tuple( + ordered[ + :limit + ] + ) diff --git a/core/cognition/causal_program.py b/core/cognition/causal_program.py new file mode 100644 index 0000000..a9770a8 --- /dev/null +++ b/core/cognition/causal_program.py @@ -0,0 +1,342 @@ +"""Explicit causal-program language for PRIME M24.""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum +from functools import lru_cache +import hashlib +import json +from itertools import combinations, product + + +VARIABLE_NAMES = ( + "A", + "B", + "C", + "D", +) + +CONFIGURATIONS = tuple( + product( + (0, 1), + repeat=len( + VARIABLE_NAMES + ), + ) +) + + +class ProgramOp(str, Enum): + VAR = "VAR" + NOT = "NOT" + AND = "AND" + OR = "OR" + XOR = "XOR" + EQ = "EQ" + + +@dataclass(frozen=True) +class CausalProgram: + op: ProgramOp + variables: tuple[int, ...] + + def __post_init__( + self, + ) -> None: + variables = tuple( + sorted( + self.variables + ) + ) + + if ( + len(set(variables)) + != len(variables) + ): + raise ValueError( + "causal-program variables must be unique" + ) + + if not all( + 0 <= variable + < len( + VARIABLE_NAMES + ) + for variable + in variables + ): + raise ValueError( + "invalid causal-program variable" + ) + + if ( + self.op + in ( + ProgramOp.VAR, + ProgramOp.NOT, + ) + and len(variables) + != 1 + ): + raise ValueError( + "VAR/NOT require one variable" + ) + + if ( + self.op + == ProgramOp.EQ + and len(variables) + != 2 + ): + raise ValueError( + "EQ requires exactly two variables" + ) + + if ( + self.op + in ( + ProgramOp.AND, + ProgramOp.OR, + ProgramOp.XOR, + ) + and not ( + 2 + <= len(variables) + <= 4 + ) + ): + raise ValueError( + "AND/OR/XOR require 2..4 variables" + ) + + object.__setattr__( + self, + "variables", + variables, + ) + + @property + def label(self) -> str: + names = tuple( + VARIABLE_NAMES[index] + for index + in self.variables + ) + + if self.op == ProgramOp.VAR: + return names[0] + + if self.op == ProgramOp.NOT: + return ( + "NOT(" + + names[0] + + ")" + ) + + return ( + self.op.value + + "(" + + ",".join(names) + + ")" + ) + + @property + def program_id(self) -> str: + payload = { + "op": self.op.value, + "variables": list( + self.variables + ), + } + + digest = hashlib.sha256( + json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + ).hexdigest() + + return ( + "cp:" + + digest + ) + + def evaluate( + self, + configuration: tuple[ + int, + ..., + ], + ) -> int: + values = [ + configuration[index] + for index + in self.variables + ] + + if self.op == ProgramOp.VAR: + return values[0] + + if self.op == ProgramOp.NOT: + return ( + 1 + - values[0] + ) + + if self.op == ProgramOp.AND: + result = 1 + + for value in values: + result &= value + + return result + + if self.op == ProgramOp.OR: + result = 0 + + for value in values: + result |= value + + return result + + if self.op == ProgramOp.XOR: + result = 0 + + for value in values: + result ^= value + + return result + + if self.op == ProgramOp.EQ: + return int( + values[0] + == values[1] + ) + + raise ValueError( + self.op + ) + + @property + def signature( + self, + ) -> tuple[int, ...]: + return tuple( + self.evaluate( + configuration + ) + for configuration + in CONFIGURATIONS + ) + + +@lru_cache(maxsize=1) +def program_universe( +) -> tuple[ + CausalProgram, + ..., +]: + programs = [] + + for variable in range(4): + programs.append( + CausalProgram( + ProgramOp.VAR, + (variable,), + ) + ) + + programs.append( + CausalProgram( + ProgramOp.NOT, + (variable,), + ) + ) + + for op in ( + ProgramOp.AND, + ProgramOp.OR, + ProgramOp.XOR, + ProgramOp.EQ, + ): + for pair in combinations( + range(4), + 2, + ): + programs.append( + CausalProgram( + op, + pair, + ) + ) + + for op in ( + ProgramOp.AND, + ProgramOp.OR, + ProgramOp.XOR, + ): + for triple in combinations( + range(4), + 3, + ): + programs.append( + CausalProgram( + op, + triple, + ) + ) + + programs.append( + CausalProgram( + op, + ( + 0, + 1, + 2, + 3, + ), + ) + ) + + programs.sort( + key=lambda program: ( + program.label + ) + ) + + ids = { + program.program_id + for program + in programs + } + + signatures = { + program.signature + for program + in programs + } + + if len(ids) != 47: + raise RuntimeError( + "unexpected M24 program count" + ) + + if len(signatures) != 47: + raise RuntimeError( + "causal program quotient collision" + ) + + return tuple( + programs + ) + + +def program_lookup( +) -> dict[str, CausalProgram]: + return { + program.program_id: program + for program + in program_universe() + } diff --git a/core/cognition/engine.py b/core/cognition/engine.py new file mode 100644 index 0000000..6e2e801 --- /dev/null +++ b/core/cognition/engine.py @@ -0,0 +1,310 @@ +"""Integrated PRIME M21 persistent adaptive cognition engine.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.registry import ( + ConstructionRegistry, +) + +from .causal_memory import ( + CausalProgramMemory, +) +from .episodic import ( + EpisodicMemory, +) +from .memory import ( + VerifiedConstructionMemory, +) +from .meta import ( + MetaLearningLedger, +) +from .planner import ( + VerifiedPlanner, +) +from .proposal_field import ( + DistributedProposalField, +) +from .schema import ( + SchemaMiner, +) +from .study import ( + ActiveStudySelector, + StudyAction, +) +from .transfer import ( + TransferEngine, + TransferProposal, +) +from .world_model import ( + TransitionVerifier, + VerifiedWorldModel, +) + + +@dataclass(frozen=True) +class CognitionSnapshot: + semantic_memory_classes: int + episodes: int + verified_transition_rules: int + meta_sources: int + + +class MegaPrimeCognition: + """Persistent cognitive layer above frozen M20 construction.""" + + def __init__(self) -> None: + self.semantic_memory = ( + VerifiedConstructionMemory() + ) + + self.causal_program_memory = ( + CausalProgramMemory() + ) + + self.episodic_memory = ( + EpisodicMemory() + ) + + self.proposal_field = ( + DistributedProposalField() + ) + + self.meta_memory = ( + MetaLearningLedger() + ) + + self.transfer_engine = ( + TransferEngine( + self.semantic_memory, + self.proposal_field, + ) + ) + + self.study_selector = ( + ActiveStudySelector() + ) + + self.world_model = ( + VerifiedWorldModel() + ) + + self.transition_verifier = ( + TransitionVerifier() + ) + + self.planner = ( + VerifiedPlanner( + self.world_model + ) + ) + + self.schema_miner = ( + SchemaMiner() + ) + + def close_world( + self, + registry: ConstructionRegistry, + *, + context_id: str, + context_tokens: tuple[ + str, + ..., + ], + reward_ppm: int, + tensions: tuple[ + str, + ..., + ] = (), + studies: tuple[ + str, + ..., + ] = (), + ) -> tuple[str, ...]: + touched = ( + self.semantic_memory.ingest_registry( + registry, + context_id=context_id, + ) + ) + + self.episodic_memory.append( + context_id=context_id, + context_tokens=( + context_tokens + ), + verified_construction_ids=tuple( + sorted( + registry.active_ids() + ) + ), + reward_ppm=( + reward_ppm + ), + tensions=tensions, + studies=studies, + ) + + return touched + + def open_world( + self, + registry: ConstructionRegistry, + *, + context_tokens: tuple[ + str, + ..., + ], + max_transfer: int = 32, + ) -> tuple[ + TransferProposal, + ..., + ]: + proposals = ( + self.transfer_engine.recall( + context_tokens=( + context_tokens + ), + max_candidates=( + max_transfer + ), + ) + ) + + self.transfer_engine.stage( + registry, + proposals, + ) + + return proposals + + def record_transfer_result( + self, + proposal: TransferProposal, + *, + context_tokens: tuple[ + str, + ..., + ], + accepted: bool, + gain_ppm: int, + ) -> None: + self.semantic_memory.record_transfer_outcome( + proposal.memory_id, + accepted=accepted, + gain_ppm=gain_ppm, + ) + + self.proposal_field.update( + proposal.spec, + context_tokens, + accepted=accepted, + gain_ppm=gain_ppm, + ) + + self.meta_memory.record( + "cross-world-transfer", + accepted=accepted, + gain_ppm=gain_ppm, + ) + + def choose_study( + self, + actions: tuple[ + StudyAction, + ..., + ], + ): + ranked = ( + self.study_selector.rank( + actions + ) + ) + + if not ranked: + return None + + return ranked[0] + + def observe_transition( + self, + state: tuple[int, ...], + action: str, + next_state: tuple[int, ...], + ) -> None: + self.world_model.observe( + state, + action, + next_state, + ) + + def verify_transition( + self, + state: tuple[int, ...], + action: str, + ): + candidate = ( + self.world_model.propose_rule( + state, + action, + ) + ) + + if candidate is None: + return None + + authorization = ( + self.transition_verifier.authorize( + candidate + ) + ) + + if authorization.verdict: + self.world_model.apply( + authorization + ) + + return ( + candidate, + authorization, + ) + + def plan( + self, + start_state: tuple[int, ...], + goal_state: tuple[int, ...], + *, + max_depth: int = 16, + ): + return self.planner.plan( + start_state, + goal_state, + max_depth=max_depth, + ) + + def mine_schemas(self): + return ( + self.schema_miner.mine( + self.semantic_memory + ) + ) + + def snapshot( + self, + ) -> CognitionSnapshot: + return CognitionSnapshot( + semantic_memory_classes=len( + self.semantic_memory.entries + ), + episodes=len( + self.episodic_memory.records + ), + verified_transition_rules=len( + self.world_model.verified + ), + meta_sources=len( + self.meta_memory.sources + ), + ) diff --git a/core/cognition/episodic.py b/core/cognition/episodic.py new file mode 100644 index 0000000..17b0ebd --- /dev/null +++ b/core/cognition/episodic.py @@ -0,0 +1,230 @@ +"""Hash-chained episodic memory for PRIME M21.""" + +from __future__ import annotations + +from dataclasses import dataclass +import hashlib +import json +from pathlib import Path + + +ZERO_HASH = "0" * 64 + + +def _canonical( + payload: dict, +) -> bytes: + return json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + + +@dataclass(frozen=True) +class EpisodeRecord: + sequence: int + context_id: str + context_tokens: tuple[str, ...] + verified_construction_ids: ( + tuple[str, ...] + ) + reward_ppm: int + tensions: tuple[str, ...] + studies: tuple[str, ...] + parent_hash: str + episode_hash: str + + def payload_without_hash( + self, + ) -> dict: + return { + "sequence": self.sequence, + "context_id": ( + self.context_id + ), + "context_tokens": list( + self.context_tokens + ), + "verified_construction_ids": list( + self.verified_construction_ids + ), + "reward_ppm": ( + self.reward_ppm + ), + "tensions": list( + self.tensions + ), + "studies": list( + self.studies + ), + "parent_hash": ( + self.parent_hash + ), + } + + +class EpisodicMemory: + FORMAT = "prime-m21-episodic-memory-v1" + + def __init__(self) -> None: + self.records: list[ + EpisodeRecord + ] = [] + + @property + def head_hash(self) -> str: + if not self.records: + return ZERO_HASH + + return self.records[ + -1 + ].episode_hash + + def append( + self, + *, + context_id: str, + context_tokens: tuple[ + str, + ..., + ], + verified_construction_ids: ( + tuple[str, ...] + ), + reward_ppm: int, + tensions: tuple[ + str, + ..., + ] = (), + studies: tuple[ + str, + ..., + ] = (), + ) -> EpisodeRecord: + payload = { + "sequence": len( + self.records + ), + "context_id": ( + context_id + ), + "context_tokens": list( + context_tokens + ), + "verified_construction_ids": list( + verified_construction_ids + ), + "reward_ppm": reward_ppm, + "tensions": list( + tensions + ), + "studies": list( + studies + ), + "parent_hash": ( + self.head_hash + ), + } + + episode_hash = ( + hashlib.sha256( + _canonical( + payload + ) + ).hexdigest() + ) + + record = EpisodeRecord( + sequence=payload[ + "sequence" + ], + context_id=context_id, + context_tokens=( + context_tokens + ), + verified_construction_ids=( + verified_construction_ids + ), + reward_ppm=reward_ppm, + tensions=tensions, + studies=studies, + parent_hash=payload[ + "parent_hash" + ], + episode_hash=( + episode_hash + ), + ) + + self.records.append( + record + ) + + return record + + def verify_chain(self) -> bool: + parent = ZERO_HASH + + for index, record in ( + enumerate( + self.records + ) + ): + if ( + record.sequence + != index + ): + return False + + if ( + record.parent_hash + != parent + ): + return False + + expected = ( + hashlib.sha256( + _canonical( + record.payload_without_hash() + ) + ).hexdigest() + ) + + if ( + expected + != record.episode_hash + ): + return False + + parent = ( + record.episode_hash + ) + + return True + + def save( + self, + path: str | Path, + ) -> None: + payload = { + "format": self.FORMAT, + "records": [ + { + **record.payload_without_hash(), + "episode_hash": ( + record.episode_hash + ), + } + for record in self.records + ], + } + + Path(path).write_text( + json.dumps( + payload, + sort_keys=True, + indent=2, + ) + + "\n" + ) diff --git a/core/cognition/hypothesis_ecology.py b/core/cognition/hypothesis_ecology.py new file mode 100644 index 0000000..d5e89b9 --- /dev/null +++ b/core/cognition/hypothesis_ecology.py @@ -0,0 +1,333 @@ +"""Weighted hypothesis ecology for PRIME M22. + +Past-only cognition may redistribute current-epoch verifier budget across +explicit candidate hypotheses. + +It may not remove the universal candidate field and it may not authorize any +candidate. +""" + +from __future__ import annotations + +from dataclasses import dataclass, replace + +from core.construction.evidence import ( + EvidenceEpoch, + global_epoch_alpha_denominator, +) +from core.construction.types import ( + ConstructionSpec, +) + + +@dataclass(frozen=True) +class HypothesisAllocation: + mass_by_id: dict[str, int] + total_mass: int + priority_ids: tuple[str, ...] + baseline_mass: int + bonus_pool: int + + def threshold_for( + self, + construction_id: str, + *, + epoch_index: int, + ) -> int: + mass = self.mass_by_id[ + construction_id + ] + + denominator = ( + global_epoch_alpha_denominator( + epoch_index + ) + ) + + numerator = ( + denominator + * self.total_mass + ) + + return ( + numerator + + mass + - 1 + ) // mass + + +def allocate_hypothesis_mass( + candidates: tuple[ + ConstructionSpec, + ..., + ], + *, + priority_ids: tuple[ + str, + ..., + ], + baseline_mass: int = 16, +) -> HypothesisAllocation: + """50/50 safety/prior mixture. + + Every candidate receives baseline mass. + + A bonus pool equal to the entire baseline pool is distributed across + past-informed candidates by deterministic rank. + + Therefore prior knowledge may concentrate at most approximately half of + the total verifier alpha mass. + + The universal field always retains at least approximately half. + """ + + if baseline_mass <= 0: + raise ValueError( + "baseline_mass must be positive" + ) + + candidate_ids = tuple( + spec.construction_id + for spec in candidates + ) + + if len(set(candidate_ids)) != len( + candidate_ids + ): + raise ValueError( + "duplicate candidate identity" + ) + + mass_by_id = { + construction_id: ( + baseline_mass + ) + for construction_id + in candidate_ids + } + + seen = set() + + active_priority = [] + + for construction_id in ( + priority_ids + ): + if construction_id in seen: + continue + + if construction_id not in ( + mass_by_id + ): + continue + + seen.add( + construction_id + ) + + active_priority.append( + construction_id + ) + + baseline_total = ( + baseline_mass + * len(candidate_ids) + ) + + bonus_pool = ( + baseline_total + if active_priority + else 0 + ) + + if active_priority: + count = len( + active_priority + ) + + rank_total = ( + count + * ( + count + + 1 + ) + // 2 + ) + + for index, construction_id in ( + enumerate( + active_priority + ) + ): + rank_weight = ( + count + - index + ) + + bonus = ( + bonus_pool + * rank_weight + // rank_total + ) + + mass_by_id[ + construction_id + ] += bonus + + total_mass = sum( + mass_by_id.values() + ) + + return HypothesisAllocation( + mass_by_id=mass_by_id, + total_mass=total_mass, + priority_ids=tuple( + active_priority + ), + baseline_mass=baseline_mass, + bonus_pool=bonus_pool, + ) + + +class WeightedEvidenceEpoch( + EvidenceEpoch +): + """M20 evidence with candidate-specific predictable alpha weights.""" + + def __init__( + self, + candidates: tuple[ + ConstructionSpec, + ..., + ], + *, + epoch_index: int, + allocation: ( + HypothesisAllocation + ), + ) -> None: + super().__init__( + candidates, + epoch_index=epoch_index, + ) + + candidate_ids = { + spec.construction_id + for spec in candidates + } + + if candidate_ids != set( + allocation.mass_by_id + ): + raise ValueError( + "allocation/candidate mismatch" + ) + + self.allocation = allocation + self.weighted_epoch_index = ( + epoch_index + ) + + self.thresholds = { + construction_id: ( + allocation.threshold_for( + construction_id, + epoch_index=( + epoch_index + ), + ) + ) + for construction_id + in candidate_ids + } + + # Compatibility / diagnostic summary only. + # Authorization uses threshold_for(). + self.threshold = max( + self.thresholds.values(), + default=( + global_epoch_alpha_denominator( + epoch_index + ) + ), + ) + + def threshold_for( + self, + construction_id: str, + ) -> int: + return self.thresholds[ + construction_id + ] + + def supported_ids( + self, + ) -> tuple[str, ...]: + return tuple( + construction_id + for ( + construction_id, + tracker, + ) + in self.trackers.items() + if tracker.supported( + self.threshold_for( + construction_id + ) + ) + ) + + def snapshot( + self, + construction_id: str, + *, + authorization_event_index=( + None + ), + ): + base = super().snapshot( + construction_id, + authorization_event_index=( + authorization_event_index + ), + ) + + tracker = self.trackers[ + construction_id + ] + + threshold = ( + self.threshold_for( + construction_id + ) + ) + + statistical = ( + tracker.statistical_pass( + threshold + ) + ) + + structural = ( + tracker.structural_pass() + ) + + return replace( + base, + threshold=threshold, + evidence_rhs=( + tracker.evidence_rhs( + threshold + ) + ), + statistical_pass=( + statistical + ), + structural_pass=( + structural + ), + supported=( + statistical + and structural + ), + ) diff --git a/core/cognition/memory.py b/core/cognition/memory.py new file mode 100644 index 0000000..796da17 --- /dev/null +++ b/core/cognition/memory.py @@ -0,0 +1,408 @@ +"""Persistent verifier-backed semantic construction memory.""" + +from __future__ import annotations + +from dataclasses import dataclass, field +import json +from pathlib import Path + +from core.construction.grammar import ( + binary, + description_length, + lag, +) +from core.construction.quotient import ( + predictive_partition_signature, +) +from core.construction.receipts import ( + verify_receipt_chain, +) +from core.construction.registry import ( + ConstructionRegistry, +) +from core.construction.types import ( + ConstructionSpec, + FeatureExpr, + FeatureOp, + expr_from_dict, +) + + +def expand_references( + expr: FeatureExpr, + lookup: dict[str, FeatureExpr], + stack: tuple[str, ...] = (), +) -> FeatureExpr: + """Convert a registry-dependent expression into a portable expression.""" + + if expr.op == FeatureOp.LAG: + assert expr.lag is not None + return lag(expr.lag) + + if expr.op == FeatureOp.REF: + assert expr.ref_id is not None + + if expr.ref_id in stack: + raise ValueError( + "cyclic construction dependency" + ) + + target = lookup.get( + expr.ref_id + ) + + if target is None: + raise KeyError( + "unresolved construction reference: " + + expr.ref_id + ) + + return expand_references( + target, + lookup, + stack + (expr.ref_id,), + ) + + assert expr.left is not None + assert expr.right is not None + + return binary( + expr.op, + expand_references( + expr.left, + lookup, + stack, + ), + expand_references( + expr.right, + lookup, + stack, + ), + ) + + +@dataclass +class SemanticMemoryEntry: + memory_id: str + spec: ConstructionSpec + quotient_signature: int + contexts: set[str] = field( + default_factory=set + ) + observations: int = 0 + successful_transfers: int = 0 + failed_transfers: int = 0 + cumulative_gain_ppm: int = 0 + + @property + def complexity(self) -> int: + return description_length( + self.spec.expression + ) + + +class VerifiedConstructionMemory: + """Persistent memory grouped by predictive quotient.""" + + FORMAT = "prime-m21-semantic-memory-v1" + + def __init__(self) -> None: + self.entries: dict[ + str, + SemanticMemoryEntry, + ] = {} + + @staticmethod + def _memory_id( + quotient_signature: int, + ) -> str: + return ( + "pq:" + + format( + quotient_signature, + "x", + ) + ) + + def ingest_registry( + self, + registry: ConstructionRegistry, + *, + context_id: str, + ) -> tuple[str, ...]: + receipts = ( + registry.receipts.records + ) + + if not verify_receipt_chain( + receipts, + expected_count=len( + receipts + ), + ): + raise ValueError( + "registry receipt chain invalid" + ) + + lookup = { + construction_id: ( + record.spec.expression + ) + for construction_id, record + in registry._records.items() + } + + touched = [] + + for record in ( + registry.active_records() + ): + portable = ( + expand_references( + record.spec.expression, + lookup, + ) + ) + + signature = ( + predictive_partition_signature( + portable, + max_lag=8, + ) + ) + + memory_id = ( + self._memory_id( + signature + ) + ) + + portable_spec = ( + ConstructionSpec( + expression=portable, + proposal_source=( + "verified-semantic-memory" + ), + ) + ) + + current = ( + self.entries.get( + memory_id + ) + ) + + if current is None: + current = ( + SemanticMemoryEntry( + memory_id=memory_id, + spec=portable_spec, + quotient_signature=( + signature + ), + ) + ) + + self.entries[ + memory_id + ] = current + + elif ( + description_length( + portable_spec.expression + ) + < + description_length( + current.spec.expression + ) + ): + # Prefer the simpler representative of the same + # predictive quotient class. + current.spec = ( + portable_spec + ) + + current.contexts.add( + context_id + ) + + current.observations += 1 + + touched.append( + memory_id + ) + + return tuple( + sorted( + set(touched) + ) + ) + + def record_transfer_outcome( + self, + memory_id: str, + *, + accepted: bool, + gain_ppm: int, + ) -> None: + entry = self.entries[ + memory_id + ] + + if accepted: + entry.successful_transfers += 1 + else: + entry.failed_transfers += 1 + + entry.cumulative_gain_ppm += ( + gain_ppm + ) + + def to_dict(self) -> dict: + return { + "format": self.FORMAT, + "entries": [ + { + "memory_id": ( + entry.memory_id + ), + "expression": ( + entry.spec.expression.to_dict() + ), + "quotient_signature": ( + str( + entry.quotient_signature + ) + ), + "contexts": sorted( + entry.contexts + ), + "observations": ( + entry.observations + ), + "successful_transfers": ( + entry.successful_transfers + ), + "failed_transfers": ( + entry.failed_transfers + ), + "cumulative_gain_ppm": ( + entry.cumulative_gain_ppm + ), + } + for entry + in sorted( + self.entries.values(), + key=lambda row: ( + row.memory_id + ), + ) + ], + } + + def save( + self, + path: str | Path, + ) -> None: + Path(path).write_text( + json.dumps( + self.to_dict(), + sort_keys=True, + indent=2, + ) + + "\n" + ) + + @classmethod + def load( + cls, + path: str | Path, + ) -> "VerifiedConstructionMemory": + payload = json.loads( + Path(path).read_text() + ) + + if ( + payload.get("format") + != cls.FORMAT + ): + raise ValueError( + "unsupported semantic memory format" + ) + + memory = cls() + + for row in payload[ + "entries" + ]: + expression = ( + expr_from_dict( + row[ + "expression" + ] + ) + ) + + spec = ConstructionSpec( + expression=expression, + proposal_source=( + "verified-semantic-memory" + ), + ) + + entry = SemanticMemoryEntry( + memory_id=row[ + "memory_id" + ], + spec=spec, + quotient_signature=int( + row[ + "quotient_signature" + ] + ), + contexts=set( + row[ + "contexts" + ] + ), + observations=int( + row[ + "observations" + ] + ), + successful_transfers=int( + row[ + "successful_transfers" + ] + ), + failed_transfers=int( + row[ + "failed_transfers" + ] + ), + cumulative_gain_ppm=int( + row[ + "cumulative_gain_ppm" + ] + ), + ) + + expected_id = ( + cls._memory_id( + entry.quotient_signature + ) + ) + + if ( + expected_id + != entry.memory_id + ): + raise ValueError( + "semantic memory identity mismatch" + ) + + memory.entries[ + entry.memory_id + ] = entry + + return memory diff --git a/core/cognition/meta.py b/core/cognition/meta.py new file mode 100644 index 0000000..cfbe289 --- /dev/null +++ b/core/cognition/meta.py @@ -0,0 +1,72 @@ +"""Meta-learning ledger for PRIME M21.""" + +from __future__ import annotations + +from dataclasses import dataclass + + +@dataclass +class ProposalSourceStats: + attempts: int = 0 + accepted: int = 0 + rejected: int = 0 + cumulative_gain_ppm: int = 0 + + @property + def priority(self) -> int: + return ( + 100 + * self.accepted + - 120 + * self.rejected + + ( + self.cumulative_gain_ppm + // 10_000 + ) + ) + + +class MetaLearningLedger: + def __init__(self) -> None: + self.sources: dict[ + str, + ProposalSourceStats, + ] = {} + + def record( + self, + source: str, + *, + accepted: bool, + gain_ppm: int, + ) -> None: + stats = ( + self.sources.setdefault( + source, + ProposalSourceStats(), + ) + ) + + stats.attempts += 1 + + if accepted: + stats.accepted += 1 + else: + stats.rejected += 1 + + stats.cumulative_gain_ppm += ( + gain_ppm + ) + + def priority( + self, + source: str, + ) -> int: + stats = self.sources.get( + source + ) + + if stats is None: + return 0 + + return stats.priority diff --git a/core/cognition/planner.py b/core/cognition/planner.py new file mode 100644 index 0000000..6bf2a31 --- /dev/null +++ b/core/cognition/planner.py @@ -0,0 +1,138 @@ +"""Planning over verifier-authorized transition structure.""" + +from __future__ import annotations + +from collections import deque +from dataclasses import dataclass + +from .world_model import ( + VerifiedWorldModel, +) + + +@dataclass(frozen=True) +class VerifiedPlan: + start_state: tuple[int, ...] + goal_state: tuple[int, ...] + actions: tuple[str, ...] + states: tuple[ + tuple[int, ...], + ..., + ] + canonical_support: bool = True + + +class VerifiedPlanner: + def __init__( + self, + world_model: ( + VerifiedWorldModel + ), + ) -> None: + self.world_model = ( + world_model + ) + + def plan( + self, + start_state: tuple[int, ...], + goal_state: tuple[int, ...], + *, + max_depth: int = 16, + ) -> VerifiedPlan | None: + if start_state == goal_state: + return VerifiedPlan( + start_state=start_state, + goal_state=goal_state, + actions=(), + states=( + start_state, + ), + ) + + queue = deque( + [ + ( + start_state, + (), + ( + start_state, + ), + ) + ] + ) + + visited = { + start_state + } + + while queue: + ( + state, + actions, + states, + ) = queue.popleft() + + if ( + len(actions) + >= max_depth + ): + continue + + for ( + action, + next_state, + ) in ( + self.world_model.verified_successors( + state + ) + ): + if next_state in visited: + continue + + next_actions = ( + actions + + ( + action, + ) + ) + + next_states = ( + states + + ( + next_state, + ) + ) + + if ( + next_state + == goal_state + ): + return VerifiedPlan( + start_state=( + start_state + ), + goal_state=( + goal_state + ), + actions=( + next_actions + ), + states=( + next_states + ), + ) + + visited.add( + next_state + ) + + queue.append( + ( + next_state, + next_actions, + next_states, + ) + ) + + return None diff --git a/core/cognition/proposal_field.py b/core/cognition/proposal_field.py new file mode 100644 index 0000000..19637e9 --- /dev/null +++ b/core/cognition/proposal_field.py @@ -0,0 +1,290 @@ +"""Deterministic distributed proposal-ranking field.""" + +from __future__ import annotations + +from dataclasses import dataclass +import hashlib + +from core.construction.types import ( + ConstructionSpec, + FeatureExpr, + FeatureOp, +) + + +FIELD_DIMENSION = 256 + + +def _expression_tokens( + expr: FeatureExpr, + *, + depth: int = 0, +) -> tuple[str, ...]: + tokens = [ + "op:" + expr.op.value, + "depth:" + str(depth), + ] + + if expr.op == FeatureOp.LAG: + assert expr.lag is not None + + tokens.extend( + ( + "lag:" + str(expr.lag), + "lag-band:" + + str( + expr.lag.bit_length() + ), + ) + ) + + elif expr.op == FeatureOp.REF: + tokens.append( + "ref" + ) + + else: + assert expr.left is not None + assert expr.right is not None + + tokens.extend( + _expression_tokens( + expr.left, + depth=depth + 1, + ) + ) + + tokens.extend( + _expression_tokens( + expr.right, + depth=depth + 1, + ) + ) + + return tuple(tokens) + + +def _feature( + token: str, +) -> tuple[int, int]: + digest = hashlib.sha256( + token.encode( + "utf-8" + ) + ).digest() + + index = ( + int.from_bytes( + digest[:4], + "big", + ) + % FIELD_DIMENSION + ) + + sign = ( + 1 + if digest[4] & 1 + else -1 + ) + + return ( + index, + sign, + ) + + +def sparse_features( + spec: ConstructionSpec, + context_tokens: tuple[ + str, + ..., + ], +) -> dict[int, int]: + result: dict[ + int, + int, + ] = {} + + tokens = list( + _expression_tokens( + spec.expression + ) + ) + + tokens.extend( + "context:" + token + for token + in context_tokens + ) + + for token in tokens: + index, sign = ( + _feature( + token + ) + ) + + result[index] = ( + result.get( + index, + 0, + ) + + sign + ) + + return result + + +@dataclass(frozen=True) +class RankedCandidate: + construction_id: str + score: int + + +class DistributedProposalField: + """Small deterministic online learned routing field. + + It changes ranking, never authority. + """ + + def __init__(self) -> None: + self.weights = [ + 0 + for _ in range( + FIELD_DIMENSION + ) + ] + + self.bias: dict[ + str, + int, + ] = {} + + def score( + self, + spec: ConstructionSpec, + context_tokens: tuple[ + str, + ..., + ], + ) -> int: + features = ( + sparse_features( + spec, + context_tokens, + ) + ) + + total = self.bias.get( + spec.construction_id, + 0, + ) + + for index, value in ( + features.items() + ): + total += ( + self.weights[ + index + ] + * value + ) + + return total + + def update( + self, + spec: ConstructionSpec, + context_tokens: tuple[ + str, + ..., + ], + *, + accepted: bool, + gain_ppm: int, + ) -> None: + magnitude = max( + 1, + min( + 100, + abs( + gain_ppm + ) + // 10_000 + + 1, + ), + ) + + direction = ( + 1 + if accepted + else -1 + ) + + step = ( + direction + * magnitude + ) + + features = ( + sparse_features( + spec, + context_tokens, + ) + ) + + for index, value in ( + features.items() + ): + self.weights[ + index + ] += ( + step + * value + ) + + self.bias[ + spec.construction_id + ] = ( + self.bias.get( + spec.construction_id, + 0, + ) + + step + ) + + def rank( + self, + specs: tuple[ + ConstructionSpec, + ..., + ], + context_tokens: tuple[ + str, + ..., + ], + ) -> tuple[ + RankedCandidate, + ..., + ]: + rows = [ + RankedCandidate( + construction_id=( + spec.construction_id + ), + score=self.score( + spec, + context_tokens, + ), + ) + for spec in specs + ] + + rows.sort( + key=lambda row: ( + -row.score, + row.construction_id, + ) + ) + + return tuple(rows) diff --git a/core/cognition/schema.py b/core/cognition/schema.py new file mode 100644 index 0000000..47d9e36 --- /dev/null +++ b/core/cognition/schema.py @@ -0,0 +1,214 @@ +"""Higher-order relation-schema proposal mining.""" + +from __future__ import annotations + +from dataclasses import dataclass +import hashlib +import json + +from core.construction.types import ( + FeatureExpr, + FeatureOp, +) + +from .memory import ( + VerifiedConstructionMemory, +) + + +@dataclass(frozen=True) +class SchemaProposal: + schema_id: str + operator: str + normalized_offsets: tuple[ + int, + ..., + ] + example_memory_ids: tuple[ + str, + ..., + ] + support: int + state_commit_authorized: bool = False + + +def _flatten( + expr: FeatureExpr, + op: FeatureOp, +) -> list[FeatureExpr]: + if expr.op != op: + return [ + expr + ] + + assert expr.left is not None + assert expr.right is not None + + return ( + _flatten( + expr.left, + op, + ) + + _flatten( + expr.right, + op, + ) + ) + + +def _raw_lag_pattern( + expr: FeatureExpr, +) -> tuple[ + str, + tuple[int, ...], +] | None: + if expr.op not in ( + FeatureOp.XOR, + FeatureOp.AND, + FeatureOp.OR, + FeatureOp.EQ, + ): + return None + + atoms = _flatten( + expr, + expr.op, + ) + + if not all( + atom.op + == FeatureOp.LAG + for atom in atoms + ): + return None + + lags = sorted( + atom.lag + for atom in atoms + if atom.lag is not None + ) + + if len(lags) < 2: + return None + + minimum = min( + lags + ) + + offsets = tuple( + lag_value + - minimum + for lag_value in lags + ) + + return ( + expr.op.value, + offsets, + ) + + +class SchemaMiner: + def mine( + self, + memory: ( + VerifiedConstructionMemory + ), + *, + minimum_examples: int = 2, + ) -> tuple[ + SchemaProposal, + ..., + ]: + groups: dict[ + tuple[ + str, + tuple[int, ...], + ], + list[str], + ] = {} + + for entry in ( + memory.entries.values() + ): + pattern = ( + _raw_lag_pattern( + entry.spec.expression + ) + ) + + if pattern is None: + continue + + groups.setdefault( + pattern, + [], + ).append( + entry.memory_id + ) + + proposals = [] + + for ( + operator, + offsets, + ), examples in groups.items(): + if ( + len(examples) + < minimum_examples + ): + continue + + payload = { + "operator": ( + operator + ), + "normalized_offsets": list( + offsets + ), + } + + schema_id = ( + "schema:" + + hashlib.sha256( + json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ).encode( + "utf-8" + ) + ).hexdigest() + ) + + proposals.append( + SchemaProposal( + schema_id=( + schema_id + ), + operator=( + operator + ), + normalized_offsets=( + offsets + ), + example_memory_ids=tuple( + sorted( + examples + ) + ), + support=len( + examples + ), + ) + ) + + proposals.sort( + key=lambda row: ( + -row.support, + row.schema_id, + ) + ) + + return tuple( + proposals + ) diff --git a/core/cognition/study.py b/core/cognition/study.py new file mode 100644 index 0000000..f3ea16d --- /dev/null +++ b/core/cognition/study.py @@ -0,0 +1,83 @@ +"""Active epistemic study selection.""" + +from __future__ import annotations + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class StudyAction: + action_id: str + candidate_predictions: dict[ + str, + int, + ] + cost: int = 0 + + +@dataclass(frozen=True) +class StudyProposal: + action_id: str + disagreement_pairs: int + score: int + state_commit_authorized: bool = False + + +class ActiveStudySelector: + """Rank interventions by hypothesis disagreement.""" + + def rank( + self, + actions: tuple[ + StudyAction, + ..., + ], + ) -> tuple[ + StudyProposal, + ..., + ]: + rows = [] + + for action in actions: + values = list( + action.candidate_predictions.values() + ) + + disagreement = 0 + + for i in range( + len(values) + ): + for j in range( + i + 1, + len(values), + ): + disagreement += int( + values[i] + != values[j] + ) + + rows.append( + StudyProposal( + action_id=( + action.action_id + ), + disagreement_pairs=( + disagreement + ), + score=( + 100 + * disagreement + - action.cost + ), + ) + ) + + rows.sort( + key=lambda row: ( + -row.score, + row.action_id, + ) + ) + + return tuple(rows) diff --git a/core/cognition/transfer.py b/core/cognition/transfer.py new file mode 100644 index 0000000..62a254c --- /dev/null +++ b/core/cognition/transfer.py @@ -0,0 +1,150 @@ +"""Cross-world verified-construction transfer.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.grammar import ( + description_length, +) +from core.construction.registry import ( + ConstructionRegistry, +) +from core.construction.types import ( + ConstructionSpec, +) + +from .memory import ( + VerifiedConstructionMemory, +) +from .proposal_field import ( + DistributedProposalField, +) + + +@dataclass(frozen=True) +class TransferProposal: + memory_id: str + spec: ConstructionSpec + score: int + reasons: tuple[str, ...] + state_commit_authorized: bool = False + + +class TransferEngine: + def __init__( + self, + memory: ( + VerifiedConstructionMemory + ), + field: ( + DistributedProposalField + ), + ) -> None: + self.memory = memory + self.field = field + + def recall( + self, + *, + context_tokens: tuple[ + str, + ..., + ], + max_candidates: int = 32, + ) -> tuple[ + TransferProposal, + ..., + ]: + proposals = [] + + for entry in ( + self.memory.entries.values() + ): + spec = ConstructionSpec( + expression=( + entry.spec.expression + ), + proposal_source=( + "cross-world-transfer" + ), + ) + + learned_score = ( + self.field.score( + spec, + context_tokens, + ) + ) + + prior = ( + 100 + * entry.successful_transfers + - 120 + * entry.failed_transfers + + ( + entry.cumulative_gain_ppm + // 10_000 + ) + + 4 + * len( + entry.contexts + ) + - description_length( + spec.expression + ) + ) + + proposals.append( + TransferProposal( + memory_id=( + entry.memory_id + ), + spec=spec, + score=( + learned_score + + prior + ), + reasons=( + "verified-memory", + "predictive-quotient", + "learned-routing", + ), + ) + ) + + proposals.sort( + key=lambda row: ( + -row.score, + row.memory_id, + row.spec.construction_id, + ) + ) + + return tuple( + proposals[ + :max_candidates + ] + ) + + def stage( + self, + registry: ConstructionRegistry, + proposals: tuple[ + TransferProposal, + ..., + ], + ) -> tuple[str, ...]: + staged = [] + + for proposal in proposals: + # Registry proposal is deliberately not authority. + registry.propose( + proposal.spec + ) + + staged.append( + proposal.spec.construction_id + ) + + return tuple(staged) diff --git a/core/cognition/world_model.py b/core/cognition/world_model.py new file mode 100644 index 0000000..1750096 --- /dev/null +++ b/core/cognition/world_model.py @@ -0,0 +1,304 @@ +"""Verifier-governed discrete transition world model.""" + +from __future__ import annotations + +from dataclasses import dataclass +import hashlib +import json + + +def _hash_payload( + payload: dict, +) -> str: + return hashlib.sha256( + json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + ).hexdigest() + + +@dataclass(frozen=True) +class TransitionCandidate: + rule_id: str + state: tuple[int, ...] + action: str + next_state: tuple[int, ...] + support: int + contradictions: int + + +@dataclass(frozen=True) +class TransitionAuthorization: + rule_id: str + verdict: bool + evidence_hash: str + reason: str + + +class VerifiedWorldModel: + """Separate proposed and verified transition structure.""" + + def __init__(self) -> None: + self.counts: dict[ + tuple[ + tuple[int, ...], + str, + ], + dict[ + tuple[int, ...], + int, + ], + ] = {} + + self.proposed: dict[ + str, + TransitionCandidate, + ] = {} + + self.verified: dict[ + tuple[ + tuple[int, ...], + str, + ], + TransitionCandidate, + ] = {} + + @staticmethod + def rule_id( + state: tuple[int, ...], + action: str, + next_state: tuple[int, ...], + ) -> str: + return ( + "tr:" + + _hash_payload( + { + "state": list( + state + ), + "action": action, + "next_state": list( + next_state + ), + } + ) + ) + + def observe( + self, + state: tuple[int, ...], + action: str, + next_state: tuple[int, ...], + ) -> None: + key = ( + state, + action, + ) + + outcomes = ( + self.counts.setdefault( + key, + {}, + ) + ) + + outcomes[ + next_state + ] = ( + outcomes.get( + next_state, + 0, + ) + + 1 + ) + + def propose_rule( + self, + state: tuple[int, ...], + action: str, + ) -> TransitionCandidate | None: + outcomes = self.counts.get( + ( + state, + action, + ) + ) + + if not outcomes: + return None + + ordered = sorted( + outcomes.items(), + key=lambda row: ( + -row[1], + row[0], + ), + ) + + next_state, support = ( + ordered[0] + ) + + total = sum( + outcomes.values() + ) + + candidate = ( + TransitionCandidate( + rule_id=self.rule_id( + state, + action, + next_state, + ), + state=state, + action=action, + next_state=( + next_state + ), + support=support, + contradictions=( + total + - support + ), + ) + ) + + self.proposed[ + candidate.rule_id + ] = candidate + + return candidate + + def apply( + self, + authorization: ( + TransitionAuthorization + ), + ) -> None: + candidate = ( + self.proposed.get( + authorization.rule_id + ) + ) + + if candidate is None: + raise KeyError( + "unknown transition proposal" + ) + + if not authorization.verdict: + raise PermissionError( + "failed transition verdict " + "cannot authorize world model" + ) + + self.verified[ + ( + candidate.state, + candidate.action, + ) + ] = candidate + + def step_verified( + self, + state: tuple[int, ...], + action: str, + ) -> tuple[int, ...] | None: + candidate = ( + self.verified.get( + ( + state, + action, + ) + ) + ) + + if candidate is None: + return None + + return candidate.next_state + + def verified_successors( + self, + state: tuple[int, ...], + ) -> tuple[ + tuple[ + str, + tuple[int, ...], + ], + ..., + ]: + rows = [ + ( + action, + rule.next_state, + ) + for ( + rule_state, + action, + ), rule + in self.verified.items() + if rule_state == state + ] + + rows.sort() + + return tuple(rows) + + +class TransitionVerifier: + """Initial conservative deterministic world-model gate. + + This is an architecture gate, not yet a scientific confidence claim. + """ + + MIN_SUPPORT = 16 + + def authorize( + self, + candidate: TransitionCandidate, + ) -> TransitionAuthorization: + verdict = ( + candidate.support + >= self.MIN_SUPPORT + and candidate.contradictions + == 0 + ) + + payload = { + "rule_id": ( + candidate.rule_id + ), + "support": ( + candidate.support + ), + "contradictions": ( + candidate.contradictions + ), + "minimum_support": ( + self.MIN_SUPPORT + ), + "verdict": verdict, + } + + return ( + TransitionAuthorization( + rule_id=( + candidate.rule_id + ), + verdict=verdict, + evidence_hash=( + _hash_payload( + payload + ) + ), + reason=( + "SUPPORTED_DETERMINISTIC_TRANSITION" + if verdict + else + "INSUFFICIENT_TRANSITION_EVIDENCE" + ), + ) + ) diff --git a/core/construction/__init__.py b/core/construction/__init__.py new file mode 100644 index 0000000..3b01373 --- /dev/null +++ b/core/construction/__init__.py @@ -0,0 +1,71 @@ +"""PRIME M20 adaptive representation construction.""" + +from .composition import ( + generate_composed_candidates, +) +from .compositional_engine import ( + CandidateFieldSnapshot, + CompositionalAdaptiveConstructionEngine, +) +from .engine import ( + AdaptiveConstructionEngine, + ConstructionDecision, + VerifierGate, +) +from .grammar import ( + binary, + dependencies, + description_length, + evaluate, + generate_bounded_candidates, + lag, + ref, + required_history, +) +from .graph_projection import ( + project_registry, +) +from .library import ( + load_library, + save_library, + snapshot_registry, + validate_library, +) +from .registry import ( + ConstructionRegistry, +) +from .types import ( + AuthorityAction, + ConstructionSpec, + ConstructionStatus, + FeatureExpr, + FeatureOp, +) + +__all__ = [ + "AdaptiveConstructionEngine", + "AuthorityAction", + "CandidateFieldSnapshot", + "CompositionalAdaptiveConstructionEngine", + "ConstructionDecision", + "ConstructionRegistry", + "ConstructionSpec", + "ConstructionStatus", + "FeatureExpr", + "FeatureOp", + "VerifierGate", + "binary", + "dependencies", + "description_length", + "evaluate", + "generate_bounded_candidates", + "generate_composed_candidates", + "lag", + "load_library", + "project_registry", + "ref", + "required_history", + "save_library", + "snapshot_registry", + "validate_library", +] diff --git a/core/construction/composition.py b/core/construction/composition.py new file mode 100644 index 0000000..54de554 --- /dev/null +++ b/core/construction/composition.py @@ -0,0 +1,154 @@ +"""Higher-order construction growth for PRIME M20.""" + +from __future__ import annotations + +from .grammar import ( + binary, + description_length, + lag, + ref, + required_history, +) +from .registry import ( + ConstructionRegistry, +) +from .types import ( + ConstructionSpec, + FeatureExpr, + FeatureOp, +) + + +COMPOSITION_OPERATORS = ( + FeatureOp.XOR, + FeatureOp.EQ, + FeatureOp.AND, + FeatureOp.OR, +) + + +def _add( + expressions: dict[ + str, + FeatureExpr, + ], + expr: FeatureExpr, +) -> None: + expressions[ + expr.expression_hash + ] = expr + + +def generate_composed_candidates( + registry: ConstructionRegistry, + *, + max_lag: int = 8, + max_candidates: int = 128, +) -> tuple[ + ConstructionSpec, + ..., +]: + """Build bounded candidates from authorized constructions. + + Authorized constructions are atoms. + Proposed/retired constructions are not. + """ + + active = ( + registry.active_records() + ) + + if not active: + return () + + active_refs = [ + ref( + record.spec.construction_id + ) + for record in active + ] + + raw_lags = [ + lag(k) + for k in range( + 1, + max_lag + 1, + ) + ] + + expressions: dict[ + str, + FeatureExpr, + ] = {} + + # Verified construction + raw observation relation. + for verified in active_refs: + for raw in raw_lags: + for op in COMPOSITION_OPERATORS: + _add( + expressions, + binary( + op, + verified, + raw, + ), + ) + + # Verified construction + verified construction. + for index, left in enumerate( + active_refs + ): + for right in active_refs[ + index + 1: + ]: + for op in COMPOSITION_OPERATORS: + _add( + expressions, + binary( + op, + left, + right, + ), + ) + + active_ids = set( + registry.active_ids() + ) + + proposed = [] + + for expr in expressions.values(): + spec = ConstructionSpec( + expression=expr, + proposal_source=( + "verified_composition" + ), + ) + + if ( + spec.construction_id + in active_ids + ): + continue + + proposed.append( + spec + ) + + proposed.sort( + key=lambda spec: ( + description_length( + spec.expression + ), + required_history( + spec.expression + ), + spec.construction_id, + ) + ) + + return tuple( + proposed[ + :max_candidates + ] + ) diff --git a/core/construction/compositional_engine.py b/core/construction/compositional_engine.py new file mode 100644 index 0000000..ec2ab15 --- /dev/null +++ b/core/construction/compositional_engine.py @@ -0,0 +1,471 @@ +"""Higher-order adaptive construction engine for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .composition import ( + generate_composed_candidates, +) +from .evidence import ( + EvidenceEpoch, + FrozenPredictions, +) +from .engine import ( + ConstructionDecision, + VerifierGate, +) +from .grammar import ( + description_length, + generate_bounded_candidates, + required_history, +) +from .registry import ( + ConstructionRegistry, +) +from .scaffold import ( + generate_scaffold_candidates, +) +from .state import ( + ConstructionStateBuilder, +) +from .types import ( + ConstructionSpec, +) + + +@dataclass(frozen=True) +class CandidateFieldSnapshot: + epoch: int + candidate_count: int + primitive_candidate_count: int + scaffold_candidate_count: int + composed_candidate_count: int + active_construction_count: int + alpha_denominator: int + threshold: int + + +class CompositionalAdaptiveConstructionEngine: + """PRIME M20 higher-order construction engine. + + Candidate classes: + + primitive/raw relational candidates; + optional non-authoritative scaffold candidates; + compositions over verifier-authorized constructions. + + Only verifier authorization changes canonical representation. + """ + + def __init__( + self, + *, + max_lag: int = 8, + max_candidates: int = 128, + enable_scaffolds: bool = False, + ) -> None: + self.max_lag = ( + max_lag + ) + + self.max_candidates = ( + max_candidates + ) + + self.enable_scaffolds = ( + enable_scaffolds + ) + + self.registry = ( + ConstructionRegistry() + ) + + self.state_builder = ( + ConstructionStateBuilder( + self.registry + ) + ) + + self.verifier = ( + VerifierGate() + ) + + self._private_history: list[ + int + ] = [] + + self._event_index = -1 + self._epoch_index = 0 + + self._pending: ( + FrozenPredictions + | None + ) = None + + self._primitive_specs = ( + generate_bounded_candidates( + max_lag=max_lag, + max_candidates=( + max_candidates + ), + ) + ) + + self._scaffold_specs = ( + generate_scaffold_candidates( + max_lag=max_lag, + max_candidates=( + max_candidates + ), + ) + if enable_scaffolds + else () + ) + + self._candidate_specs: tuple[ + ConstructionSpec, + ..., + ] = () + + self._epoch = ( + self._build_epoch() + ) + + def _candidate_field( + self, + ) -> tuple[ + ConstructionSpec, + ..., + ]: + active = set( + self.registry.active_ids() + ) + + combined: dict[ + str, + ConstructionSpec, + ] = {} + + for spec in ( + self._primitive_specs + ): + if ( + spec.construction_id + not in active + ): + combined[ + spec.construction_id + ] = spec + + for spec in ( + self._scaffold_specs + ): + if ( + spec.construction_id + not in active + ): + combined[ + spec.construction_id + ] = spec + + composed = ( + generate_composed_candidates( + self.registry, + max_lag=( + self.max_lag + ), + max_candidates=( + self.max_candidates + ), + ) + ) + + for spec in composed: + if ( + spec.construction_id + not in active + ): + combined[ + spec.construction_id + ] = spec + + ordered = sorted( + combined.values(), + key=lambda spec: ( + description_length( + spec.expression + ), + required_history( + spec.expression + ), + spec.construction_id, + ), + ) + + return tuple( + ordered[ + :self.max_candidates + ] + ) + + def _build_epoch( + self, + ) -> EvidenceEpoch: + candidates = ( + self._candidate_field() + ) + + for spec in candidates: + self.registry.propose( + spec + ) + + self._candidate_specs = ( + candidates + ) + + return EvidenceEpoch( + candidates, + epoch_index=( + self._epoch_index + ), + ) + + def begin_episode( + self, + ) -> None: + self._private_history = [] + self._pending = None + + self.state_builder.reset_episode() + + def observe( + self, + observation: int, + ) -> tuple[int, ...]: + if self._pending is not None: + raise RuntimeError( + "previous observation must be finalized" + ) + + self._event_index += 1 + + self._private_history.append( + observation + ) + + maximum = ( + self.max_lag + + 1 + ) + + if ( + len( + self._private_history + ) + > maximum + ): + del self._private_history[ + :-maximum + ] + + policy_state = ( + self.state_builder.observe( + observation + ) + ) + + self._pending = ( + self._epoch.freeze( + policy_state, + tuple( + self._private_history + ), + self.state_builder.current_values, + ) + ) + + return policy_state + + def _select( + self, + supported_ids: tuple[ + str, + ..., + ], + ) -> str: + lookup = { + spec.construction_id: spec + for spec + in self._candidate_specs + } + + return min( + supported_ids, + key=lambda construction_id: ( + description_length( + lookup[ + construction_id + ].expression + ), + required_history( + lookup[ + construction_id + ].expression + ), + construction_id, + ), + ) + + def finalize( + self, + target: int, + ) -> ConstructionDecision: + if self._pending is None: + raise RuntimeError( + "observe must occur first" + ) + + frozen = self._pending + self._pending = None + + outcome = ( + self._epoch.finalize( + frozen, + target=target, + event_index=( + self._event_index + ), + ) + ) + + if not outcome.supported_ids: + return ConstructionDecision( + authorized=False, + construction_id=None, + evidence=None, + receipt=None, + ) + + selected = ( + self._select( + outcome.supported_ids + ) + ) + + evidence = ( + self._epoch.snapshot( + selected, + authorization_event_index=( + self._event_index + ), + ) + ) + + authorization = ( + self.verifier.authorize( + evidence + ) + ) + + receipt = ( + self.registry.apply( + authorization + ) + ) + + self._epoch_index += 1 + + self._epoch = ( + self._build_epoch() + ) + + return ConstructionDecision( + authorized=True, + construction_id=( + selected + ), + evidence=evidence, + receipt=receipt, + ) + + def candidate_field_snapshot( + self, + ) -> CandidateFieldSnapshot: + primitive_ids = { + spec.construction_id + for spec + in self._primitive_specs + } + + scaffold_ids = { + spec.construction_id + for spec + in self._scaffold_specs + } + + primitive = sum( + spec.construction_id + in primitive_ids + for spec + in self._candidate_specs + ) + + scaffold = sum( + spec.construction_id + in scaffold_ids + for spec + in self._candidate_specs + ) + + composed = ( + len( + self._candidate_specs + ) + - primitive + - scaffold + ) + + return CandidateFieldSnapshot( + epoch=( + self._epoch_index + ), + candidate_count=len( + self._candidate_specs + ), + primitive_candidate_count=( + primitive + ), + scaffold_candidate_count=( + scaffold + ), + composed_candidate_count=( + composed + ), + active_construction_count=len( + self.registry.active_ids() + ), + alpha_denominator=( + self._epoch.alpha_denominator + ), + threshold=( + self._epoch.threshold + ), + ) + + @property + def active_construction_ids( + self, + ) -> tuple[str, ...]: + return ( + self.registry.active_ids() + ) + + @property + def receipt_chain( + self, + ) -> list[dict]: + return ( + self.registry.receipts.records + ) diff --git a/core/construction/compression.py b/core/construction/compression.py new file mode 100644 index 0000000..b56f605 --- /dev/null +++ b/core/construction/compression.py @@ -0,0 +1,123 @@ +"""Predictive-quotient compression proposals for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .quotient import ( + expanded_description_length, + predictive_partition_signature, + registry_expression_lookup, +) +from .registry import ( + ConstructionRegistry, +) + + +@dataclass(frozen=True) +class CompressionProposal: + retained_construction_id: str + redundant_construction_ids: ( + tuple[str, ...] + ) + quotient_signature: str + state_commit_authorized: bool = False + + +def propose_partition_compression( + registry: ConstructionRegistry, + *, + max_lag: int = 8, +) -> tuple[ + CompressionProposal, + ..., +]: + """Detect redundant authorized representations. + + Proposal only. Does not mutate registry state. + """ + + lookup = ( + registry_expression_lookup( + registry + ) + ) + + groups: dict[ + int, + list, + ] = {} + + for record in ( + registry.active_records() + ): + signature = ( + predictive_partition_signature( + record.spec.expression, + max_lag=max_lag, + lookup=lookup, + ) + ) + + groups.setdefault( + signature, + [], + ).append( + record + ) + + proposals = [] + + for signature, records in ( + groups.items() + ): + if len(records) < 2: + continue + + ordered = sorted( + records, + key=lambda record: ( + expanded_description_length( + record.spec.expression, + lookup=lookup, + ), + record.authorized_sequence, + record.spec.construction_id, + ), + ) + + retained = ordered[0] + + redundant = tuple( + row.spec.construction_id + for row in ordered[ + 1: + ] + ) + + proposals.append( + CompressionProposal( + retained_construction_id=( + retained.spec.construction_id + ), + redundant_construction_ids=( + redundant + ), + quotient_signature=( + hex( + signature + ) + ), + state_commit_authorized=False, + ) + ) + + proposals.sort( + key=lambda row: ( + row.retained_construction_id + ) + ) + + return tuple( + proposals + ) diff --git a/core/construction/engine.py b/core/construction/engine.py new file mode 100644 index 0000000..6b58b5c --- /dev/null +++ b/core/construction/engine.py @@ -0,0 +1,311 @@ +"""Verifier-governed adaptive construction engine for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .evidence import ( + EvidenceEpoch, + FrozenPredictions, +) +from .grammar import ( + description_length, + generate_bounded_candidates, + required_history, +) +from .registry import ( + ConstructionRegistry, +) +from .state import ( + ConstructionStateBuilder, +) +from .types import ( + AuthorityAction, + ConstructionSpec, + EvidenceSnapshot, + VerifierAuthorization, +) + + +@dataclass(frozen=True) +class ConstructionDecision: + authorized: bool + construction_id: str | None + evidence: EvidenceSnapshot | None + receipt: dict | None + + +class VerifierGate: + """Only this gate converts evidence into canonical authority.""" + + def authorize( + self, + evidence: EvidenceSnapshot, + ) -> VerifierAuthorization: + if not evidence.supported: + raise PermissionError( + "unsupported evidence cannot authorize construction" + ) + + if ( + evidence.obstruction_event_index + is None + ): + raise PermissionError( + "construction cannot authorize before obstruction" + ) + + return VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + evidence.construction_id + ), + verdict=True, + evidence_hash=( + evidence.evidence_hash + ), + reason=( + "ANYTIME_VALID_AND_STRUCTURAL_SUPPORT" + ), + ) + + +class AdaptiveConstructionEngine: + def __init__( + self, + *, + candidates: ( + tuple[ + ConstructionSpec, + ..., + ] + | None + ) = None, + ) -> None: + self.registry = ( + ConstructionRegistry() + ) + + if candidates is None: + candidates = ( + generate_bounded_candidates() + ) + + self.all_candidates = tuple( + candidates + ) + + for spec in self.all_candidates: + self.registry.propose( + spec + ) + + self.state_builder = ( + ConstructionStateBuilder( + self.registry + ) + ) + + self.verifier = ( + VerifierGate() + ) + + self._private_history: list[ + int + ] = [] + + self._event_index = -1 + + self._pending: ( + FrozenPredictions + | None + ) = None + + self._epoch = ( + self._new_evidence_epoch() + ) + + def _inactive_candidates( + self, + ) -> tuple[ + ConstructionSpec, + ..., + ]: + active = set( + self.registry.active_ids() + ) + + return tuple( + spec + for spec + in self.all_candidates + if spec.construction_id + not in active + ) + + def _new_evidence_epoch( + self, + ) -> EvidenceEpoch: + return EvidenceEpoch( + self._inactive_candidates() + ) + + def begin_episode(self) -> None: + self._private_history = [] + self._pending = None + + self.state_builder.reset_episode() + + def observe( + self, + observation: int, + ) -> tuple[int, ...]: + if self._pending is not None: + raise RuntimeError( + "previous observation must be finalized before next observe" + ) + + self._event_index += 1 + + self._private_history.append( + observation + ) + + if len( + self._private_history + ) > 9: + del self._private_history[ + :-9 + ] + + policy_state = ( + self.state_builder.observe( + observation + ) + ) + + self._pending = ( + self._epoch.freeze( + policy_state, + tuple( + self._private_history + ), + ) + ) + + return policy_state + + def _select_supported( + self, + supported_ids: tuple[ + str, + ..., + ], + ) -> str: + lookup = { + spec.construction_id: spec + for spec + in self.all_candidates + } + + return min( + supported_ids, + key=lambda construction_id: ( + description_length( + lookup[ + construction_id + ].expression + ), + required_history( + lookup[ + construction_id + ].expression + ), + construction_id, + ), + ) + + def finalize( + self, + target: int, + ) -> ConstructionDecision: + if self._pending is None: + raise RuntimeError( + "observe must occur before finalize" + ) + + frozen = self._pending + self._pending = None + + outcome = ( + self._epoch.finalize( + frozen, + target=target, + event_index=( + self._event_index + ), + ) + ) + + if not outcome.supported_ids: + return ConstructionDecision( + authorized=False, + construction_id=None, + evidence=None, + receipt=None, + ) + + selected = ( + self._select_supported( + outcome.supported_ids + ) + ) + + evidence = ( + self._epoch.snapshot( + selected, + authorization_event_index=( + self._event_index + ), + ) + ) + + authorization = ( + self.verifier.authorize( + evidence + ) + ) + + receipt = ( + self.registry.apply( + authorization + ) + ) + + # CRITICAL: + # state_builder has never seen verifier-private history. + # The newly active construction receives a fresh empty + # prospective policy buffer when sync_registry() next runs. + + self._epoch = ( + self._new_evidence_epoch() + ) + + return ConstructionDecision( + authorized=True, + construction_id=selected, + evidence=evidence, + receipt=receipt, + ) + + @property + def active_construction_ids( + self, + ) -> tuple[str, ...]: + return self.registry.active_ids() + + @property + def receipt_chain(self) -> list[dict]: + return self.registry.receipts.records diff --git a/core/construction/evidence.py b/core/construction/evidence.py new file mode 100644 index 0000000..9f38a71 --- /dev/null +++ b/core/construction/evidence.py @@ -0,0 +1,448 @@ +"""Anytime-valid construction evidence for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .grammar import ( + description_length, + evaluate, +) +from .types import ( + ConstructionSpec, + EvidenceSnapshot, +) + + +OBSTRUCTION_MIN_PER_TARGET = 8 +RUN_LEVEL_ALPHA_DENOMINATOR = 64 + + +def global_epoch_alpha_denominator( + epoch_index: int, +) -> int: + """Return the denominator for the epoch-level alpha budget. + + The schedule is + + alpha_e = 1 / (64 * 2**(e + 1)) + + so the infinite sum over zero-indexed epochs is exactly 1/64. + """ + + if epoch_index < 0: + raise ValueError( + "epoch_index must be non-negative" + ) + + return ( + RUN_LEVEL_ALPHA_DENOMINATOR + * (1 << (epoch_index + 1)) + ) + + +class BinaryMajorityPredictor: + def __init__(self) -> None: + self._counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + def predict( + self, + state: tuple[int, ...], + ) -> int: + counts = self._counts.get( + state, + [0, 0], + ) + + return int( + counts[1] + > counts[0] + ) + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + if target not in (0, 1): + raise ValueError( + "target must be binary" + ) + + counts = self._counts.setdefault( + state, + [0, 0], + ) + + counts[target] += 1 + + +@dataclass +class CandidateEvidence: + spec: ConstructionSpec + predictor: BinaryMajorityPredictor + wins: int = 0 + losses: int = 0 + + @property + def discordant(self) -> int: + return self.wins + self.losses + + @property + def net_advantage(self) -> int: + return self.wins - self.losses + + @property + def structural_cost(self) -> int: + return description_length( + self.spec.expression + ) + + def evidence_lhs(self) -> int: + return 3 ** self.wins + + def evidence_rhs( + self, + threshold: int, + ) -> int: + return ( + threshold + * 2 ** self.discordant + ) + + def statistical_pass( + self, + threshold: int, + ) -> bool: + return ( + self.evidence_lhs() + >= self.evidence_rhs( + threshold + ) + ) + + def structural_pass(self) -> bool: + return ( + self.net_advantage + > self.structural_cost + ) + + def supported( + self, + threshold: int, + ) -> bool: + return ( + self.statistical_pass( + threshold + ) + and self.structural_pass() + ) + + +@dataclass(frozen=True) +class FrozenPredictions: + canonical_state: tuple[int, ...] + canonical_prediction: int + candidate_states: dict[ + str, + tuple[int, ...], + ] + candidate_predictions: dict[ + str, + int, + ] + + +@dataclass(frozen=True) +class EvidenceOutcome: + obstruction_open: bool + obstruction_just_opened: bool + supported_ids: tuple[str, ...] + + +class EvidenceEpoch: + def __init__( + self, + candidates: tuple[ + ConstructionSpec, + ..., + ], + *, + epoch_index: int | None = None, + ) -> None: + self.candidates = candidates + + # None preserves the original single-epoch M20-A semantics. + # + # Adaptive compositional engines MUST supply epoch_index so the + # candidate-family error budget is alpha-spent across every + # representation epoch in the run. + self.epoch_index = ( + epoch_index + ) + + if epoch_index is None: + self.alpha_denominator = ( + RUN_LEVEL_ALPHA_DENOMINATOR + ) + else: + self.alpha_denominator = ( + global_epoch_alpha_denominator( + epoch_index + ) + ) + + self.threshold = ( + self.alpha_denominator + * max( + 1, + len(candidates), + ) + ) + + self.canonical_predictor = ( + BinaryMajorityPredictor() + ) + + self.trackers = { + spec.construction_id: ( + CandidateEvidence( + spec=spec, + predictor=( + BinaryMajorityPredictor() + ), + ) + ) + for spec in candidates + } + + self.obstruction_counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + self.obstruction_open = False + self.obstruction_event_index: ( + int | None + ) = None + + def freeze( + self, + canonical_state: tuple[int, ...], + verifier_history: tuple[int, ...], + resolved: dict[str, int] | None = None, + ) -> FrozenPredictions: + canonical_prediction = ( + self.canonical_predictor.predict( + canonical_state + ) + ) + + states = {} + predictions = {} + + for construction_id, tracker in ( + self.trackers.items() + ): + bit = evaluate( + tracker.spec.expression, + verifier_history, + resolved, + ) + + candidate_state = ( + canonical_state + + (bit,) + ) + + states[ + construction_id + ] = candidate_state + + predictions[ + construction_id + ] = tracker.predictor.predict( + candidate_state + ) + + return FrozenPredictions( + canonical_state=( + canonical_state + ), + canonical_prediction=( + canonical_prediction + ), + candidate_states=states, + candidate_predictions=( + predictions + ), + ) + + def _has_obstruction(self) -> bool: + return any( + counts[0] + >= OBSTRUCTION_MIN_PER_TARGET + and counts[1] + >= OBSTRUCTION_MIN_PER_TARGET + for counts + in self.obstruction_counts.values() + ) + + def supported_ids( + self, + ) -> tuple[str, ...]: + return tuple( + construction_id + for construction_id, tracker + in self.trackers.items() + if tracker.supported( + self.threshold + ) + ) + + def snapshot( + self, + construction_id: str, + *, + authorization_event_index: ( + int | None + ) = None, + ) -> EvidenceSnapshot: + tracker = self.trackers[ + construction_id + ] + + statistical = ( + tracker.statistical_pass( + self.threshold + ) + ) + + structural = ( + tracker.structural_pass() + ) + + return EvidenceSnapshot( + construction_id=( + construction_id + ), + wins=tracker.wins, + losses=tracker.losses, + threshold=self.threshold, + evidence_lhs=( + tracker.evidence_lhs() + ), + evidence_rhs=( + tracker.evidence_rhs( + self.threshold + ) + ), + statistical_pass=( + statistical + ), + structural_cost=( + tracker.structural_cost + ), + structural_pass=( + structural + ), + supported=( + statistical + and structural + ), + obstruction_event_index=( + self.obstruction_event_index + ), + authorization_event_index=( + authorization_event_index + ), + ) + + def finalize( + self, + frozen: FrozenPredictions, + *, + target: int, + event_index: int, + ) -> EvidenceOutcome: + if target not in (0, 1): + raise ValueError( + "target must be binary" + ) + + for construction_id, tracker in ( + self.trackers.items() + ): + candidate_prediction = ( + frozen.candidate_predictions[ + construction_id + ] + ) + + if ( + candidate_prediction + != frozen.canonical_prediction + ): + if ( + candidate_prediction + == target + ): + tracker.wins += 1 + else: + tracker.losses += 1 + + bucket = ( + self.obstruction_counts.setdefault( + frozen.canonical_state, + [0, 0], + ) + ) + + bucket[target] += 1 + + self.canonical_predictor.update( + frozen.canonical_state, + target, + ) + + for construction_id, tracker in ( + self.trackers.items() + ): + tracker.predictor.update( + frozen.candidate_states[ + construction_id + ], + target, + ) + + just_opened = False + + if ( + not self.obstruction_open + and self._has_obstruction() + ): + self.obstruction_open = True + self.obstruction_event_index = ( + event_index + ) + just_opened = True + + supported: tuple[str, ...] = () + + if self.obstruction_open: + supported = ( + self.supported_ids() + ) + + return EvidenceOutcome( + obstruction_open=( + self.obstruction_open + ), + obstruction_just_opened=( + just_opened + ), + supported_ids=supported, + ) diff --git a/core/construction/grammar.py b/core/construction/grammar.py new file mode 100644 index 0000000..71a56df --- /dev/null +++ b/core/construction/grammar.py @@ -0,0 +1,341 @@ +"""Bounded generative construction grammar for PRIME M20.""" + +from __future__ import annotations + +from .types import ( + ConstructionSpec, + FeatureExpr, + FeatureOp, +) + + +COMMUTATIVE = { + FeatureOp.XOR, + FeatureOp.EQ, + FeatureOp.AND, + FeatureOp.OR, +} + + +def lag(k: int) -> FeatureExpr: + return FeatureExpr( + op=FeatureOp.LAG, + lag=k, + ) + + +def ref( + construction_id: str, +) -> FeatureExpr: + return FeatureExpr( + op=FeatureOp.REF, + ref_id=construction_id, + ) + + +def binary( + op: FeatureOp, + left: FeatureExpr, + right: FeatureExpr, +) -> FeatureExpr: + if op not in COMMUTATIVE: + raise ValueError( + "unsupported binary operator" + ) + + if ( + left.expression_hash + > right.expression_hash + ): + left, right = ( + right, + left, + ) + + return FeatureExpr( + op=op, + left=left, + right=right, + ) + + +def history_value( + history: ( + list[int] + | tuple[int, ...] + ), + k: int, +) -> int: + index = ( + len(history) + - 1 + - k + ) + + if index < 0: + return 0 + + value = history[ + index + ] + + if value not in ( + 0, + 1, + ): + raise ValueError( + "history must be binary" + ) + + return value + + +def dependencies( + expr: FeatureExpr, +) -> frozenset[str]: + if expr.op == FeatureOp.LAG: + return frozenset() + + if expr.op == FeatureOp.REF: + assert expr.ref_id is not None + + return frozenset( + ( + expr.ref_id, + ) + ) + + assert expr.left is not None + assert expr.right is not None + + return ( + dependencies( + expr.left + ) + | + dependencies( + expr.right + ) + ) + + +def evaluate( + expr: FeatureExpr, + history: ( + list[int] + | tuple[int, ...] + ), + resolved: ( + dict[str, int] + | None + ) = None, +) -> int: + if resolved is None: + resolved = {} + + if expr.op == FeatureOp.LAG: + assert expr.lag is not None + + return history_value( + history, + expr.lag, + ) + + if expr.op == FeatureOp.REF: + assert expr.ref_id is not None + + if ( + expr.ref_id + not in resolved + ): + raise KeyError( + "construction reference " + "is not currently resolved: " + + expr.ref_id + ) + + value = resolved[ + expr.ref_id + ] + + if value not in ( + 0, + 1, + ): + raise ValueError( + "resolved construction " + "value must be binary" + ) + + return value + + assert expr.left is not None + assert expr.right is not None + + a = evaluate( + expr.left, + history, + resolved, + ) + + b = evaluate( + expr.right, + history, + resolved, + ) + + if expr.op == FeatureOp.XOR: + return a ^ b + + if expr.op == FeatureOp.EQ: + return int( + a == b + ) + + if expr.op == FeatureOp.AND: + return a & b + + if expr.op == FeatureOp.OR: + return a | b + + raise ValueError( + "unsupported expression op" + ) + + +def required_history( + expr: FeatureExpr, +) -> int: + if expr.op == FeatureOp.LAG: + assert expr.lag is not None + return expr.lag + + if expr.op == FeatureOp.REF: + return 0 + + assert expr.left is not None + assert expr.right is not None + + return max( + required_history( + expr.left + ), + required_history( + expr.right + ), + ) + + +def description_length( + expr: FeatureExpr, +) -> int: + if expr.op == FeatureOp.LAG: + assert expr.lag is not None + + return ( + 2 + + max( + 1, + expr.lag.bit_length(), + ) + ) + + if expr.op == FeatureOp.REF: + # Reusing a verified construction + # should be cheaper than restating + # its internal expression. + return 3 + + assert expr.left is not None + assert expr.right is not None + + return ( + 1 + + description_length( + expr.left + ) + + description_length( + expr.right + ) + ) + + +def generate_bounded_candidates( + *, + max_lag: int = 8, + max_candidates: int = 128, +) -> tuple[ + ConstructionSpec, + ..., +]: + if max_lag < 1: + raise ValueError( + "max_lag must be positive" + ) + + if max_candidates < 1: + raise ValueError( + "max_candidates must be positive" + ) + + primitives = [ + lag(k) + for k in range( + 1, + max_lag + 1, + ) + ] + + expressions: dict[ + str, + FeatureExpr, + ] = {} + + for expr in primitives: + expressions[ + expr.expression_hash + ] = expr + + for index, left in enumerate( + primitives + ): + for right in primitives[ + index + 1: + ]: + for op in ( + FeatureOp.XOR, + FeatureOp.EQ, + FeatureOp.AND, + FeatureOp.OR, + ): + expr = binary( + op, + left, + right, + ) + + expressions[ + expr.expression_hash + ] = expr + + ordered = sorted( + expressions.values(), + key=lambda expr: ( + description_length( + expr + ), + required_history( + expr + ), + expr.expression_hash, + ), + ) + + return tuple( + ConstructionSpec( + expression=expr + ) + for expr in ordered[ + :max_candidates + ] + ) diff --git a/core/construction/graph_projection.py b/core/construction/graph_projection.py new file mode 100644 index 0000000..b748904 --- /dev/null +++ b/core/construction/graph_projection.py @@ -0,0 +1,107 @@ +"""Graph proposal projection for PRIME M20. + +This module does NOT mutate the living graph. + +It emits a deterministic proposal envelope suitable for a later +TSKernel/TSIR authority adapter. +""" + +from __future__ import annotations + +import hashlib + +from .grammar import ( + dependencies, +) +from .registry import ( + ConstructionRegistry, +) +from .types import ( + canonical_bytes, +) + + +PROJECTION_VERSION = ( + "prime-m20-construction-projection-v1" +) + + +def project_registry( + registry: ConstructionRegistry, +) -> dict: + nodes = [] + edges = [] + + for construction_id, record in sorted( + registry._records.items() + ): + nodes.append( + { + "node_id": ( + construction_id + ), + "node_type": ( + "prime_construction" + ), + "status": ( + record.status.value + ), + "expression": ( + record.spec.expression.to_dict() + ), + "proposal_source": ( + record.spec.proposal_source + ), + "authoritative": ( + record.status.value + == "authorized" + ), + } + ) + + for dependency in sorted( + dependencies( + record.spec.expression + ) + ): + edges.append( + { + "src": ( + construction_id + ), + "dst": dependency, + "relation": ( + "depends_on" + ), + } + ) + + payload = { + "projection_version": ( + PROJECTION_VERSION + ), + "registry_hash": ( + registry.registry_hash() + ), + "receipt_tip": ( + registry.receipts.tip + ), + "nodes": nodes, + "edges": edges, + "requested_operation": ( + "PROPOSE_GRAPH_DELTA" + ), + "state_commit_authorized": ( + False + ), + } + + payload[ + "projection_hash" + ] = hashlib.sha256( + canonical_bytes( + payload + ) + ).hexdigest() + + return payload diff --git a/core/construction/library.py b/core/construction/library.py new file mode 100644 index 0000000..704c5bf --- /dev/null +++ b/core/construction/library.py @@ -0,0 +1,226 @@ +"""Persistent verified construction library for PRIME M20.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +from .grammar import ( + dependencies, +) +from .receipts import ( + verify_receipt_chain, +) +from .registry import ( + ConstructionRegistry, +) +from .types import ( + canonical_bytes, +) + + +LIBRARY_FORMAT = ( + "prime-m20-construction-library-v1" +) + + +def snapshot_registry( + registry: ConstructionRegistry, +) -> dict: + records = [] + + for construction_id, record in sorted( + registry._records.items() + ): + records.append( + { + "construction": ( + record.spec.to_dict() + ), + "status": ( + record.status.value + ), + "proposed_sequence": ( + record.proposed_sequence + ), + "authorized_sequence": ( + record.authorized_sequence + ), + "retired_sequence": ( + record.retired_sequence + ), + "dependencies": sorted( + dependencies( + record.spec.expression + ) + ), + } + ) + + payload = { + "format": LIBRARY_FORMAT, + "registry_hash": ( + registry.registry_hash() + ), + "active_construction_ids": list( + registry.active_ids() + ), + "records": records, + "receipt_chain": ( + registry.receipts.records + ), + "receipt_count": ( + registry.receipts.count + ), + "receipt_tip": ( + registry.receipts.tip + ), + } + + payload["library_hash"] = ( + hashlib.sha256( + canonical_bytes( + payload + ) + ).hexdigest() + ) + + return payload + + +def validate_library( + payload: dict, +) -> bool: + if ( + payload.get("format") + != LIBRARY_FORMAT + ): + return False + + supplied_hash = ( + payload.get( + "library_hash" + ) + ) + + if not isinstance( + supplied_hash, + str, + ): + return False + + unsigned = dict( + payload + ) + + unsigned.pop( + "library_hash", + None, + ) + + actual = hashlib.sha256( + canonical_bytes( + unsigned + ) + ).hexdigest() + + if actual != supplied_hash: + return False + + if not verify_receipt_chain( + payload.get( + "receipt_chain", + [], + ), + expected_count=( + payload.get( + "receipt_count" + ) + ), + expected_tip=( + payload.get( + "receipt_tip" + ) + ), + ): + return False + + active = set( + payload.get( + "active_construction_ids", + [], + ) + ) + + known = { + row[ + "construction" + ][ + "construction_id" + ] + for row + in payload.get( + "records", + [], + ) + } + + if not active.issubset( + known + ): + return False + + return True + + +def save_library( + registry: ConstructionRegistry, + path: ( + str + | Path + ), +) -> str: + path = Path( + path + ) + + payload = ( + snapshot_registry( + registry + ) + ) + + path.write_bytes( + canonical_bytes( + payload + ) + ) + + return payload[ + "library_hash" + ] + + +def load_library( + path: ( + str + | Path + ), +) -> dict: + payload = json.loads( + Path( + path + ).read_text( + encoding="utf-8" + ) + ) + + if not validate_library( + payload + ): + raise ValueError( + "invalid construction library" + ) + + return payload diff --git a/core/construction/quotient.py b/core/construction/quotient.py new file mode 100644 index 0000000..da90f10 --- /dev/null +++ b/core/construction/quotient.py @@ -0,0 +1,418 @@ +"""Predictive quotient semantics for bounded PRIME M20 constructions.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .grammar import ( + description_length, +) +from .registry import ( + ConstructionRegistry, +) +from .types import ( + FeatureExpr, + FeatureOp, +) + + +RELATION_EXACT = "exact" +RELATION_COMPLEMENT = "complement" +RELATION_DIFFERENT = "different" + + +def registry_expression_lookup( + registry: ConstructionRegistry, +) -> dict[ + str, + FeatureExpr, +]: + return { + construction_id: ( + record.spec.expression + ) + for construction_id, record + in registry._records.items() + } + + +def _evaluate_assignment( + expr: FeatureExpr, + assignment: dict[int, int], + lookup: dict[ + str, + FeatureExpr, + ], + stack: tuple[str, ...] = (), +) -> int: + if expr.op == FeatureOp.LAG: + assert expr.lag is not None + + if expr.lag not in assignment: + raise ValueError( + "truth-table assignment " + "does not cover required lag" + ) + + return assignment[ + expr.lag + ] + + if expr.op == FeatureOp.REF: + assert expr.ref_id is not None + + if expr.ref_id in stack: + raise ValueError( + "cyclic construction reference" + ) + + target = lookup.get( + expr.ref_id + ) + + if target is None: + raise KeyError( + "unresolved construction reference: " + + expr.ref_id + ) + + return _evaluate_assignment( + target, + assignment, + lookup, + stack + + ( + expr.ref_id, + ), + ) + + assert expr.left is not None + assert expr.right is not None + + a = _evaluate_assignment( + expr.left, + assignment, + lookup, + stack, + ) + + b = _evaluate_assignment( + expr.right, + assignment, + lookup, + stack, + ) + + if expr.op == FeatureOp.XOR: + return a ^ b + + if expr.op == FeatureOp.EQ: + return int( + a == b + ) + + if expr.op == FeatureOp.AND: + return a & b + + if expr.op == FeatureOp.OR: + return a | b + + raise ValueError( + "unsupported feature operation" + ) + + +def semantic_signature( + expr: FeatureExpr, + *, + max_lag: int = 8, + lookup: ( + dict[ + str, + FeatureExpr, + ] + | None + ) = None, +) -> int: + """Exact Boolean truth-table signature.""" + + if lookup is None: + lookup = {} + + signature = 0 + + for case in range( + 1 << max_lag + ): + assignment = { + lag_index: ( + case + >> ( + lag_index + - 1 + ) + ) + & 1 + for lag_index + in range( + 1, + max_lag + 1, + ) + } + + value = _evaluate_assignment( + expr, + assignment, + lookup, + ) + + signature |= ( + value + << case + ) + + return signature + + +def complement_signature( + signature: int, + *, + max_lag: int = 8, +) -> int: + mask = ( + 1 + << ( + 1 << max_lag + ) + ) - 1 + + return ( + mask + ^ signature + ) + + +def predictive_partition_signature( + expr: FeatureExpr, + *, + max_lag: int = 8, + lookup: ( + dict[ + str, + FeatureExpr, + ] + | None + ) = None, +) -> int: + signature = semantic_signature( + expr, + max_lag=max_lag, + lookup=lookup, + ) + + complement = ( + complement_signature( + signature, + max_lag=max_lag, + ) + ) + + return min( + signature, + complement, + ) + + +def semantic_relation( + left: FeatureExpr, + right: FeatureExpr, + *, + max_lag: int = 8, + left_lookup: ( + dict[ + str, + FeatureExpr, + ] + | None + ) = None, + right_lookup: ( + dict[ + str, + FeatureExpr, + ] + | None + ) = None, +) -> str: + left_signature = ( + semantic_signature( + left, + max_lag=max_lag, + lookup=left_lookup, + ) + ) + + right_signature = ( + semantic_signature( + right, + max_lag=max_lag, + lookup=right_lookup, + ) + ) + + if ( + left_signature + == right_signature + ): + return RELATION_EXACT + + if ( + left_signature + == complement_signature( + right_signature, + max_lag=max_lag, + ) + ): + return ( + RELATION_COMPLEMENT + ) + + return RELATION_DIFFERENT + + +def predictively_equivalent( + left: FeatureExpr, + right: FeatureExpr, + *, + max_lag: int = 8, + left_lookup=None, + right_lookup=None, +) -> bool: + return ( + semantic_relation( + left, + right, + max_lag=max_lag, + left_lookup=( + left_lookup + ), + right_lookup=( + right_lookup + ), + ) + != RELATION_DIFFERENT + ) + + +@dataclass(frozen=True) +class QuotientMatch: + construction_id: str + relation: str + + +def active_partition_matches( + registry: ConstructionRegistry, + target: FeatureExpr, + *, + max_lag: int = 8, +) -> tuple[ + QuotientMatch, + ..., +]: + lookup = ( + registry_expression_lookup( + registry + ) + ) + + matches = [] + + for record in ( + registry.active_records() + ): + relation = ( + semantic_relation( + record.spec.expression, + target, + max_lag=max_lag, + left_lookup=lookup, + ) + ) + + if ( + relation + != RELATION_DIFFERENT + ): + matches.append( + QuotientMatch( + construction_id=( + record.spec.construction_id + ), + relation=relation, + ) + ) + + return tuple( + matches + ) + + +def expanded_description_length( + expr: FeatureExpr, + *, + lookup: dict[ + str, + FeatureExpr, + ], + stack: tuple[str, ...] = (), +) -> int: + if expr.op != FeatureOp.REF: + if expr.op == FeatureOp.LAG: + return ( + description_length( + expr + ) + ) + + assert expr.left is not None + assert expr.right is not None + + return ( + 1 + + expanded_description_length( + expr.left, + lookup=lookup, + stack=stack, + ) + + expanded_description_length( + expr.right, + lookup=lookup, + stack=stack, + ) + ) + + assert expr.ref_id is not None + + if expr.ref_id in stack: + raise ValueError( + "cyclic construction reference" + ) + + target = lookup.get( + expr.ref_id + ) + + if target is None: + raise KeyError( + expr.ref_id + ) + + return expanded_description_length( + target, + lookup=lookup, + stack=( + stack + + ( + expr.ref_id, + ) + ), + ) diff --git a/core/construction/receipts.py b/core/construction/receipts.py new file mode 100644 index 0000000..f027af6 --- /dev/null +++ b/core/construction/receipts.py @@ -0,0 +1,123 @@ +"""Deterministic hash-chained receipts for PRIME M20.""" + +from __future__ import annotations + +from copy import deepcopy +import hashlib + +from .types import canonical_bytes + + +GENESIS_HASH = "0" * 64 + + +class ReceiptChain: + def __init__(self) -> None: + self._records: list[dict] = [] + self._tip = GENESIS_HASH + + @property + def count(self) -> int: + return len(self._records) + + @property + def tip(self) -> str: + return self._tip + + @property + def records(self) -> list[dict]: + return deepcopy( + self._records + ) + + def append( + self, + payload: dict, + ) -> dict: + body = deepcopy(payload) + + body["sequence"] = ( + len(self._records) + ) + + body["previous_receipt_hash"] = ( + self._tip + ) + + receipt_hash = hashlib.sha256( + canonical_bytes(body) + ).hexdigest() + + record = { + "payload": body, + "receipt_hash": receipt_hash, + } + + self._records.append( + record + ) + + self._tip = receipt_hash + + return deepcopy(record) + + +def verify_receipt_chain( + records: list[dict], + *, + expected_count: int | None = None, + expected_tip: str | None = None, +) -> bool: + previous = GENESIS_HASH + + for sequence, record in enumerate( + records + ): + payload = record.get( + "payload" + ) + + receipt_hash = record.get( + "receipt_hash" + ) + + if not isinstance( + payload, + dict, + ): + return False + + if payload.get( + "sequence" + ) != sequence: + return False + + if payload.get( + "previous_receipt_hash" + ) != previous: + return False + + actual = hashlib.sha256( + canonical_bytes(payload) + ).hexdigest() + + if actual != receipt_hash: + return False + + previous = actual + + if ( + expected_count is not None + and len(records) + != expected_count + ): + return False + + if ( + expected_tip is not None + and previous + != expected_tip + ): + return False + + return True diff --git a/core/construction/registry.py b/core/construction/registry.py new file mode 100644 index 0000000..4fd62ff --- /dev/null +++ b/core/construction/registry.py @@ -0,0 +1,317 @@ +"""Canonical construction registry for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass +import hashlib + +from .grammar import dependencies +from .receipts import ReceiptChain +from .types import ( + AuthorityAction, + ConstructionSpec, + ConstructionStatus, + VerifierAuthorization, + canonical_bytes, +) + + +@dataclass +class ConstructionRecord: + spec: ConstructionSpec + status: ConstructionStatus + proposed_sequence: int + authorized_sequence: int | None = None + retired_sequence: int | None = None + + +class ConstructionRegistry: + """Proposal/state separation for constructed representation.""" + + def __init__(self) -> None: + self._records: dict[ + str, + ConstructionRecord, + ] = {} + + self._proposal_sequence = 0 + self._authorization_sequence = 0 + + self.receipts = ReceiptChain() + + def propose( + self, + spec: ConstructionSpec, + ) -> ConstructionRecord: + self.validate_dependencies( + spec + ) + + construction_id = ( + spec.construction_id + ) + + existing = self._records.get( + construction_id + ) + + if existing is not None: + return existing + + record = ConstructionRecord( + spec=spec, + status=ConstructionStatus.PROPOSED, + proposed_sequence=( + self._proposal_sequence + ), + ) + + self._proposal_sequence += 1 + + self._records[ + construction_id + ] = record + + return record + + def get( + self, + construction_id: str, + ) -> ConstructionRecord | None: + return self._records.get( + construction_id + ) + + def active_records( + self, + ) -> tuple[ + ConstructionRecord, + ..., + ]: + rows = [ + record + for record + in self._records.values() + if record.status + == ConstructionStatus.AUTHORIZED + ] + + rows.sort( + key=lambda record: ( + record.authorized_sequence, + record.spec.construction_id, + ) + ) + + return tuple(rows) + + def active_ids(self) -> tuple[str, ...]: + return tuple( + row.spec.construction_id + for row in self.active_records() + ) + + def active_dependents( + self, + construction_id: str, + ) -> tuple[str, ...]: + rows = [] + + for record in self.active_records(): + if ( + construction_id + in dependencies( + record.spec.expression + ) + ): + rows.append( + record.spec.construction_id + ) + + return tuple( + sorted(rows) + ) + + def validate_dependencies( + self, + spec: ConstructionSpec, + ) -> None: + active = set( + self.active_ids() + ) + + missing = sorted( + dependencies( + spec.expression + ) + - active + ) + + if missing: + raise ValueError( + "construction references " + "non-authorized dependencies: " + + ", ".join(missing) + ) + + def registry_hash(self) -> str: + payload = [ + { + "construction_id": ( + record.spec.construction_id + ), + "status": ( + record.status.value + ), + "proposed_sequence": ( + record.proposed_sequence + ), + "authorized_sequence": ( + record.authorized_sequence + ), + "retired_sequence": ( + record.retired_sequence + ), + } + for record + in sorted( + self._records.values(), + key=lambda row: ( + row.spec.construction_id + ), + ) + ] + + return hashlib.sha256( + canonical_bytes(payload) + ).hexdigest() + + def apply( + self, + authorization: VerifierAuthorization, + ) -> dict: + if not authorization.verdict: + raise PermissionError( + "failed verifier verdict cannot mutate registry" + ) + + record = self._records.get( + authorization.construction_id + ) + + if record is None: + raise KeyError( + "construction must be proposed before authorization" + ) + + before = self.registry_hash() + + action = authorization.action + + if action == AuthorityAction.AUTHORIZE: + if ( + record.status + != ConstructionStatus.PROPOSED + ): + raise ValueError( + "only proposed construction may be authorized" + ) + + record.status = ( + ConstructionStatus.AUTHORIZED + ) + + record.authorized_sequence = ( + self._authorization_sequence + ) + + self._authorization_sequence += 1 + + elif action == AuthorityAction.RETIRE: + if ( + record.status + != ConstructionStatus.AUTHORIZED + ): + raise ValueError( + "only authorized construction may be retired" + ) + + dependents = ( + self.active_dependents( + authorization.construction_id + ) + ) + + if dependents: + raise ValueError( + "cannot retire construction " + "with active dependents: " + + ", ".join( + dependents + ) + ) + + record.status = ( + ConstructionStatus.RETIRED + ) + + record.retired_sequence = ( + self._authorization_sequence + ) + + self._authorization_sequence += 1 + + elif action == AuthorityAction.RESTORE: + if ( + record.status + != ConstructionStatus.RETIRED + ): + raise ValueError( + "only retired construction may be restored" + ) + + record.status = ( + ConstructionStatus.AUTHORIZED + ) + + record.authorized_sequence = ( + self._authorization_sequence + ) + + self._authorization_sequence += 1 + + else: + raise ValueError( + "unsupported authority action" + ) + + after = self.registry_hash() + + return self.receipts.append( + { + "event": ( + "CONSTRUCTION_AUTHORITY_TRANSITION" + ), + "action": ( + action.value + ), + "construction": ( + record.spec.to_dict() + ), + "evidence_hash": ( + authorization.evidence_hash + ), + "reason": ( + authorization.reason + ), + "registry_hash_before": ( + before + ), + "registry_hash_after": ( + after + ), + "active_construction_ids": list( + self.active_ids() + ), + } + ) diff --git a/core/construction/scaffold.py b/core/construction/scaffold.py new file mode 100644 index 0000000..4fa9e18 --- /dev/null +++ b/core/construction/scaffold.py @@ -0,0 +1,135 @@ +"""Bounded non-authoritative proposal scaffolds for PRIME M20.""" + +from __future__ import annotations + +from itertools import combinations + +from .grammar import ( + binary, + description_length, + lag, + required_history, +) +from .types import ( + ConstructionSpec, + FeatureExpr, + FeatureOp, +) + + +SCAFFOLD_OPS = ( + FeatureOp.XOR, + FeatureOp.AND, + FeatureOp.OR, +) + + +def fold_commutative( + op: FeatureOp, + expressions: tuple[ + FeatureExpr, + ..., + ], +) -> FeatureExpr: + if ( + op + not in SCAFFOLD_OPS + ): + raise ValueError( + "unsupported scaffold operator" + ) + + if len(expressions) < 2: + raise ValueError( + "scaffold requires >=2 expressions" + ) + + ordered = sorted( + expressions, + key=lambda expr: ( + expr.expression_hash + ), + ) + + current = ordered[0] + + for expr in ordered[1:]: + current = binary( + op, + current, + expr, + ) + + return current + + +def generate_scaffold_candidates( + *, + max_lag: int = 8, + max_candidates: int = 256, +) -> tuple[ + ConstructionSpec, + ..., +]: + """Generate bounded depth-2 proposal expressions. + + Internal subexpressions are proposal scaffolds only. + + They are NOT canonical constructions and receive no authority. + """ + + if max_lag < 3: + return () + + expressions: dict[ + str, + FeatureExpr, + ] = {} + + for a, b, c in combinations( + range( + 1, + max_lag + 1, + ), + 3, + ): + atoms = ( + lag(a), + lag(b), + lag(c), + ) + + for op in SCAFFOLD_OPS: + expr = fold_commutative( + op, + atoms, + ) + + expressions[ + expr.expression_hash + ] = expr + + ordered = sorted( + expressions.values(), + key=lambda expr: ( + description_length( + expr + ), + required_history( + expr + ), + expr.expression_hash, + ), + ) + + return tuple( + ConstructionSpec( + expression=expr, + proposal_source=( + "bounded_scaffold" + ), + ) + for expr in ordered[ + :max_candidates + ] + ) diff --git a/core/construction/state.py b/core/construction/state.py new file mode 100644 index 0000000..6351d7c --- /dev/null +++ b/core/construction/state.py @@ -0,0 +1,149 @@ +"""Canonical policy state builder for PRIME M20.""" + +from __future__ import annotations + +from .grammar import ( + evaluate, +) +from .registry import ( + ConstructionRegistry, +) + + +class ConstructionStateBuilder: + """Policy-visible construction state. + + Every construction owns a prospective raw-history buffer. + + Newly authorized constructions begin empty. + + REF dependencies use only the current outputs of already-authorized + constructions. + + Verifier-private sensory history is never backfilled into these buffers. + """ + + def __init__( + self, + registry: ConstructionRegistry, + ) -> None: + self.registry = registry + + self._buffers: dict[ + str, + list[int], + ] = {} + + self._current_values: dict[ + str, + int, + ] = {} + + @property + def current_values( + self, + ) -> dict[str, int]: + return dict( + self._current_values + ) + + def sync_registry(self) -> None: + active = set( + self.registry.active_ids() + ) + + for construction_id in active: + self._buffers.setdefault( + construction_id, + [], + ) + + for construction_id in list( + self._buffers + ): + if construction_id not in active: + del self._buffers[ + construction_id + ] + + self._current_values = { + key: value + for key, value + in self._current_values.items() + if key in active + } + + def reset_episode(self) -> None: + self.sync_registry() + + for construction_id in ( + self._buffers + ): + self._buffers[ + construction_id + ] = [] + + self._current_values = {} + + def observe( + self, + observation: int, + ) -> tuple[int, ...]: + if observation not in ( + 0, + 1, + ): + raise ValueError( + "observation must be binary" + ) + + self.sync_registry() + + state = [ + observation + ] + + resolved: dict[ + str, + int, + ] = {} + + for record in ( + self.registry.active_records() + ): + construction_id = ( + record.spec.construction_id + ) + + buffer = self._buffers[ + construction_id + ] + + buffer.append( + observation + ) + + if len(buffer) > 9: + del buffer[:-9] + + value = evaluate( + record.spec.expression, + buffer, + resolved, + ) + + resolved[ + construction_id + ] = value + + state.append( + value + ) + + self._current_values = ( + resolved + ) + + return tuple( + state + ) diff --git a/core/construction/study.py b/core/construction/study.py new file mode 100644 index 0000000..8a2ea89 --- /dev/null +++ b/core/construction/study.py @@ -0,0 +1,73 @@ +"""Proposal-only study prioritization for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .evidence import EvidenceEpoch + + +@dataclass(frozen=True) +class StudyHint: + construction_id: str + wins: int + losses: int + net_advantage: int + structural_cost: int + discordant_events: int + supported: bool + + +def rank_study_targets( + epoch: EvidenceEpoch, +) -> tuple[ + StudyHint, + ..., +]: + """Rank unresolved evidence streams. + + This function has no authority over canonical state. + """ + + hints = [] + + for construction_id, tracker in ( + epoch.trackers.items() + ): + hints.append( + StudyHint( + construction_id=( + construction_id + ), + wins=tracker.wins, + losses=tracker.losses, + net_advantage=( + tracker.net_advantage + ), + structural_cost=( + tracker.structural_cost + ), + discordant_events=( + tracker.discordant + ), + supported=( + tracker.supported( + epoch.threshold + ) + ), + ) + ) + + hints.sort( + key=lambda hint: ( + not hint.supported, + -( + hint.net_advantage + - hint.structural_cost + ), + -hint.discordant_events, + hint.construction_id, + ) + ) + + return tuple(hints) diff --git a/core/construction/types.py b/core/construction/types.py new file mode 100644 index 0000000..a49faa7 --- /dev/null +++ b/core/construction/types.py @@ -0,0 +1,295 @@ +"""Typed objects for PRIME M20 adaptive construction.""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum +import hashlib +import json + + +SEMANTICS_VERSION = "prime-m20.1" + + +def canonical_bytes(value: object) -> bytes: + return ( + json.dumps( + value, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + +class FeatureOp(str, Enum): + LAG = "lag" + REF = "ref" + XOR = "xor" + EQ = "eq" + AND = "and" + OR = "or" + + +class ConstructionStatus(str, Enum): + PROPOSED = "proposed" + AUTHORIZED = "authorized" + RETIRED = "retired" + + +class AuthorityAction(str, Enum): + AUTHORIZE = "authorize" + RETIRE = "retire" + RESTORE = "restore" + + +@dataclass(frozen=True) +class FeatureExpr: + op: FeatureOp + lag: int | None = None + ref_id: str | None = None + left: "FeatureExpr | None" = None + right: "FeatureExpr | None" = None + + def __post_init__(self) -> None: + if self.op == FeatureOp.LAG: + if self.lag is None or self.lag < 1: + raise ValueError( + "lag expression requires positive lag" + ) + + if ( + self.ref_id is not None + or self.left is not None + or self.right is not None + ): + raise ValueError( + "lag expression cannot have ref/children" + ) + + return + + if self.op == FeatureOp.REF: + if ( + not isinstance( + self.ref_id, + str, + ) + or not self.ref_id + ): + raise ValueError( + "ref expression requires construction id" + ) + + if ( + self.lag is not None + or self.left is not None + or self.right is not None + ): + raise ValueError( + "ref expression cannot have lag/children" + ) + + return + + if ( + self.lag is not None + or self.ref_id is not None + ): + raise ValueError( + "binary expression cannot contain direct lag/ref field" + ) + + if ( + self.left is None + or self.right is None + ): + raise ValueError( + "binary expression requires two children" + ) + + def to_dict(self) -> dict: + if self.op == FeatureOp.LAG: + return { + "op": self.op.value, + "lag": self.lag, + } + + if self.op == FeatureOp.REF: + return { + "op": self.op.value, + "ref_id": self.ref_id, + } + + return { + "op": self.op.value, + "left": self.left.to_dict(), + "right": self.right.to_dict(), + } + + @property + def expression_hash(self) -> str: + payload = { + "semantics_version": ( + SEMANTICS_VERSION + ), + "expression": self.to_dict(), + } + + return hashlib.sha256( + canonical_bytes( + payload + ) + ).hexdigest() + + +def expr_from_dict( + value: dict, +) -> FeatureExpr: + op = FeatureOp( + value["op"] + ) + + if op == FeatureOp.LAG: + return FeatureExpr( + op=op, + lag=int( + value["lag"] + ), + ) + + if op == FeatureOp.REF: + return FeatureExpr( + op=op, + ref_id=str( + value["ref_id"] + ), + ) + + return FeatureExpr( + op=op, + left=expr_from_dict( + value["left"] + ), + right=expr_from_dict( + value["right"] + ), + ) + + +@dataclass(frozen=True) +class ConstructionSpec: + expression: FeatureExpr + proposal_source: str = ( + "bounded_grammar" + ) + + @property + def construction_id(self) -> str: + return ( + "cx:" + + self.expression.expression_hash + ) + + def to_dict(self) -> dict: + return { + "construction_id": ( + self.construction_id + ), + "semantics_version": ( + SEMANTICS_VERSION + ), + "expression": ( + self.expression.to_dict() + ), + "proposal_source": ( + self.proposal_source + ), + } + + +@dataclass(frozen=True) +class EvidenceSnapshot: + construction_id: str + wins: int + losses: int + threshold: int + evidence_lhs: int + evidence_rhs: int + statistical_pass: bool + structural_cost: int + structural_pass: bool + supported: bool + obstruction_event_index: ( + int | None + ) + authorization_event_index: ( + int | None + ) + + def to_dict(self) -> dict: + return { + "construction_id": ( + self.construction_id + ), + "wins": self.wins, + "losses": self.losses, + "threshold": self.threshold, + "evidence_lhs": ( + self.evidence_lhs + ), + "evidence_rhs": ( + self.evidence_rhs + ), + "statistical_pass": ( + self.statistical_pass + ), + "structural_cost": ( + self.structural_cost + ), + "structural_pass": ( + self.structural_pass + ), + "supported": ( + self.supported + ), + "obstruction_event_index": ( + self.obstruction_event_index + ), + "authorization_event_index": ( + self.authorization_event_index + ), + } + + @property + def evidence_hash(self) -> str: + return hashlib.sha256( + canonical_bytes( + self.to_dict() + ) + ).hexdigest() + + +@dataclass(frozen=True) +class VerifierAuthorization: + action: AuthorityAction + construction_id: str + verdict: bool + evidence_hash: str + reason: str + + def to_dict(self) -> dict: + return { + "action": ( + self.action.value + ), + "construction_id": ( + self.construction_id + ), + "verdict": self.verdict, + "evidence_hash": ( + self.evidence_hash + ), + "reason": self.reason, + } diff --git a/core/cortex/__init__.py b/core/cortex/__init__.py new file mode 100644 index 0000000..1a8d96e --- /dev/null +++ b/core/cortex/__init__.py @@ -0,0 +1,47 @@ +"""Mega PRIME Native Cortex.""" + +from .model import ( + CortexConfig, + CortexOutput, + NativeCortex, + TernaryLinear, +) +from .telemetry import ( + LayerObservation, + TSObs, + append_jsonl, +) +from .tokenizer import ( + ByteTokenizer, +) + +__all__ = [ + "ByteTokenizer", + "CortexConfig", + "CortexOutput", + "LayerObservation", + "NativeCortex", + "TSObs", + "TernaryLinear", + "append_jsonl", +] + +from .bpe_tokenizer import BPETokenizer + +if "BPETokenizer" not in __all__: + __all__.append("BPETokenizer") + + +from .model_v1 import ( + CortexV1Config, + CortexV1Output, + NativeCortexV1, +) + +for _name in ( + "CortexV1Config", + "CortexV1Output", + "NativeCortexV1", +): + if _name not in __all__: + __all__.append(_name) diff --git a/core/cortex/bpe_tokenizer.py b/core/cortex/bpe_tokenizer.py new file mode 100644 index 0000000..1e68e64 --- /dev/null +++ b/core/cortex/bpe_tokenizer.py @@ -0,0 +1,90 @@ +"""BPE tokenizer adapter for Mega PRIME Native Cortex.""" + +from __future__ import annotations + +from tokenizers import Tokenizer + + +class BPETokenizer: + def __init__( + self, + path: str, + ) -> None: + self.tokenizer = ( + Tokenizer.from_file(path) + ) + + vocab = ( + self.tokenizer.get_vocab() + ) + + self.PAD = vocab[""] + self.BOS = vocab[""] + self.EOS = vocab[""] + self.UNK = vocab[""] + + self.vocab_size = ( + self.tokenizer + .get_vocab_size() + ) + + def encode( + self, + text: str, + *, + add_bos: bool = True, + add_eos: bool = True, + ) -> list[int]: + ids = list( + self.tokenizer + .encode(text) + .ids + ) + + if add_bos: + ids.insert( + 0, + self.BOS, + ) + + if add_eos: + ids.append( + self.EOS + ) + + return ids + + def decode( + self, + tokens, + ) -> str: + ids = [ + int(token) + for token in tokens + if int(token) not in ( + self.PAD, + self.BOS, + self.EOS, + ) + ] + + return self.tokenizer.decode( + ids + ) + + def token_label( + self, + token: int, + ) -> str: + value = ( + self.tokenizer + .id_to_token( + int(token) + ) + ) + + return ( + value + if value is not None + else "" + ) diff --git a/core/cortex/counterfactual_verifier.py b/core/cortex/counterfactual_verifier.py new file mode 100644 index 0000000..871024d --- /dev/null +++ b/core/cortex/counterfactual_verifier.py @@ -0,0 +1,513 @@ +"""Canonical counterfactual verifier-pair construction for Native Cortex. + +Pairs are generated by executing PRIME's existing typed verifiers. +No neural prediction is authoritative. +""" + +from __future__ import annotations + +from copy import deepcopy + +from core.cortex.prime_bridge import ( + VERIFIER_LABEL_TO_ID, + stable_hash, +) + +from core.kernel.ir import ( + ClaimNode, + EntityNode, + Provenance, + TSIRDocument, + VerifierObligation, +) + +from core.kernel.obligations import ( + ArithmeticVerifier, + CodePropertyVerifier, + StructuralVerifier, +) + +from core.kernel.transaction import ( + TransactionWorkspace, +) + + +PAIR_CHANNELS = ( + "arithmetic", + "structural", + "code_property", +) + + +def workspace( + document: TSIRDocument | None = None, +): + return TransactionWorkspace( + base_graph_hash="counterfactual-curriculum", + document=( + document + if document is not None + else TSIRDocument() + ), + base_nodes={}, + base_edges=[], + ) + + +def _finalize_record( + *, + pair_id: str, + pair_hash: str, + pair_member: str, + verifier_type: str, + source_text: str, + premises: list[str], + obligation: str, + verifier_result: dict, + counterfactual_field: str, + counterfactual_value, + construction_metadata: dict, +): + outcome = str( + verifier_result["outcome"] + ) + + expected = { + "ACCEPT": "pass", + "REJECT": "fail", + }[ + pair_member + ] + + if outcome != expected: + raise RuntimeError( + f"canonical verifier returned {outcome}, " + f"expected {expected}" + ) + + record = { + "pair_id": pair_id, + "pair_hash": pair_hash, + "pair_member": pair_member, + "counterfactual_pair": True, + "counterfactual_field": counterfactual_field, + "counterfactual_value": counterfactual_value, + "construction_metadata": construction_metadata, + "source_text": source_text, + "premises": list(premises), + "obligation": obligation, + "verifier_type": verifier_type, + "verifier_action": ( + "typed_pass" + if pair_member == "ACCEPT" + else "typed_fail" + ), + "verifier_label": pair_member, + "verifier_label_id": ( + VERIFIER_LABEL_TO_ID[ + pair_member + ] + ), + "verifier_result": verifier_result, + "authority": "NONE", + } + + record["record_hash"] = stable_hash( + record + ) + + return record + + +def arithmetic_pair( + index: int, + *, + split: str, +): + verifier = ArithmeticVerifier() + + a = ( + 3 + + (index * 17) % 89 + ) + + b = ( + 2 + + (index * 31) % 73 + ) + + correct = a + b + + pair_id = ( + f"counterfactual:{split}:" + f"arithmetic:{index}" + ) + + pair_spec = { + "pair_id": pair_id, + "channel": "arithmetic", + "a": a, + "b": b, + "accept_expected": correct, + "reject_expected": correct + 1, + } + + pair_hash = stable_hash( + pair_spec + ) + + records = [] + + for member, expected in ( + ("ACCEPT", correct), + ("REJECT", correct + 1), + ): + expression = ( + f"{a} + {b} = {expected}" + ) + + obligation = VerifierObligation( + id=( + f"{pair_id}:" + f"{member.lower()}" + ), + verifier_type="arithmetic", + target_claim=expression, + expected_property={ + "expression": expression, + }, + ) + + result = verifier.verify( + obligation, + workspace(), + ) + + records.append( + _finalize_record( + pair_id=pair_id, + pair_hash=pair_hash, + pair_member=member, + verifier_type="arithmetic", + source_text=( + "Verify the arithmetic proposition: " + + expression + ), + premises=[], + obligation=expression, + verifier_result=result.to_dict(), + counterfactual_field=( + "expected_result" + ), + counterfactual_value=expected, + construction_metadata={ + "a": a, + "b": b, + "correct_result": correct, + }, + ) + ) + + return tuple(records) + + +def structural_pair( + index: int, + *, + split: str, +): + verifier = StructuralVerifier() + + provenance = Provenance( + "system_seed", + reliability=1.0, + ) + + subject = ( + f"entity:counterfactual:" + f"subject:{index}" + ) + + object_id = ( + f"entity:counterfactual:" + f"object:{index}" + ) + + pair_id = ( + f"counterfactual:{split}:" + f"structural:{index}" + ) + + pair_spec = { + "pair_id": pair_id, + "channel": "structural", + "subject": subject, + "object": object_id, + "counterfactual_field": ( + "object_declared" + ), + } + + pair_hash = stable_hash( + pair_spec + ) + + records = [] + + for member, object_declared in ( + ("ACCEPT", True), + ("REJECT", False), + ): + entities = [ + EntityNode( + id=subject, + entity_type="object", + label=f"subject {index}", + provenance=provenance, + ) + ] + + if object_declared: + entities.append( + EntityNode( + id=object_id, + entity_type="object", + label=f"object {index}", + provenance=provenance, + ) + ) + + claim = ClaimNode( + id=( + f"claim:counterfactual:" + f"struct:{index}" + ), + subject=subject, + predicate="related_to", + object=object_id, + status="proposed", + provenance=provenance, + ) + + document = TSIRDocument( + entities=entities, + claims=[claim], + ) + + obligation = VerifierObligation( + id=( + f"{pair_id}:" + f"{member.lower()}" + ), + verifier_type="structural", + target_claim="__document__", + ) + + result = verifier.verify( + obligation, + workspace(document), + ) + + premise = ( + f"subject={subject}; " + f"object={object_id}; " + f"object_declared=" + f"{object_declared}" + ) + + records.append( + _finalize_record( + pair_id=pair_id, + pair_hash=pair_hash, + pair_member=member, + verifier_type="structural", + source_text=( + "Check TSIR structural consistency: " + + premise + ), + premises=[premise], + obligation=( + "TSIR document is " + "internally consistent" + ), + verifier_result=result.to_dict(), + counterfactual_field=( + "object_declared" + ), + counterfactual_value=( + object_declared + ), + construction_metadata={ + "subject": subject, + "object": object_id, + }, + ) + ) + + return tuple(records) + + +def code_property_pair( + index: int, + *, + split: str, +): + verifier = CodePropertyVerifier() + + multiplier = ( + 2 + + index % 5 + ) + + offset = ( + index % 7 + ) + + function = ( + f"counterfactual_transform_{index}" + ) + + body = ( + f"x * {multiplier} + {offset}" + ) + + base_examples = [] + + for value in ( + 0, + 1, + 2, + 5, + ): + base_examples.append( + { + "input": value, + "expected": ( + value + * multiplier + + offset + ), + } + ) + + pair_id = ( + f"counterfactual:{split}:" + f"code_property:{index}" + ) + + pair_spec = { + "pair_id": pair_id, + "channel": "code_property", + "function": function, + "body": body, + "counterfactual_field": ( + "examples[-1].expected" + ), + } + + pair_hash = stable_hash( + pair_spec + ) + + records = [] + + for member in ( + "ACCEPT", + "REJECT", + ): + examples = deepcopy( + base_examples + ) + + if member == "REJECT": + examples[-1]["expected"] += 1 + + spec = { + "function": function, + "parameter": "x", + "body": body, + "examples": examples, + } + + obligation = VerifierObligation( + id=( + f"{pair_id}:" + f"{member.lower()}" + ), + verifier_type="code_property", + target_claim=function, + expected_property=spec, + ) + + result = verifier.verify( + obligation, + workspace(), + ) + + premise = ( + f"{function}(x) = {body}; " + f"examples = {examples}" + ) + + records.append( + _finalize_record( + pair_id=pair_id, + pair_hash=pair_hash, + pair_member=member, + verifier_type="code_property", + source_text=( + "Verify this bounded code property: " + + premise + ), + premises=[premise], + obligation=( + f"{function} satisfies " + "the supplied examples" + ), + verifier_result=result.to_dict(), + counterfactual_field=( + "examples[-1].expected" + ), + counterfactual_value=( + examples[-1]["expected"] + ), + construction_metadata={ + "function": function, + "body": body, + "base_examples": ( + base_examples + ), + }, + ) + ) + + return tuple(records) + + +def build_counterfactual_pair( + channel: str, + index: int, + *, + split: str, +): + if channel == "arithmetic": + return arithmetic_pair( + index, + split=split, + ) + + if channel == "structural": + return structural_pair( + index, + split=split, + ) + + if channel == "code_property": + return code_property_pair( + index, + split=split, + ) + + raise ValueError( + f"unsupported pair channel: {channel}" + ) diff --git a/core/cortex/model.py b/core/cortex/model.py new file mode 100644 index 0000000..6654edb --- /dev/null +++ b/core/cortex/model.py @@ -0,0 +1,1031 @@ +"""Mega PRIME Native Cortex. + +Ternary projections + matrix-valued delta recurrent memory + +sparse expert routing. + +The cortex has no canonical epistemic authority. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +import torch +from torch import nn +import torch.nn.functional as F + +from .telemetry import ( + LayerObservation, +) + + +class RMSNorm( + nn.Module +): + def __init__( + self, + dimension: int, + eps: float = 1e-6, + ) -> None: + super().__init__() + + self.weight = nn.Parameter( + torch.ones( + dimension + ) + ) + + self.eps = eps + + def forward( + self, + x, + ): + scale = ( + x.pow(2) + .mean( + dim=-1, + keepdim=True, + ) + .add( + self.eps + ) + .rsqrt() + ) + + return ( + x + * scale + * self.weight + ) + + +class TernaryLinear( + nn.Module +): + """Trainable FP weights; ternary effective forward weights. + + Straight-through estimator: + + {-scale, 0, +scale} + + This establishes the low-bit architecture without requiring + specialized inference kernels yet. + """ + + def __init__( + self, + in_features: int, + out_features: int, + *, + bias: bool = True, + ) -> None: + super().__init__() + + self.weight = nn.Parameter( + torch.empty( + out_features, + in_features, + ) + ) + + if bias: + self.bias = nn.Parameter( + torch.zeros( + out_features + ) + ) + else: + self.register_parameter( + "bias", + None, + ) + + nn.init.normal_( + self.weight, + mean=0.0, + std=( + in_features + ** -0.5 + ), + ) + + def effective_weight( + self, + ): + scale = ( + self.weight + .detach() + .abs() + .mean( + dim=-1, + keepdim=True, + ) + .clamp_min( + 1e-6 + ) + ) + + quantized = ( + torch.round( + self.weight + / scale + ) + .clamp( + -1, + 1, + ) + * scale + ) + + # Straight-through estimator. + return ( + self.weight + + ( + quantized + - self.weight + ).detach() + ) + + def forward( + self, + x, + ): + return F.linear( + x, + self.effective_weight(), + self.bias, + ) + + +@dataclass(frozen=True) +class CortexConfig: + vocab_size: int = 259 + + d_model: int = 96 + + layers: int = 3 + + memory_heads: int = 4 + + experts: int = 4 + + expert_hidden: int = 192 + + verifier_classes: int = 5 + + dropout: float = 0.0 + + +@dataclass +class CortexOutput: + logits: torch.Tensor + + verifier_logits: torch.Tensor + + states: list[ + torch.Tensor + ] + + auxiliary_loss: torch.Tensor + + telemetry: list | None = None + + +class DeltaMemory( + nn.Module +): + def __init__( + self, + config: CortexConfig, + ) -> None: + super().__init__() + + if ( + config.d_model + % config.memory_heads + != 0 + ): + raise ValueError( + "d_model must divide memory_heads" + ) + + self.d_model = ( + config.d_model + ) + + self.heads = ( + config.memory_heads + ) + + self.head_dim = ( + config.d_model + // config.memory_heads + ) + + self.q_proj = ( + TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + ) + + self.k_proj = ( + TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + ) + + self.v_proj = ( + TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + ) + + self.out_proj = ( + TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + ) + + self.gates = nn.Linear( + config.d_model, + 2 + * config.memory_heads, + ) + + with torch.no_grad(): + self.gates.bias[ + :config.memory_heads + ].fill_( + -2.0 + ) + + self.gates.bias[ + config.memory_heads: + ].fill_( + -1.0 + ) + + def initial_state( + self, + batch_size: int, + *, + device, + dtype, + ): + return torch.zeros( + batch_size, + self.heads, + self.head_dim, + self.head_dim, + device=device, + dtype=dtype, + ) + + def step( + self, + x, + state, + ): + batch = x.shape[0] + + q = ( + self.q_proj( + x + ) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + k = ( + self.k_proj( + x + ) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + v = ( + self.v_proj( + x + ) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + q = F.normalize( + q, + dim=-1, + eps=1e-6, + ) + + k = F.normalize( + k, + dim=-1, + eps=1e-6, + ) + + read = torch.einsum( + "bhkv,bhk->bhv", + state, + q, + ) + + predicted = torch.einsum( + "bhkv,bhk->bhv", + state, + k, + ) + + gate_values = ( + torch.sigmoid( + self.gates( + x + ) + ) + .reshape( + batch, + self.heads, + 2, + ) + ) + + erase = ( + 0.10 + * gate_values[ + :, + :, + 0, + ] + ) + + write = ( + 0.50 + * gate_values[ + :, + :, + 1, + ] + ) + + residual = ( + v + - predicted + ) + + delta = ( + k.unsqueeze( + -1 + ) + * residual.unsqueeze( + -2 + ) + ) + + new_state = ( + ( + 1.0 + - erase.unsqueeze( + -1 + ).unsqueeze( + -1 + ) + ) + * state + + write.unsqueeze( + -1 + ).unsqueeze( + -1 + ) + * delta + ) + + output = ( + self.out_proj( + read.reshape( + batch, + self.d_model, + ) + ) + ) + + stats = { + "state_norm": ( + new_state + .detach() + .float() + .norm( + dim=(-2, -1) + ) + .mean() + .item() + ), + "read_norm": ( + read + .detach() + .float() + .norm( + dim=-1 + ) + .mean() + .item() + ), + "erase_mean": ( + erase + .detach() + .float() + .mean() + .item() + ), + "write_mean": ( + write + .detach() + .float() + .mean() + .item() + ), + } + + return ( + output, + new_state, + stats, + ) + + +class SparseExpert( + nn.Module +): + def __init__( + self, + config: CortexConfig, + ) -> None: + super().__init__() + + self.up = TernaryLinear( + config.d_model, + config.expert_hidden, + ) + + self.down = TernaryLinear( + config.expert_hidden, + config.d_model, + ) + + def forward( + self, + x, + ): + return self.down( + F.silu( + self.up( + x + ) + ) + ) + + +class SparseMoE( + nn.Module +): + def __init__( + self, + config: CortexConfig, + ) -> None: + super().__init__() + + self.expert_count = ( + config.experts + ) + + self.router = nn.Linear( + config.d_model, + config.experts, + ) + + self.experts = nn.ModuleList( + [ + SparseExpert( + config + ) + for _ in range( + config.experts + ) + ] + ) + + def forward( + self, + x, + ): + probabilities = ( + torch.softmax( + self.router( + x + ), + dim=-1, + ) + ) + + top_probability, top_index = ( + probabilities.max( + dim=-1 + ) + ) + + output = torch.zeros_like( + x + ) + + for expert_index, expert in ( + enumerate( + self.experts + ) + ): + mask = ( + top_index + == expert_index + ) + + if not torch.any( + mask + ): + continue + + expert_output = expert( + x[ + mask + ] + ) + + output[ + mask + ] = ( + expert_output + * top_probability[ + mask + ].unsqueeze( + -1 + ) + ) + + importance = ( + probabilities.mean( + dim=0 + ) + ) + + load = ( + F.one_hot( + top_index, + num_classes=( + self.expert_count + ), + ) + .float() + .mean( + dim=0 + ) + ) + + auxiliary_loss = ( + self.expert_count + * ( + importance + * load + ).sum() + ) + + return ( + output, + auxiliary_loss, + top_index, + top_probability, + ) + + +class CortexBlock( + nn.Module +): + def __init__( + self, + config: CortexConfig, + ) -> None: + super().__init__() + + self.norm_memory = ( + RMSNorm( + config.d_model + ) + ) + + self.memory = ( + DeltaMemory( + config + ) + ) + + self.norm_expert = ( + RMSNorm( + config.d_model + ) + ) + + self.moe = ( + SparseMoE( + config + ) + ) + + self.dropout = nn.Dropout( + config.dropout + ) + + def initial_state( + self, + batch_size, + *, + device, + dtype, + ): + return ( + self.memory.initial_state( + batch_size, + device=device, + dtype=dtype, + ) + ) + + def step( + self, + x, + state, + ): + memory_output, state, stats = ( + self.memory.step( + self.norm_memory( + x + ), + state, + ) + ) + + x = ( + x + + self.dropout( + memory_output + ) + ) + + expert_output, aux, index, probability = ( + self.moe( + self.norm_expert( + x + ) + ) + ) + + x = ( + x + + self.dropout( + expert_output + ) + ) + + stats.update( + { + "expert_index": ( + index + ), + "expert_probability": ( + probability + ), + } + ) + + return ( + x, + state, + aux, + stats, + ) + + +class NativeCortex( + nn.Module +): + VERIFIER_LABELS = ( + "UNKNOWN", + "ACCEPT", + "REJECT", + "REPAIR", + "ABSTAIN", + ) + + def __init__( + self, + config: CortexConfig, + ) -> None: + super().__init__() + + self.config = config + + self.embedding = nn.Embedding( + config.vocab_size, + config.d_model, + ) + + self.blocks = nn.ModuleList( + [ + CortexBlock( + config + ) + for _ in range( + config.layers + ) + ] + ) + + self.final_norm = ( + RMSNorm( + config.d_model + ) + ) + + self.verifier_head = ( + TernaryLinear( + config.d_model, + config.verifier_classes, + ) + ) + + def parameter_count( + self, + ) -> int: + return sum( + parameter.numel() + for parameter + in self.parameters() + ) + + def initial_states( + self, + batch_size, + *, + device, + dtype=None, + ): + if dtype is None: + dtype = ( + self.embedding + .weight + .dtype + ) + + return [ + block.initial_state( + batch_size, + device=device, + dtype=dtype, + ) + for block + in self.blocks + ] + + def step( + self, + tokens, + states=None, + *, + telemetry=False, + ): + if tokens.ndim != 1: + raise ValueError( + "step tokens must have shape [batch]" + ) + + x = self.embedding( + tokens + ) + + if states is None: + states = ( + self.initial_states( + tokens.shape[0], + device=( + tokens.device + ), + dtype=x.dtype, + ) + ) + + new_states = [] + + layer_stats = [] + + auxiliary = ( + x.new_zeros( + () + ) + ) + + for layer_index, ( + block, + state, + ) in enumerate( + zip( + self.blocks, + states, + ) + ): + x, new_state, aux, stats = ( + block.step( + x, + state, + ) + ) + + new_states.append( + new_state + ) + + auxiliary = ( + auxiliary + + aux + ) + + if telemetry: + layer_stats.append( + LayerObservation( + layer=( + layer_index + ), + recurrent_state_norm=( + stats[ + "state_norm" + ] + ), + read_norm=( + stats[ + "read_norm" + ] + ), + erase_mean=( + stats[ + "erase_mean" + ] + ), + write_mean=( + stats[ + "write_mean" + ] + ), + selected_expert=int( + stats[ + "expert_index" + ][0].item() + ), + expert_probability=float( + stats[ + "expert_probability" + ][0].item() + ), + ) + ) + + x = self.final_norm( + x + ) + + # Weight-tied output head. + logits = F.linear( + x, + self.embedding.weight, + ) + + verifier_logits = ( + self.verifier_head( + x + ) + ) + + return ( + logits, + verifier_logits, + new_states, + auxiliary + / len( + self.blocks + ), + ( + layer_stats + if telemetry + else None + ), + ) + + def forward( + self, + tokens, + states=None, + *, + telemetry=False, + ) -> CortexOutput: + if tokens.ndim != 2: + raise ValueError( + "tokens must have shape [batch, sequence]" + ) + + logits = [] + + verifier_logits = [] + + telemetry_rows = ( + [] + if telemetry + else None + ) + + auxiliary = ( + self.embedding + .weight + .new_zeros( + () + ) + ) + + for position in range( + tokens.shape[1] + ): + ( + token_logits, + token_verifier, + states, + token_aux, + token_telemetry, + ) = self.step( + tokens[ + :, + position, + ], + states, + telemetry=( + telemetry + ), + ) + + logits.append( + token_logits + ) + + verifier_logits.append( + token_verifier + ) + + auxiliary = ( + auxiliary + + token_aux + ) + + if telemetry: + telemetry_rows.append( + token_telemetry + ) + + return CortexOutput( + logits=torch.stack( + logits, + dim=1, + ), + verifier_logits=( + torch.stack( + verifier_logits, + dim=1, + ) + ), + states=states, + auxiliary_loss=( + auxiliary + / tokens.shape[1] + ), + telemetry=( + telemetry_rows + ), + ) diff --git a/core/cortex/model_v1.py b/core/cortex/model_v1.py new file mode 100644 index 0000000..9b63cc6 --- /dev/null +++ b/core/cortex/model_v1.py @@ -0,0 +1,1506 @@ +"""Mega PRIME Native Cortex V1. + +Architecture: + + BPE + multi-timescale delta recurrence + bounded local attention + top-2 train / top-1 inference sparse experts + ternary-effective projections + factorized output decoder + +The cortex has zero epistemic authority. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import math + +import torch +from torch import nn +import torch.nn.functional as F + +from .model import ( + RMSNorm, + SparseExpert, + TernaryLinear, +) + + +@dataclass(frozen=True) +class CortexV1Config: + vocab_size: int = 4096 + + d_model: int = 192 + + layers: int = 4 + + memory_heads: int = 6 + + attention_heads: int = 6 + + attention_every: int = 2 + + attention_window: int = 64 + + experts: int = 6 + + expert_hidden: int = 384 + + output_rank: int = 64 + + verifier_classes: int = 5 + + dropout: float = 0.0 + + +@dataclass +class BlockState: + memory: torch.Tensor + + attention_keys: torch.Tensor | None = None + + attention_values: torch.Tensor | None = None + + +@dataclass +class CortexV1Output: + logits: torch.Tensor + + verifier_logits: torch.Tensor + + hidden: torch.Tensor + + states: list[BlockState] + + router_balance_loss: torch.Tensor + + router_z_loss: torch.Tensor + + router_entropy_normalized: torch.Tensor + + diagnostics: list[dict] | None = None + + +class MultiTimescaleDeltaMemory( + nn.Module +): + def __init__( + self, + config: CortexV1Config, + ) -> None: + super().__init__() + + if ( + config.d_model + % config.memory_heads + != 0 + ): + raise ValueError( + "d_model must divide memory_heads" + ) + + self.d_model = ( + config.d_model + ) + + self.heads = ( + config.memory_heads + ) + + self.head_dim = ( + config.d_model + // config.memory_heads + ) + + self.q_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.k_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.v_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.out_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.gates = nn.Linear( + config.d_model, + 2 * self.heads, + ) + + half_lives = torch.logspace( + math.log10(4.0), + math.log10(768.0), + steps=self.heads, + ) + + retention = torch.pow( + torch.tensor(0.5), + 1.0 / half_lives, + ) + + self.register_buffer( + "base_retention", + retention, + persistent=True, + ) + + with torch.no_grad(): + self.gates.bias[ + :self.heads + ].fill_( + -2.0 + ) + + self.gates.bias[ + self.heads: + ].fill_( + -1.0 + ) + + def initial_state( + self, + batch_size: int, + *, + device, + dtype, + ): + return torch.zeros( + batch_size, + self.heads, + self.head_dim, + self.head_dim, + device=device, + dtype=dtype, + ) + + def step( + self, + x, + state, + ): + batch = x.shape[0] + + q = ( + self.q_proj(x) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + k = ( + self.k_proj(x) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + v = ( + self.v_proj(x) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + q = F.normalize( + q, + dim=-1, + eps=1e-6, + ) + + k = F.normalize( + k, + dim=-1, + eps=1e-6, + ) + + read = torch.einsum( + "bhkv,bhk->bhv", + state, + q, + ) + + prediction = torch.einsum( + "bhkv,bhk->bhv", + state, + k, + ) + + gates = ( + torch.sigmoid( + self.gates(x) + ) + .reshape( + batch, + self.heads, + 2, + ) + ) + + erase = gates[ + :, + :, + 0, + ] + + write = ( + 0.35 + * gates[ + :, + :, + 1, + ] + ) + + base = ( + self.base_retention + .to( + dtype=state.dtype, + device=state.device, + ) + .view( + 1, + self.heads, + ) + ) + + retention = ( + base + * ( + 1.0 + - 0.25 + * erase + ) + ).clamp( + 0.0, + 0.99995, + ) + + residual = ( + v + - prediction + ) + + delta = ( + k.unsqueeze(-1) + * residual.unsqueeze(-2) + ) + + new_state = ( + retention[ + :, + :, + None, + None, + ] + * state + + write[ + :, + :, + None, + None, + ] + * delta + ) + + output = self.out_proj( + read.reshape( + batch, + self.d_model, + ) + ) + + stats = { + "state_norm": ( + new_state + .detach() + .float() + .norm( + dim=(-2, -1) + ) + .mean() + ), + "read_norm": ( + read + .detach() + .float() + .norm( + dim=-1 + ) + .mean() + ), + "erase_mean": ( + erase + .detach() + .float() + .mean() + ), + "write_mean": ( + write + .detach() + .float() + .mean() + ), + "retention_mean": ( + retention + .detach() + .float() + .mean() + ), + } + + return ( + output, + new_state, + stats, + ) + + +class LocalAttention( + nn.Module +): + def __init__( + self, + config: CortexV1Config, + ) -> None: + super().__init__() + + if ( + config.d_model + % config.attention_heads + != 0 + ): + raise ValueError( + "d_model must divide attention_heads" + ) + + self.heads = ( + config.attention_heads + ) + + self.head_dim = ( + config.d_model + // self.heads + ) + + self.window = ( + config.attention_window + ) + + self.q_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.k_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.v_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + self.out_proj = TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + + def step( + self, + x, + key_cache, + value_cache, + *, + disabled: bool = False, + ): + if disabled: + return ( + torch.zeros_like(x), + key_cache, + value_cache, + { + "attention_entropy": ( + x.new_zeros(()) + ), + "attention_context": 0, + }, + ) + + batch = x.shape[0] + + q = ( + self.q_proj(x) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + k = ( + self.k_proj(x) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + v = ( + self.v_proj(x) + .reshape( + batch, + self.heads, + self.head_dim, + ) + ) + + k = k.unsqueeze(2) + v = v.unsqueeze(2) + + if key_cache is None: + keys = k + values = v + + else: + keys = torch.cat( + ( + key_cache, + k, + ), + dim=2, + ) + + values = torch.cat( + ( + value_cache, + v, + ), + dim=2, + ) + + if ( + keys.shape[2] + > self.window + ): + keys = keys[ + :, + :, + -self.window:, + : + ] + + values = values[ + :, + :, + -self.window:, + : + ] + + scale = ( + self.head_dim + ** -0.5 + ) + + scores = ( + torch.einsum( + "bhd,bhtd->bht", + q, + keys, + ) + * scale + ) + + probabilities = ( + torch.softmax( + scores, + dim=-1, + ) + ) + + context = torch.einsum( + "bht,bhtd->bhd", + probabilities, + values, + ) + + output = self.out_proj( + context.reshape( + batch, + -1, + ) + ) + + length = ( + probabilities.shape[-1] + ) + + if length > 1: + entropy = -( + probabilities + * torch.log( + probabilities + + 1e-12 + ) + ).sum( + dim=-1 + ).mean() + + entropy = ( + entropy + / math.log(length) + ) + + else: + entropy = ( + probabilities + .new_zeros(()) + ) + + return ( + output, + keys, + values, + { + "attention_entropy": ( + entropy + .detach() + .float() + ), + "attention_context": ( + length + ), + }, + ) + + +class TopKMoE( + nn.Module +): + def __init__( + self, + config: CortexV1Config, + ) -> None: + super().__init__() + + self.expert_count = ( + config.experts + ) + + self.router = nn.Linear( + config.d_model, + config.experts, + ) + + self.experts = nn.ModuleList( + [ + SparseExpert( + config + ) + for _ in range( + config.experts + ) + ] + ) + + def forward( + self, + x, + ): + router_logits = ( + self.router(x) + ) + + probabilities = ( + torch.softmax( + router_logits, + dim=-1, + ) + ) + + top_k = ( + min( + 2, + self.expert_count, + ) + if self.training + else 1 + ) + + top_values, top_indices = ( + torch.topk( + probabilities, + top_k, + dim=-1, + ) + ) + + top_weights = ( + top_values + / top_values.sum( + dim=-1, + keepdim=True, + ).clamp_min( + 1e-9 + ) + ) + + output = torch.zeros_like( + x + ) + + for expert_index, expert in ( + enumerate( + self.experts + ) + ): + for slot in range( + top_k + ): + mask = ( + top_indices[ + :, + slot, + ] + == expert_index + ) + + if not torch.any(mask): + continue + + expert_output = ( + expert( + x[mask] + ) + ) + + output[mask] += ( + expert_output + * top_weights[ + mask, + slot, + ].unsqueeze( + -1 + ) + ) + + importance = ( + probabilities.mean( + dim=0 + ) + ) + + assignments = ( + F.one_hot( + top_indices, + num_classes=( + self.expert_count + ), + ) + .float() + .sum( + dim=1 + ) + / top_k + ) + + load = ( + assignments.mean( + dim=0 + ) + ) + + balance_loss = ( + self.expert_count + * ( + importance + * load + ).sum() + ) + + z_loss = ( + torch.logsumexp( + router_logits, + dim=-1, + ) + .pow(2) + .mean() + ) + + entropy = -( + probabilities + * torch.log( + probabilities + + 1e-12 + ) + ).sum( + dim=-1 + ).mean() + + entropy_normalized = ( + entropy + / math.log( + self.expert_count + ) + ) + + stats = { + "top_expert": ( + top_indices[ + :, + 0, + ] + .detach() + ), + "top_probability": ( + top_values[ + :, + 0, + ] + .detach() + ), + "entropy_normalized": ( + entropy_normalized + .detach() + ), + } + + return ( + output, + balance_loss, + z_loss, + entropy_normalized, + stats, + ) + + +class CortexV1Block( + nn.Module +): + def __init__( + self, + config: CortexV1Config, + *, + use_attention: bool, + ) -> None: + super().__init__() + + self.use_attention = ( + use_attention + ) + + self.memory_norm = RMSNorm( + config.d_model + ) + + self.memory = ( + MultiTimescaleDeltaMemory( + config + ) + ) + + if use_attention: + self.attention_norm = ( + RMSNorm( + config.d_model + ) + ) + + self.attention = ( + LocalAttention( + config + ) + ) + + else: + self.attention_norm = None + self.attention = None + + self.expert_norm = RMSNorm( + config.d_model + ) + + self.moe = TopKMoE( + config + ) + + self.dropout = nn.Dropout( + config.dropout + ) + + def initial_state( + self, + batch_size, + *, + device, + dtype, + ): + return BlockState( + memory=( + self.memory + .initial_state( + batch_size, + device=device, + dtype=dtype, + ) + ), + ) + + def step( + self, + x, + state: BlockState, + *, + disable_attention: bool = False, + ): + ( + memory_output, + memory_state, + memory_stats, + ) = self.memory.step( + self.memory_norm(x), + state.memory, + ) + + x = ( + x + + self.dropout( + memory_output + ) + ) + + attention_stats = { + "attention_entropy": ( + x.new_zeros(()) + ), + "attention_context": 0, + } + + attention_keys = ( + state.attention_keys + ) + + attention_values = ( + state.attention_values + ) + + if self.use_attention: + ( + attention_output, + attention_keys, + attention_values, + attention_stats, + ) = self.attention.step( + self.attention_norm(x), + attention_keys, + attention_values, + disabled=( + disable_attention + ), + ) + + x = ( + x + + self.dropout( + attention_output + ) + ) + + ( + expert_output, + balance_loss, + z_loss, + entropy, + expert_stats, + ) = self.moe( + self.expert_norm(x) + ) + + x = ( + x + + self.dropout( + expert_output + ) + ) + + stats = { + **memory_stats, + **attention_stats, + **expert_stats, + } + + return ( + x, + BlockState( + memory=memory_state, + attention_keys=( + attention_keys + ), + attention_values=( + attention_values + ), + ), + balance_loss, + z_loss, + entropy, + stats, + ) + + +class NativeCortexV1( + nn.Module +): + """Observable low-compute recurrent language cortex.""" + + def __init__( + self, + config: CortexV1Config, + ) -> None: + super().__init__() + + self.config = config + + self.embedding = nn.Embedding( + config.vocab_size, + config.d_model, + ) + + self.blocks = nn.ModuleList( + [ + CortexV1Block( + config, + use_attention=( + ( + layer_index + + 1 + ) + % config.attention_every + == 0 + ), + ) + for layer_index + in range( + config.layers + ) + ] + ) + + self.final_norm = RMSNorm( + config.d_model + ) + + self.lm_bottleneck = ( + TernaryLinear( + config.d_model, + config.output_rank, + bias=False, + ) + ) + + self.lm_output = ( + TernaryLinear( + config.output_rank, + config.vocab_size, + bias=False, + ) + ) + + self.verifier_head = ( + TernaryLinear( + config.d_model, + config.verifier_classes, + ) + ) + + self.future_predictor = ( + TernaryLinear( + config.d_model, + config.d_model, + bias=False, + ) + ) + + def parameter_count( + self, + ) -> int: + return sum( + parameter.numel() + for parameter + in self.parameters() + ) + + def initial_states( + self, + batch_size, + *, + device, + dtype, + ): + return [ + block.initial_state( + batch_size, + device=device, + dtype=dtype, + ) + for block + in self.blocks + ] + + def decode_logits( + self, + hidden, + ): + bottleneck = ( + self.lm_bottleneck( + hidden + ) + ) + + return self.lm_output( + bottleneck + ) + + def step( + self, + tokens, + states=None, + *, + reset_recurrence: bool = False, + disable_attention: bool = False, + collect_diagnostics: bool = False, + ): + if tokens.ndim != 1: + raise ValueError( + "step tokens must be [batch]" + ) + + x = self.embedding( + tokens + ) + + if states is None: + states = ( + self.initial_states( + tokens.shape[0], + device=tokens.device, + dtype=x.dtype, + ) + ) + + if reset_recurrence: + states = [ + BlockState( + memory=( + torch.zeros_like( + state.memory + ) + ), + attention_keys=( + state.attention_keys + ), + attention_values=( + state.attention_values + ), + ) + for state + in states + ] + + new_states = [] + + balance_total = ( + x.new_zeros(()) + ) + + z_total = ( + x.new_zeros(()) + ) + + entropy_total = ( + x.new_zeros(()) + ) + + diagnostics = ( + [] + if collect_diagnostics + else None + ) + + for layer_index, ( + block, + state, + ) in enumerate( + zip( + self.blocks, + states, + ) + ): + ( + x, + new_state, + balance, + z_loss, + entropy, + stats, + ) = block.step( + x, + state, + disable_attention=( + disable_attention + ), + ) + + new_states.append( + new_state + ) + + balance_total = ( + balance_total + + balance + ) + + z_total = ( + z_total + + z_loss + ) + + entropy_total = ( + entropy_total + + entropy + ) + + if collect_diagnostics: + diagnostics.append( + { + "layer": ( + layer_index + ), + **stats, + } + ) + + hidden = self.final_norm( + x + ) + + logits = self.decode_logits( + hidden + ) + + verifier_logits = ( + self.verifier_head( + hidden + ) + ) + + denominator = len( + self.blocks + ) + + return ( + logits, + verifier_logits, + hidden, + new_states, + balance_total + / denominator, + z_total + / denominator, + entropy_total + / denominator, + diagnostics, + ) + + def forward( + self, + tokens, + states=None, + *, + reset_recurrence: bool = False, + disable_attention: bool = False, + collect_diagnostics: bool = False, + ) -> CortexV1Output: + if tokens.ndim != 2: + raise ValueError( + "tokens must be [batch, sequence]" + ) + + logits = [] + verifier_logits = [] + hidden_rows = [] + + balance_total = ( + self.embedding + .weight + .new_zeros(()) + ) + + z_total = ( + self.embedding + .weight + .new_zeros(()) + ) + + entropy_total = ( + self.embedding + .weight + .new_zeros(()) + ) + + diagnostic_totals = None + + if collect_diagnostics: + diagnostic_totals = [ + { + "expert_counts": ( + torch.zeros( + self.config.experts, + dtype=torch.long, + ) + ), + "router_confidence_sum": 0.0, + "router_entropy_sum": 0.0, + "state_norm_sum": 0.0, + "read_norm_sum": 0.0, + "erase_sum": 0.0, + "write_sum": 0.0, + "retention_sum": 0.0, + "attention_entropy_sum": 0.0, + "attention_steps": 0, + "steps": 0, + } + for _ in range( + self.config.layers + ) + ] + + for position in range( + tokens.shape[1] + ): + ( + token_logits, + token_verifier, + token_hidden, + states, + balance, + z_loss, + entropy, + diagnostics, + ) = self.step( + tokens[ + :, + position, + ], + states, + reset_recurrence=( + reset_recurrence + ), + disable_attention=( + disable_attention + ), + collect_diagnostics=( + collect_diagnostics + ), + ) + + logits.append( + token_logits + ) + + verifier_logits.append( + token_verifier + ) + + hidden_rows.append( + token_hidden + ) + + balance_total = ( + balance_total + + balance + ) + + z_total = ( + z_total + + z_loss + ) + + entropy_total = ( + entropy_total + + entropy + ) + + if collect_diagnostics: + for row in diagnostics: + layer = row[ + "layer" + ] + + target = ( + diagnostic_totals[ + layer + ] + ) + + expert = ( + row[ + "top_expert" + ] + .detach() + .cpu() + ) + + target[ + "expert_counts" + ] += torch.bincount( + expert, + minlength=( + self.config.experts + ), + ) + + target[ + "router_confidence_sum" + ] += float( + row[ + "top_probability" + ] + .float() + .mean() + .item() + ) + + target[ + "router_entropy_sum" + ] += float( + row[ + "entropy_normalized" + ] + .item() + ) + + target[ + "state_norm_sum" + ] += float( + row[ + "state_norm" + ].item() + ) + + target[ + "read_norm_sum" + ] += float( + row[ + "read_norm" + ].item() + ) + + target[ + "erase_sum" + ] += float( + row[ + "erase_mean" + ].item() + ) + + target[ + "write_sum" + ] += float( + row[ + "write_mean" + ].item() + ) + + target[ + "retention_sum" + ] += float( + row[ + "retention_mean" + ].item() + ) + + if ( + row[ + "attention_context" + ] + > 0 + ): + target[ + "attention_entropy_sum" + ] += float( + row[ + "attention_entropy" + ].item() + ) + + target[ + "attention_steps" + ] += 1 + + target[ + "steps" + ] += 1 + + sequence = ( + tokens.shape[1] + ) + + return CortexV1Output( + logits=torch.stack( + logits, + dim=1, + ), + verifier_logits=( + torch.stack( + verifier_logits, + dim=1, + ) + ), + hidden=torch.stack( + hidden_rows, + dim=1, + ), + states=states, + router_balance_loss=( + balance_total + / sequence + ), + router_z_loss=( + z_total + / sequence + ), + router_entropy_normalized=( + entropy_total + / sequence + ), + diagnostics=( + diagnostic_totals + ), + ) diff --git a/core/cortex/prime_bridge.py b/core/cortex/prime_bridge.py new file mode 100644 index 0000000..a9612ef --- /dev/null +++ b/core/cortex/prime_bridge.py @@ -0,0 +1,317 @@ +"""Cortex <-> PRIME bridge. + +Neural cognition may propose and predict. +PRIME remains the sole epistemic authority. +""" + +from __future__ import annotations + +from dataclasses import dataclass, asdict +import hashlib +import json +from typing import Any + +from core.language.tslc import TSLCCompiler +from core.verifier.verifier_os import VerifierOS + + +VERIFIER_LABELS = ( + "UNKNOWN", + "ACCEPT", + "REJECT", + "REPAIR", + "ABSTAIN", +) + +VERIFIER_LABEL_TO_ID = { + label: index + for index, label in enumerate(VERIFIER_LABELS) +} + + +def canonical_json( + value: Any, +) -> str: + return json.dumps( + value, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=True, + default=str, + ) + + +def stable_hash( + value: Any, +) -> str: + return hashlib.sha256( + canonical_json(value).encode("utf-8") + ).hexdigest() + + +def action_to_label( + action: str | None, +) -> str: + value = str( + action or "" + ).strip().lower() + + if value in { + "accept", + "accepted", + "record", + "commit", + "committed", + }: + return "ACCEPT" + + if value in { + "reject", + "rejected", + }: + return "REJECT" + + if value in { + "repair", + "open_repair", + "representation_repair", + "supersede", + }: + return "REPAIR" + + if value in { + "abstain", + "abstained", + "quarantine", + "quarantined", + "defer", + "branch", + }: + return "ABSTAIN" + + return "UNKNOWN" + + +def compact_semantics( + compiled: dict, +) -> dict: + premises = list( + compiled + .get("graph_deltas", {}) + .get("premises", []) + )[:4] + + obligations = list( + compiled.get( + "verifier_obligations", + [], + ) + )[:2] + + def clean( + values, + ): + return [ + str(value)[:220] + for value in values + ] + + return { + "provenance": "model_proposer", + "status": "proposed", + "premises": clean( + premises + ), + "obligations": clean( + obligations + ), + } + + +@dataclass +class VerifierExperience: + source_sha256: str + source_text: str + + proposal: dict + proposal_sha256: str + + premises: list[str] + obligation: str + + verifier_action: str + verifier_label: str + verifier_label_id: int + + verifier_result: dict + verifier_result_sha256: str + + authority: str = "NONE" + + parent_hash: str = "" + record_hash: str = "" + + def payload_without_hash( + self, + ): + payload = asdict( + self + ) + + payload.pop( + "record_hash", + None, + ) + + return payload + + +class PrimeCortexBridge: + """Non-authoritative cortex interface to PRIME verification.""" + + def __init__( + self, + *, + compiler=None, + verifier=None, + ): + self.compiler = ( + compiler + if compiler is not None + else TSLCCompiler() + ) + + self.verifier = ( + verifier + if verifier is not None + else VerifierOS() + ) + + def compile_source( + self, + text: str, + ) -> dict: + return self.compiler.compile( + text + ) + + def semantic_proposal( + self, + text: str, + ) -> dict: + return compact_semantics( + self.compile_source( + text + ) + ) + + def verify_proposal( + self, + *, + source_text: str, + source_sha256: str, + proposal: dict, + parent_hash: str = "", + ) -> list[VerifierExperience]: + + premises = [ + str(item) + for item in proposal.get( + "premises", + [], + ) + ] + + obligations = [ + str(item) + for item in proposal.get( + "obligations", + [], + ) + ] + + experiences = [] + + for obligation in obligations: + try: + result = ( + self.verifier.verify_claim( + premises, + obligation, + ) + ) + + action = str( + result.get( + "action", + "unknown", + ) + ) + + except Exception as error: + action = "bridge_error" + + result = { + "action": action, + "error_type": ( + type(error).__name__ + ), + "error": str(error), + } + + label = action_to_label( + action + ) + + proposal_hash = stable_hash( + proposal + ) + + verifier_hash = stable_hash( + result + ) + + experience = VerifierExperience( + source_sha256=( + source_sha256 + ), + source_text=( + source_text + ), + proposal=proposal, + proposal_sha256=( + proposal_hash + ), + premises=premises, + obligation=obligation, + verifier_action=action, + verifier_label=label, + verifier_label_id=( + VERIFIER_LABEL_TO_ID[ + label + ] + ), + verifier_result=result, + verifier_result_sha256=( + verifier_hash + ), + authority="NONE", + parent_hash=parent_hash, + ) + + experience.record_hash = ( + stable_hash( + experience + .payload_without_hash() + ) + ) + + parent_hash = ( + experience.record_hash + ) + + experiences.append( + experience + ) + + return experiences diff --git a/core/cortex/telemetry.py b/core/cortex/telemetry.py new file mode 100644 index 0000000..afeee89 --- /dev/null +++ b/core/cortex/telemetry.py @@ -0,0 +1,86 @@ +"""Native cognition telemetry for Mega PRIME.""" + +from __future__ import annotations + +from dataclasses import ( + asdict, + dataclass, +) +import json + + +@dataclass(frozen=True) +class LayerObservation: + layer: int + + recurrent_state_norm: float + + read_norm: float + + erase_mean: float + + write_mean: float + + selected_expert: int + + expert_probability: float + + +@dataclass(frozen=True) +class TSObs: + sequence: int + + model_id: str + + token_id: int + + token_label: str + + authority: str + + verifier_prediction: int + + verifier_confidence: float + + top_output_tokens: tuple[ + tuple[int, float], + ..., + ] + + layers: tuple[ + LayerObservation, + ..., + ] + + def to_dict( + self, + ) -> dict: + return asdict( + self + ) + + def to_json( + self, + ) -> str: + return json.dumps( + self.to_dict(), + sort_keys=True, + ) + + +def append_jsonl( + path, + observation: TSObs, +) -> None: + with open( + path, + "a", + encoding="utf-8", + ) as handle: + handle.write( + observation.to_json() + ) + + handle.write( + "\n" + ) diff --git a/core/cortex/tokenizer.py b/core/cortex/tokenizer.py new file mode 100644 index 0000000..61d026c --- /dev/null +++ b/core/cortex/tokenizer.py @@ -0,0 +1,94 @@ +"""Transparent byte tokenizer for Mega PRIME Native Cortex.""" + +from __future__ import annotations + + +class ByteTokenizer: + PAD = 256 + BOS = 257 + EOS = 258 + + vocab_size = 259 + + def encode( + self, + text: str, + *, + add_bos: bool = True, + add_eos: bool = True, + ) -> list[int]: + tokens = list( + text.encode( + "utf-8" + ) + ) + + if add_bos: + tokens.insert( + 0, + self.BOS, + ) + + if add_eos: + tokens.append( + self.EOS + ) + + return tokens + + def decode( + self, + tokens, + ) -> str: + raw = bytes( + token + for token in tokens + if ( + 0 <= token < 256 + ) + ) + + return raw.decode( + "utf-8", + errors="replace", + ) + + def token_label( + self, + token: int, + ) -> str: + if token == self.PAD: + return "" + + if token == self.BOS: + return "" + + if token == self.EOS: + return "" + + if not ( + 0 <= token < 256 + ): + return "" + + value = bytes( + [token] + ) + + try: + decoded = value.decode( + "utf-8" + ) + except UnicodeDecodeError: + return ( + f"" + ) + + if decoded.isprintable(): + return repr( + decoded + ) + + return ( + f"" + ) diff --git a/core/cortex/verifier_prompt.py b/core/cortex/verifier_prompt.py new file mode 100644 index 0000000..ddaad96 --- /dev/null +++ b/core/cortex/verifier_prompt.py @@ -0,0 +1,40 @@ +"""Canonical neural prompt for predicting PRIME verifier behaviour.""" + +from __future__ import annotations + + +def format_verifier_prompt( + record: dict, +) -> str: + verifier_type = str( + record.get( + "verifier_type", + "unknown", + ) + ) + + premises = "\n".join( + str(value) + for value + in record.get( + "premises", + [], + ) + ) + + obligation = str( + record.get( + "obligation", + "", + ) + ) + + return ( + "PRIME VERIFIER PREDICTION\n" + f"CHANNEL: {verifier_type}\n" + "PREMISES:\n" + f"{premises}\n" + "OBLIGATION:\n" + f"{obligation}\n" + "VERDICT:\n" + ) diff --git a/core/kernel/__init__.py b/core/kernel/__init__.py index 6e20c1d..403de9f 100644 --- a/core/kernel/__init__.py +++ b/core/kernel/__init__.py @@ -1,11 +1,31 @@ """Canonical verifier-gated TS transaction kernel.""" from .kernel import TSKernel +from .prime_authority import ( + AUTHORITY_MODE_LEGACY_LOCAL, + AUTHORITY_MODE_PRIME_REQUIRED, + PrimeAdmission, + PrimeAuthorityError, + PrimeAuthorityUnavailable, + PrimeV19AuthorityAdapter, +) from .receipts import TSReceipt, validate_receipt_hash -from .transaction import CommitDecision, TransactionRequest, TransactionResult +from .transaction import ( + CommitDecision, + ReentrantGraphTransactionError, + TransactionRequest, + TransactionResult, +) __all__ = [ "CommitDecision", + "AUTHORITY_MODE_LEGACY_LOCAL", + "AUTHORITY_MODE_PRIME_REQUIRED", + "PrimeAdmission", + "PrimeAuthorityError", + "PrimeAuthorityUnavailable", + "PrimeV19AuthorityAdapter", + "ReentrantGraphTransactionError", "TSKernel", "TSReceipt", "TransactionRequest", diff --git a/core/kernel/commit.py b/core/kernel/commit.py index 2cc616b..5801502 100644 --- a/core/kernel/commit.py +++ b/core/kernel/commit.py @@ -6,8 +6,9 @@ from dataclasses import asdict from typing import Any +from ..graph.universal_living_graph import UniversalLivingGraph from ..types import Edge, Node -from .ir import ClaimNode, TSIRDocument +from .ir import ClaimNode, TSIRDocument, stable_hash from .transaction import graph_state_hash @@ -125,6 +126,70 @@ def commit_document( return delta +def preview_document_commit( + *, + base_nodes: dict[str, Node], + base_edges: list[Edge], + document: TSIRDocument, + accepted_claim_ids: set[str], + claim_status_by_id: dict[str, str] | None = None, + commit_branch_only: bool = False, +) -> tuple[dict[str, Any], str, str]: + """Apply a pending commit to a detached graph and return exact projections. + + The result is ``(graph_delta, graph_delta_hash, expected_post_state_hash)``. + No live graph object or persistence backend is touched. + """ + + detached = UniversalLivingGraph( + config={"runtime": {"graph_backend": "memory"}}, + auto_load=False, + ) + for node in sorted(base_nodes.values(), key=lambda item: item.id): + cloned = detached.add_node( + node_id=node.id, + content=node.content, + topics=node.topics, + activation=node.activation, + stability=node.stability, + base_strength=node.base_strength, + last_wave=node.last_wave, + attributes=node.attributes, + embedding=node.embedding, + ) + cloned.collapsed = node.collapsed + for edge in base_edges: + detached.add_edge( + edge.src, + edge.dst, + weight=edge.weight, + relation=edge.relation, + ) + + delta = commit_document( + detached, + document, + accepted_claim_ids=accepted_claim_ids, + claim_status_by_id=claim_status_by_id, + commit_branch_only=commit_branch_only, + ) + return delta, stable_hash(delta), graph_state_hash(detached) + + +def restore_graph_snapshot( + graph: Any, + nodes: dict[str, Node], + edges: list[Edge], +) -> None: + """Restore a detached snapshot after a failed post-commit condition.""" + + snapshot = ( + {node_id: copy.deepcopy(node) for node_id, node in nodes.items()}, + [copy.deepcopy(edge) for edge in edges], + ) + _restore_mutable_snapshot(graph, snapshot) + + def _label(document: TSIRDocument, entity_id: str) -> str: entity = document.entity_by_id(entity_id) if entity is None: diff --git a/core/kernel/kernel.py b/core/kernel/kernel.py index 3049467..5844a32 100644 --- a/core/kernel/kernel.py +++ b/core/kernel/kernel.py @@ -6,7 +6,12 @@ from typing import Any from ..graph.universal_living_graph import UniversalLivingGraph -from .commit import commit_document, render_claim +from .commit import ( + commit_document, + preview_document_commit, + render_claim, + restore_graph_snapshot, +) from .ir import ClaimNode, Provenance, TSOperation, VerifierObligation, stable_hash from .obligations import ( ArithmeticVerifier, @@ -20,6 +25,14 @@ VerificationResult, compile_proof_to_bogvm_artifact, ) +from .prime_authority import ( + AUTHORITY_MODE_LEGACY_LOCAL, + AUTHORITY_MODE_PRIME_REQUIRED, + AUTHORITY_MODES, + PrimeAuthorityUnavailable, + PrimeV19AuthorityAdapter, + admission_binds_boggers_projection, +) from .receipts import TSReceipt, build_receipt from .replay import replay_receipt from .representation import PARSER_VERSION, DeterministicTSParser @@ -31,6 +44,7 @@ TransactionWorkspace, graph_snapshot, graph_state_hash, + serialized_graph_transaction, ) @@ -42,7 +56,18 @@ def __init__( graph: Any | None = None, *, parent_receipt_hash: str | None = None, + authority_mode: str = AUTHORITY_MODE_LEGACY_LOCAL, + prime_authority: PrimeV19AuthorityAdapter | None = None, ) -> None: + if authority_mode not in AUTHORITY_MODES: + raise ValueError(f"unknown authority mode: {authority_mode}") + if ( + prime_authority is not None + and authority_mode != AUTHORITY_MODE_PRIME_REQUIRED + ): + raise ValueError( + "a configured PRIME adapter requires authority_mode='prime_required'" + ) self.graph = ( graph if graph is not None else UniversalLivingGraph(auto_load=False) ) @@ -57,6 +82,8 @@ def __init__( self.commit_policy = CommitPolicyVerifier() self.parent_receipt_hash = parent_receipt_hash self.receipts: list[TSReceipt] = [] + self.authority_mode = authority_mode + self.prime_authority = prime_authority def can_handle(self, text: str) -> bool: parsed = self.parser.parse(text).document @@ -69,6 +96,13 @@ def can_handle(self, text: str) -> bool: ) def transact(self, request: TransactionRequest | str) -> TransactionResult: + with serialized_graph_transaction(self.graph): + return self._transact_serialized(request) + + def _transact_serialized( + self, + request: TransactionRequest | str, + ) -> TransactionResult: if isinstance(request, str): request = TransactionRequest(raw_input=request) @@ -204,20 +238,185 @@ def transact(self, request: TransactionRequest | str) -> TransactionResult: for claim_id, status in claim_status_by_id.items() if status == "accepted" } - if decision == CommitDecision.COMMIT: - workspace.committed_graph_delta = commit_document( - self.graph, - document, - accepted_claim_ids=accepted_claim_ids, - claim_status_by_id=claim_status_by_id, - ) - elif decision == CommitDecision.BRANCH: - workspace.committed_graph_delta = commit_document( - self.graph, - document, - accepted_claim_ids=set(), - commit_branch_only=True, - ) + prime_authority_receipt: dict[str, Any] = {} + prospective_graph_delta: dict[str, Any] | None = None + prospective_graph_delta_hash: str | None = None + expected_post_state_hash: str | None = None + if ( + decision in {CommitDecision.COMMIT, CommitDecision.BRANCH} + and self.authority_mode == AUTHORITY_MODE_PRIME_REQUIRED + ): + if self.prime_authority is None: + decision = CommitDecision.ABSTAIN + reason = "PRIME v19 authority is required but unavailable" + prime_authority_receipt = { + "schema": "boggers-prime-v19-admission-v1", + "authorized": False, + "decision": "ABSTAIN", + "reason_codes": ["prime_authority_unavailable"], + } + else: + try: + ( + prospective_graph_delta, + prospective_graph_delta_hash, + expected_post_state_hash, + ) = preview_document_commit( + base_nodes=workspace.base_nodes, + base_edges=workspace.base_edges, + document=document, + accepted_claim_ids=( + set() + if decision == CommitDecision.BRANCH + else accepted_claim_ids + ), + claim_status_by_id=( + None + if decision == CommitDecision.BRANCH + else claim_status_by_id + ), + commit_branch_only=decision == CommitDecision.BRANCH, + ) + admission = self.prime_authority.authorize_document_commit( + request=request, + workspace=workspace, + document=document, + base_graph_hash=base_hash, + local_decision=decision.value, + local_reason=reason, + accepted_claim_ids=accepted_claim_ids, + claim_status_by_id=claim_status_by_id, + commit_branch_only=decision == CommitDecision.BRANCH, + boggers_parent_receipt_hash=self.parent_receipt_hash, + prospective_graph_delta=prospective_graph_delta, + prospective_graph_delta_hash=prospective_graph_delta_hash, + expected_post_state_hash=expected_post_state_hash, + ) + prime_authority_receipt = admission.to_dict() + if not admission.authorized: + decision = ( + CommitDecision.REJECT + if admission.decision == "REJECT" + else CommitDecision.ABSTAIN + ) + reasons = ",".join(admission.reason_codes) or "no_reason" + reason = f"PRIME v19 authority denied commit: {reasons}" + elif not admission_binds_boggers_projection( + admission, + prospective_graph_delta=prospective_graph_delta, + prospective_graph_delta_hash=prospective_graph_delta_hash, + expected_post_state_hash=expected_post_state_hash, + ): + decision = CommitDecision.ABSTAIN + reason = ( + "PRIME v19 admission did not bind the exact pending " + "Boggers graph projection" + ) + self._invalidate_prime_admission( + prime_authority_receipt, + "boggers_projection_binding_failed", + ) + elif graph_state_hash(self.graph) != base_hash: + decision = CommitDecision.ABSTAIN + reason = ( + "Boggers graph changed while PRIME authority was pending" + ) + self._invalidate_prime_admission( + prime_authority_receipt, + "boggers_base_graph_changed_before_commit", + ) + except PrimeAuthorityUnavailable as exc: + decision = CommitDecision.ABSTAIN + reason = "PRIME v19 authority failed closed" + prime_authority_receipt = { + "schema": "boggers-prime-v19-admission-v1", + "authorized": False, + "decision": "ABSTAIN", + "reason_codes": ["prime_authority_unavailable"], + "error_type": type(exc).__name__, + } + except Exception as exc: + decision = CommitDecision.ABSTAIN + reason = "Boggers could not project the pending PRIME commit" + prime_authority_receipt = { + "schema": "boggers-prime-v19-admission-v1", + "authorized": False, + "decision": "ABSTAIN", + "reason_codes": ["boggers_prospective_commit_failed"], + "error_type": type(exc).__name__, + } + if decision in {CommitDecision.COMMIT, CommitDecision.BRANCH}: + if self.authority_mode == AUTHORITY_MODE_PRIME_REQUIRED: + try: + committed_graph_delta = commit_document( + self.graph, + document, + accepted_claim_ids=( + set() + if decision == CommitDecision.BRANCH + else accepted_claim_ids + ), + claim_status_by_id=( + None + if decision == CommitDecision.BRANCH + else claim_status_by_id + ), + commit_branch_only=decision == CommitDecision.BRANCH, + ) + actual_post_state_hash = graph_state_hash(self.graph) + projection_matches = ( + prospective_graph_delta is not None + and prospective_graph_delta_hash is not None + and expected_post_state_hash is not None + and committed_graph_delta == prospective_graph_delta + and stable_hash(committed_graph_delta) + == prospective_graph_delta_hash + and actual_post_state_hash == expected_post_state_hash + ) + if not projection_matches: + restore_graph_snapshot( + self.graph, + workspace.base_nodes, + workspace.base_edges, + ) + decision = CommitDecision.ABSTAIN + reason = ( + "Boggers commit did not match the PRIME-authorized " + "graph projection" + ) + self._invalidate_prime_admission( + prime_authority_receipt, + "boggers_post_commit_verification_failed", + ) + else: + workspace.committed_graph_delta = committed_graph_delta + except Exception as exc: + restore_graph_snapshot( + self.graph, + workspace.base_nodes, + workspace.base_edges, + ) + decision = CommitDecision.ABSTAIN + reason = "Boggers failed to apply the PRIME-authorized commit" + self._invalidate_prime_admission( + prime_authority_receipt, + "boggers_commit_application_failed", + ) + prime_authority_receipt["error_type"] = type(exc).__name__ + elif decision == CommitDecision.COMMIT: + workspace.committed_graph_delta = commit_document( + self.graph, + document, + accepted_claim_ids=accepted_claim_ids, + claim_status_by_id=claim_status_by_id, + ) + else: + workspace.committed_graph_delta = commit_document( + self.graph, + document, + accepted_claim_ids=set(), + commit_branch_only=True, + ) self._mark_bogvm_commit_authorization(workspace, decision) post_hash = graph_state_hash(self.graph) @@ -267,6 +466,8 @@ def transact(self, request: TransactionRequest | str) -> TransactionResult: ], rendered_explanation=rendered, committed_graph_delta=workspace.committed_graph_delta, + authority_mode=self.authority_mode, + prime_authority_receipt=prime_authority_receipt, ) receipt.renderer_metadata["replay_verified"] = ( self._verify_replay_from_workspace(workspace, receipt) @@ -276,6 +477,17 @@ def transact(self, request: TransactionRequest | str) -> TransactionResult: self.parent_receipt_hash = receipt.receipt_hash return TransactionResult(decision=decision, receipt=receipt, rendered=rendered) + @staticmethod + def _invalidate_prime_admission( + prime_authority_receipt: dict[str, Any], + reason_code: str, + ) -> None: + prime_authority_receipt["authorized"] = False + prime_authority_receipt["reason_codes"] = [ + *prime_authority_receipt.get("reason_codes", []), + reason_code, + ] + def replay( self, receipt: TSReceipt | dict[str, Any], graph: Any | None = None ) -> str: diff --git a/core/kernel/prime_authority.py b/core/kernel/prime_authority.py new file mode 100644 index 0000000..9524fd8 --- /dev/null +++ b/core/kernel/prime_authority.py @@ -0,0 +1,442 @@ +"""PRIME v19 admission seam for canonical Boggers graph commits. + +Boggers owns parsing, domain verification, TSIR, BOGVM, and application of its +local graph delta. PRIME owns the final admission decision. This adapter turns +the exact pending ``commit_document`` call into a content-addressed PRIME graph +proposal and refuses authority unless the returned receipt verifies against the +same live PRIME kernel. + +The import of :mod:`prime_v19` is intentionally lazy. Legacy-local mode can +continue to load Boggers during the migration, while ``prime_required`` fails +closed at transaction time when PRIME is unavailable. +""" + +from __future__ import annotations + +from dataclasses import asdict, dataclass +import math +from typing import Any, Iterable + +from .ir import TSIRDocument, stable_hash as boggers_stable_hash +from .representation import PARSER_VERSION +from .transaction import TransactionRequest, TransactionWorkspace + + +AUTHORITY_MODE_LEGACY_LOCAL = "legacy_local" +AUTHORITY_MODE_PRIME_REQUIRED = "prime_required" +AUTHORITY_MODES = frozenset( + {AUTHORITY_MODE_LEGACY_LOCAL, AUTHORITY_MODE_PRIME_REQUIRED} +) + + +class PrimeAuthorityError(RuntimeError): + """Base class for failures at the external authority boundary.""" + + +class PrimeAuthorityUnavailable(PrimeAuthorityError): + """Raised when the configured PRIME runtime cannot be invoked.""" + + +@dataclass(frozen=True, slots=True) +class PrimeAdmission: + """Detached summary of one PRIME admission attempt.""" + + authorized: bool + decision: str + reason_codes: tuple[str, ...] + mutation_intent_hash: str + proposal_hash: str + receipt: dict[str, Any] + + def to_dict(self) -> dict[str, Any]: + return { + "schema": "boggers-prime-v19-admission-v1", + "authorized": self.authorized, + "decision": self.decision, + "reason_codes": list(self.reason_codes), + "mutation_intent_hash": self.mutation_intent_hash, + "proposal_hash": self.proposal_hash, + "receipt": self.receipt, + } + + +class PrimeV19AuthorityAdapter: + """Translate a verified Boggers transaction into one PRIME v19 request. + + ``prime_kernel`` is an already bootstrapped ``prime_v19.AuthorityKernel``. + Its verifier registry and policy remain the trusted boot configuration; + this adapter supplies evidence, never a caller-authored pass/fail result. + """ + + def __init__( + self, + prime_kernel: Any, + *, + proposer_key_id: str, + proposer_signing_key: bytes, + evidence_obligations: Iterable[str] = ("safety", "semantic"), + representation_evidence_obligations: Iterable[str] | None = None, + proposer_id: str = "boggers.tskernel.commit-proposer", + ) -> None: + obligations = tuple(evidence_obligations) + representation_obligations = ( + tuple(representation_evidence_obligations) + if representation_evidence_obligations is not None + else tuple(dict.fromkeys((*obligations, "representation_economics"))) + ) + if prime_kernel is None: + raise ValueError("prime_kernel cannot be None") + if not proposer_id: + raise ValueError("proposer_id cannot be empty") + if not proposer_key_id: + raise ValueError("proposer_key_id cannot be empty") + if ( + not isinstance(proposer_signing_key, bytes) + or len(proposer_signing_key) < 32 + or len(set(proposer_signing_key)) < 8 + ): + raise ValueError( + "proposer_signing_key must contain at least 32 bytes and " + "8 distinct byte values" + ) + if not obligations or len(obligations) != len(set(obligations)): + raise ValueError("evidence obligations must be non-empty and unique") + if ( + not representation_obligations + or len(representation_obligations) != len(set(representation_obligations)) + or "representation_economics" not in representation_obligations + ): + raise ValueError( + "representation evidence obligations must be unique and include " + "'representation_economics'" + ) + self._prime_kernel = prime_kernel + self._evidence_obligations = obligations + self._representation_evidence_obligations = representation_obligations + self._proposer_id = proposer_id + self._proposer_key_id = proposer_key_id + self._proposer_signing_key = bytes(proposer_signing_key) + + def authorize_document_commit( + self, + *, + request: TransactionRequest, + workspace: TransactionWorkspace, + document: TSIRDocument, + base_graph_hash: str, + local_decision: str, + local_reason: str, + accepted_claim_ids: set[str], + claim_status_by_id: dict[str, str], + commit_branch_only: bool, + boggers_parent_receipt_hash: str | None, + prospective_graph_delta: dict[str, Any], + prospective_graph_delta_hash: str, + expected_post_state_hash: str, + ) -> PrimeAdmission: + try: + from prime_v19 import ( + AuthorityRequest, + Decision, + EvidenceEnvelope, + GraphNode, + GraphPatchProposal, + PatchOperation, + Scope, + stable_hash, + ) + except (ImportError, ModuleNotFoundError) as exc: + raise PrimeAuthorityUnavailable("PRIME v19 package is unavailable") from exc + + try: + context = self._prime_kernel.context + intent = self._build_mutation_intent( + request=request, + workspace=workspace, + document=document, + base_graph_hash=base_graph_hash, + local_decision=local_decision, + local_reason=local_reason, + accepted_claim_ids=accepted_claim_ids, + claim_status_by_id=claim_status_by_id, + commit_branch_only=commit_branch_only, + prospective_graph_delta=prospective_graph_delta, + prospective_graph_delta_hash=prospective_graph_delta_hash, + expected_post_state_hash=expected_post_state_hash, + ) + mutation_intent_hash = stable_hash(intent) + provenance = { + "schema": "boggers-prime-v19-provenance-v1", + "source": request.provenance, + "parser_version": PARSER_VERSION, + "boggers_parent_receipt_hash": boggers_parent_receipt_hash, + "boggers_document_hash": document.hash(), + } + node_id = ( + "boggers-commit-" + + stable_hash( + { + "mutation_intent_hash": mutation_intent_hash, + "prime_parent_root": context.current_root, + "prime_sequence": context.next_sequence, + } + )[:40] + ) + is_representation_transition = ( + commit_branch_only or self._contains_representation_transition(document) + ) + node_kind = ( + "boggers_representation_commit" + if is_representation_transition + else "boggers_document_commit" + ) + intent_node = GraphNode.create( + node_id, + node_kind, + { + "mutation_intent": intent, + "mutation_intent_hash": mutation_intent_hash, + "provenance": provenance, + }, + ) + scope = ( + Scope.REPRESENTATION_TRANSITION + if is_representation_transition + else Scope.DETERMINISTIC_SEMANTIC_COMMIT + ) + proposal = GraphPatchProposal.create( + graph_lineage_id=context.graph_lineage_id, + scope=scope, + proposer_id=self._proposer_id, + proposer_key_id=self._proposer_key_id, + proposer_signing_key=self._proposer_signing_key, + parent_root=context.current_root, + parent_authority_hash=context.parent_authority_hash, + expected_sequence=context.next_sequence, + mutation_intent_hash=mutation_intent_hash, + provenance_hash=stable_hash(provenance), + affected_nodes=(node_id,), + operations=(PatchOperation.upsert_node(intent_node),), + metadata={ + "adapter_schema": "boggers-prime-v19-adapter-v1", + "boggers_base_graph_hash": base_graph_hash, + "boggers_document_hash": document.hash(), + "prospective_graph_delta_hash": prospective_graph_delta_hash, + "expected_post_state_hash": expected_post_state_hash, + }, + ) + evidence_payload = { + "schema": "boggers-prime-v19-evidence-v1", + "proposal_hash": proposal.proposal_hash, + "mutation_intent_hash": mutation_intent_hash, + "boggers_base_graph_hash": base_graph_hash, + "boggers_document_hash": document.hash(), + "prospective_graph_delta_hash": prospective_graph_delta_hash, + "expected_post_state_hash": expected_post_state_hash, + "local_verifier_obligations_hash": boggers_stable_hash( + intent["verifier_obligations"] + ), + "local_verification_results_hash": boggers_stable_hash( + intent["verification_results"] + ), + } + authority_request = AuthorityRequest.create( + proposal, + tuple( + EvidenceEnvelope.create( + obligation, + {**evidence_payload, "obligation_id": obligation}, + ) + for obligation in ( + self._representation_evidence_obligations + if is_representation_transition + else self._evidence_obligations + ) + ), + ) + receipt = self._prime_kernel.authorize_and_commit(authority_request) + receipt_payload = receipt.to_dict() + + binding_valid = self._receipt_binds_exact_request( + receipt=receipt, + authority_request=authority_request, + proposal=proposal, + mutation_intent_hash=mutation_intent_hash, + ) + cryptographically_valid = bool(self._prime_kernel.verify_receipt(receipt)) + live_state_valid = bool(self._prime_kernel.verify_live_state()) + authorized = ( + receipt.decision is Decision.AUTHORIZE + and bool(receipt.ledgered) + and binding_valid + and cryptographically_valid + and live_state_valid + ) + reason_codes = tuple(str(reason) for reason in receipt.reason_codes) + if not binding_valid: + reason_codes += ("adapter_binding_verification_failed",) + if not cryptographically_valid: + reason_codes += ("prime_receipt_verification_failed",) + if not live_state_valid: + reason_codes += ("prime_live_state_verification_failed",) + + return PrimeAdmission( + authorized=authorized, + decision=str(receipt.decision.value), + reason_codes=reason_codes, + mutation_intent_hash=mutation_intent_hash, + proposal_hash=proposal.proposal_hash, + receipt=receipt_payload, + ) + except PrimeAuthorityError: + raise + except Exception as exc: + raise PrimeAuthorityUnavailable( + f"PRIME v19 authority call failed: {type(exc).__name__}" + ) from exc + + @staticmethod + def _build_mutation_intent( + *, + request: TransactionRequest, + workspace: TransactionWorkspace, + document: TSIRDocument, + base_graph_hash: str, + local_decision: str, + local_reason: str, + accepted_claim_ids: set[str], + claim_status_by_id: dict[str, str], + commit_branch_only: bool, + prospective_graph_delta: dict[str, Any], + prospective_graph_delta_hash: str, + expected_post_state_hash: str, + ) -> dict[str, Any]: + intent = { + "schema": "boggers-document-commit-intent-v2", + "numeric_encoding": "python-float-as-decimal-tag-v1", + "boggers_base_graph_hash": base_graph_hash, + "raw_input_hash": boggers_stable_hash({"raw_input": request.raw_input}), + "request_provenance": request.provenance, + "document_hash": document.hash(), + "document": document.to_dict(), + "local_decision": local_decision, + "local_reason": local_reason, + "accepted_claim_ids": sorted(accepted_claim_ids), + "claim_status_by_id": { + key: claim_status_by_id[key] for key in sorted(claim_status_by_id) + }, + "commit_branch_only": commit_branch_only, + "prospective_graph_delta": prospective_graph_delta, + "prospective_graph_delta_hash": prospective_graph_delta_hash, + "expected_post_state_hash": expected_post_state_hash, + "verifier_obligations": [ + asdict(item) + for item in sorted(workspace.obligations, key=lambda item: item.id) + ], + "verification_results": [ + result.to_dict() + for result in sorted( + workspace.verification_results, + key=lambda item: (item.obligation_id, item.verifier_type), + ) + ], + "bogvm_artifacts": list(workspace.bogvm_artifacts), + } + return PrimeV19AuthorityAdapter._prime_canonical_value(intent) + + @staticmethod + def _prime_canonical_value(value: Any) -> Any: + """Encode Boggers floats without weakening PRIME's canonical JSON rules.""" + + if isinstance(value, float): + if not math.isfinite(value): + raise ValueError( + "non-finite Boggers value cannot cross PRIME authority" + ) + return {"$python_float_decimal": repr(value)} + if isinstance(value, dict): + if any(not isinstance(key, str) for key in value): + raise TypeError("PRIME-bound object keys must be strings") + return { + key: PrimeV19AuthorityAdapter._prime_canonical_value(item) + for key, item in value.items() + } + if isinstance(value, (list, tuple)): + return [ + PrimeV19AuthorityAdapter._prime_canonical_value(item) for item in value + ] + return value + + @staticmethod + def _contains_representation_transition(document: TSIRDocument) -> bool: + return any( + operation.operation_type + in {"BRANCH_REPRESENTATION", "MERGE_REPRESENTATION"} + for operation in document.operations + ) + + def _receipt_binds_exact_request( + self, + *, + receipt: Any, + authority_request: Any, + proposal: Any, + mutation_intent_hash: str, + ) -> bool: + try: + live_context = self._prime_kernel.context + live_snapshot = self._prime_kernel.snapshot + return ( + receipt.request_hash == authority_request.request_hash + and receipt.proposal.proposal_hash == proposal.proposal_hash + and receipt.proposal.parent_root == proposal.parent_root + and receipt.proposal.graph_lineage_id == proposal.graph_lineage_id + and receipt.proposal.mutation_intent_hash == mutation_intent_hash + and receipt.previous_root == proposal.parent_root + and receipt.sequence == proposal.expected_sequence + and receipt.previous_hash == proposal.parent_authority_hash + and receipt.new_root == live_snapshot.root + and live_context.parent_authority_hash == receipt.receipt_hash + ) + except (AttributeError, TypeError, ValueError): + return False + + +def admission_binds_boggers_projection( + admission: PrimeAdmission, + *, + prospective_graph_delta: dict[str, Any], + prospective_graph_delta_hash: str, + expected_post_state_hash: str, +) -> bool: + """Independently verify the local projection inside a detached admission. + + This check deliberately runs in ``TSKernel`` after the adapter returns. It + prevents a buggy or tampering adapter wrapper from swapping the prospective + delta or post-state after PRIME verification but before Boggers publishes it. + """ + + try: + from prime_v19 import stable_hash as prime_stable_hash + + proposal = admission.receipt["proposal"] + metadata = proposal["metadata"] + operation_payload = proposal["operations"][0]["body"]["payload"] + intent = operation_payload["mutation_intent"] + canonical_delta = PrimeV19AuthorityAdapter._prime_canonical_value( + prospective_graph_delta + ) + return ( + boggers_stable_hash(prospective_graph_delta) == prospective_graph_delta_hash + and intent["prospective_graph_delta"] == canonical_delta + and intent["prospective_graph_delta_hash"] == prospective_graph_delta_hash + and intent["expected_post_state_hash"] == expected_post_state_hash + and metadata["prospective_graph_delta_hash"] == prospective_graph_delta_hash + and metadata["expected_post_state_hash"] == expected_post_state_hash + and operation_payload["mutation_intent_hash"] + == admission.mutation_intent_hash + and proposal["mutation_intent_hash"] == admission.mutation_intent_hash + and prime_stable_hash(intent) == admission.mutation_intent_hash + ) + except (AttributeError, ImportError, IndexError, KeyError, TypeError, ValueError): + return False diff --git a/core/kernel/receipts.py b/core/kernel/receipts.py index c56cf00..b439c1e 100644 --- a/core/kernel/receipts.py +++ b/core/kernel/receipts.py @@ -34,6 +34,8 @@ class TSReceipt: post_state_hash: str parent_receipt_hash: str | None receipt_hash: str + authority_mode: str = "legacy_local" + prime_authority_receipt: dict[str, Any] = field(default_factory=dict) renderer_metadata: dict[str, Any] = field(default_factory=dict) reasoning_artifacts: list[dict[str, Any]] = field(default_factory=list) execution_artifacts: list[dict[str, Any]] = field(default_factory=list) @@ -81,6 +83,8 @@ def build_receipt( proof_artifacts: list[dict[str, Any]], rendered_explanation: str, committed_graph_delta: dict[str, Any], + authority_mode: str = "legacy_local", + prime_authority_receipt: dict[str, Any] | None = None, ) -> TSReceipt: input_hash = stable_hash({"raw_input": raw_input}) transaction_id = ( @@ -115,6 +119,8 @@ def build_receipt( post_state_hash=post_state_hash, parent_receipt_hash=parent_receipt_hash, receipt_hash="", + authority_mode=authority_mode, + prime_authority_receipt=prime_authority_receipt or {}, renderer_metadata=renderer_metadata, reasoning_artifacts=reasoning_artifacts, execution_artifacts=execution_artifacts, diff --git a/core/kernel/transaction.py b/core/kernel/transaction.py index 1dd4219..ebc8844 100644 --- a/core/kernel/transaction.py +++ b/core/kernel/transaction.py @@ -3,14 +3,132 @@ from __future__ import annotations import copy +from contextlib import contextmanager from dataclasses import asdict, dataclass, field from enum import Enum +import threading from typing import Any +import weakref from ..types import Edge, Node from .ir import TSIRDocument, VerifierObligation, stable_hash +class ReentrantGraphTransactionError(RuntimeError): + """Raised instead of deadlocking on a nested transaction for one graph.""" + + +@dataclass(slots=True) +class _GraphTransactionGuard: + transaction_lock: threading.Lock = field(default_factory=threading.Lock) + owner_lock: threading.Lock = field(default_factory=threading.Lock) + owner_thread_id: int | None = None + + +_GRAPH_GUARDS_LOCK = threading.Lock() +_GRAPH_GUARDS: dict[ + int, + tuple[weakref.ReferenceType[Any] | Any, _GraphTransactionGuard], +] = {} + + +def _drop_graph_guard( + graph_id: int, + graph_reference: weakref.ReferenceType[Any], +) -> None: + with _GRAPH_GUARDS_LOCK: + entry = _GRAPH_GUARDS.get(graph_id) + if entry is not None and entry[0] is graph_reference: + _GRAPH_GUARDS.pop(graph_id, None) + + +def _graph_transaction_guard(graph: Any) -> _GraphTransactionGuard: + graph_id = id(graph) + with _GRAPH_GUARDS_LOCK: + existing = _GRAPH_GUARDS.get(graph_id) + if existing is not None: + reference, guard = existing + referenced_graph = ( + reference() + if isinstance(reference, weakref.ReferenceType) + else reference + ) + if referenced_graph is graph: + return guard + _GRAPH_GUARDS.pop(graph_id, None) + + guard = _GraphTransactionGuard() + try: + reference = weakref.ref( + graph, + lambda item, key=graph_id: _drop_graph_guard(key, item), + ) + except TypeError: + # A non-weak-referenceable graph is retained so object-id reuse can + # never alias two guards. Such custom graph objects are uncommon. + reference = graph + _GRAPH_GUARDS[graph_id] = (reference, guard) + return guard + + +@contextmanager +def _held_graph_lock(graph: Any): + """Hold a graph-native lock for callers which mutate through graph methods. + + ``UniversalLivingGraph`` exposes a re-entrant context-manager lock. The + acquire/release fallback supports equivalent graph implementations without + requiring them to implement the context-manager protocol. + """ + + graph_lock = getattr(graph, "_lock", None) + if graph_lock is None: + yield + return + if hasattr(graph_lock, "__enter__") and hasattr(graph_lock, "__exit__"): + with graph_lock: + yield + return + acquire = getattr(graph_lock, "acquire", None) + release = getattr(graph_lock, "release", None) + if not callable(acquire) or not callable(release): + yield + return + acquire() + try: + yield + finally: + release() + + +@contextmanager +def serialized_graph_transaction(graph: Any): + """Serialize the complete TSKernel transaction for one graph object. + + The guard is shared by every TSKernel instance using the same in-process + graph. A nested call from the owning thread fails immediately instead of + blocking forever on the non-reentrant transaction lock. + """ + + guard = _graph_transaction_guard(graph) + thread_id = threading.get_ident() + with guard.owner_lock: + if guard.owner_thread_id == thread_id: + raise ReentrantGraphTransactionError( + "a graph transaction cannot re-enter itself" + ) + + with _held_graph_lock(graph): + guard.transaction_lock.acquire() + try: + with guard.owner_lock: + guard.owner_thread_id = thread_id + yield + finally: + with guard.owner_lock: + guard.owner_thread_id = None + guard.transaction_lock.release() + + class CommitDecision(str, Enum): COMMIT = "commit" REJECT = "reject" diff --git a/data/native_cortex/tokenizer/TOKENIZER_MANIFEST.json b/data/native_cortex/tokenizer/TOKENIZER_MANIFEST.json new file mode 100644 index 0000000..2d33fa8 --- /dev/null +++ b/data/native_cortex/tokenizer/TOKENIZER_MANIFEST.json @@ -0,0 +1,14 @@ +{ + "format": "mega-prime-bpe-v1", + "requested_vocab_size": 4096, + "special_tokens": [ + "", + "", + "", + "" + ], + "tokenizer_sha256": "a9d5e03bc9fded944c506f325beecc38ef11995ac0de0cf5745a3cd36fba91f4", + "train_corpus": "/home/boggersthefish/BoggersSpace/BoggersTheAI/data/native_cortex/splits/train.jsonl", + "train_corpus_sha256": "f69c1b1849b06324e6983d121a8dc7f007fb449adfcba432952f0a9acc3e795c", + "vocab_size": 4096 +} \ No newline at end of file diff --git a/data/native_cortex/tokenizer/TOKENIZER_MANIFEST.sha256 b/data/native_cortex/tokenizer/TOKENIZER_MANIFEST.sha256 new file mode 100644 index 0000000..0582a88 --- /dev/null +++ b/data/native_cortex/tokenizer/TOKENIZER_MANIFEST.sha256 @@ -0,0 +1 @@ +be51510d7933546f49d2b6d23d852d154c1daea47d8c1a0696fa8c3a65bd0f41 TOKENIZER_MANIFEST.json diff --git a/data/native_cortex/tokenizer/tokenizer.json b/data/native_cortex/tokenizer/tokenizer.json new file mode 100644 index 0000000..f130678 --- /dev/null +++ b/data/native_cortex/tokenizer/tokenizer.json @@ -0,0 +1,19513 @@ +{ + "version": "1.0", + "truncation": null, + "padding": null, + "added_tokens": [ + { + "id": 0, + "content": "", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 1, + "content": "", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 2, + "content": "", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 3, + "content": "", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + } + ], + "normalizer": { + "type": "NFC" + }, + "pre_tokenizer": { + "type": "ByteLevel", + "add_prefix_space": false, + "trim_offsets": true, + "use_regex": true + }, + "post_processor": null, + "decoder": { + "type": "ByteLevel", + "add_prefix_space": true, + "trim_offsets": true, + "use_regex": true + }, + "model": { + "type": "BPE", + "dropout": null, + "unk_token": "", + "continuing_subword_prefix": null, + "end_of_word_suffix": null, + "fuse_unk": false, + "byte_fallback": false, + "ignore_merges": false, + "vocab": { + "": 0, + "": 1, + "": 2, + "": 3, + "!": 4, + "\"": 5, + "#": 6, + "$": 7, + "%": 8, + "&": 9, + "'": 10, + "(": 11, + ")": 12, + "*": 13, + "+": 14, + ",": 15, + "-": 16, + ".": 17, + "/": 18, + "0": 19, + "1": 20, + "2": 21, + "3": 22, + "4": 23, + "5": 24, + "6": 25, + "7": 26, + "8": 27, + "9": 28, + ":": 29, + ";": 30, + "<": 31, + "=": 32, + ">": 33, + "?": 34, + "@": 35, + "A": 36, + "B": 37, + "C": 38, + "D": 39, + "E": 40, + "F": 41, + "G": 42, + "H": 43, + "I": 44, + "J": 45, + "K": 46, + "L": 47, + "M": 48, + "N": 49, + "O": 50, + "P": 51, + "Q": 52, + "R": 53, + "S": 54, + "T": 55, + "U": 56, + "V": 57, + "W": 58, + "X": 59, + "Y": 60, + "Z": 61, + "[": 62, + "\\": 63, + "]": 64, + "^": 65, + "_": 66, + "`": 67, + "a": 68, + "b": 69, + "c": 70, + "d": 71, + "e": 72, + "f": 73, + "g": 74, + "h": 75, + "i": 76, + "j": 77, + "k": 78, + "l": 79, + "m": 80, + "n": 81, + "o": 82, + "p": 83, + "q": 84, + "r": 85, + "s": 86, + "t": 87, + "u": 88, + "v": 89, + "w": 90, + "x": 91, + "y": 92, + "z": 93, + "{": 94, + "|": 95, + "}": 96, + "~": 97, + "¡": 98, + "¢": 99, + "£": 100, + "¤": 101, + "¥": 102, + "¦": 103, + "§": 104, + "¨": 105, + "©": 106, + "ª": 107, + "«": 108, + "¬": 109, + "®": 110, + "¯": 111, + "°": 112, + "±": 113, + "²": 114, + "³": 115, + "´": 116, + "µ": 117, + "¶": 118, + "·": 119, + "¸": 120, + "¹": 121, + "º": 122, + "»": 123, + "¼": 124, + "½": 125, + "¾": 126, + "¿": 127, + "À": 128, + "Á": 129, + "Â": 130, + "Ã": 131, + "Ä": 132, + "Å": 133, + "Æ": 134, + "Ç": 135, + "È": 136, + "É": 137, + "Ê": 138, + "Ë": 139, + "Ì": 140, + "Í": 141, + "Î": 142, + "Ï": 143, + "Ð": 144, + "Ñ": 145, + "Ò": 146, + "Ó": 147, + "Ô": 148, + "Õ": 149, + "Ö": 150, + "×": 151, + "Ø": 152, + "Ù": 153, + "Ú": 154, + "Û": 155, + "Ü": 156, + "Ý": 157, + "Þ": 158, + "ß": 159, + "à": 160, + "á": 161, + "â": 162, + "ã": 163, + "ä": 164, + "å": 165, + "æ": 166, + "ç": 167, + "è": 168, + "é": 169, + "ê": 170, + "ë": 171, + "ì": 172, + "í": 173, + "î": 174, + "ï": 175, + "ð": 176, + "ñ": 177, + "ò": 178, + "ó": 179, + "ô": 180, + "õ": 181, + "ö": 182, + "÷": 183, + "ø": 184, + "ù": 185, + "ú": 186, + "û": 187, + "ü": 188, + "ý": 189, + "þ": 190, + "ÿ": 191, + "Ā": 192, + "ā": 193, + "Ă": 194, + "ă": 195, + "Ą": 196, + "ą": 197, + "Ć": 198, + "ć": 199, + "Ĉ": 200, + "ĉ": 201, + "Ċ": 202, + "ċ": 203, + "Č": 204, + "č": 205, + "Ď": 206, + "ď": 207, + "Đ": 208, + "đ": 209, + "Ē": 210, + "ē": 211, + "Ĕ": 212, + "ĕ": 213, + "Ė": 214, + "ė": 215, + "Ę": 216, + "ę": 217, + "Ě": 218, + "ě": 219, + "Ĝ": 220, + "ĝ": 221, + "Ğ": 222, + "ğ": 223, + "Ġ": 224, + "ġ": 225, + "Ģ": 226, + "ģ": 227, + "Ĥ": 228, + "ĥ": 229, + "Ħ": 230, + "ħ": 231, + "Ĩ": 232, + "ĩ": 233, + "Ī": 234, + "ī": 235, + "Ĭ": 236, + "ĭ": 237, + "Į": 238, + "į": 239, + "İ": 240, + "ı": 241, + "IJ": 242, + "ij": 243, + "Ĵ": 244, + "ĵ": 245, + "Ķ": 246, + "ķ": 247, + "ĸ": 248, + "Ĺ": 249, + "ĺ": 250, + "Ļ": 251, + "ļ": 252, + "Ľ": 253, + "ľ": 254, + "Ŀ": 255, + "ŀ": 256, + "Ł": 257, + "ł": 258, + "Ń": 259, + "Ġt": 260, + "he": 261, + "Ġa": 262, + "Ġs": 263, + "Ġthe": 264, + "Ġw": 265, + "nd": 266, + "in": 267, + "ed": 268, + "er": 269, + "Ġand": 270, + "Ġb": 271, + "Ġto": 272, + "re": 273, + "Ġo": 274, + "Ġf": 275, + "it": 276, + "Ġh": 277, + "Ġc": 278, + "as": 279, + "ou": 280, + "at": 281, + "Ġp": 282, + "Ġd": 283, + "ar": 284, + "is": 285, + "on": 286, + "an": 287, + "Ġm": 288, + "Ġl": 289, + "en": 290, + "ing": 291, + "or": 292, + "om": 293, + "ĠT": 294, + "Ġhe": 295, + "Ġwas": 296, + "es": 297, + "il": 298, + "Ġ,": 299, + "al": 300, + "ay": 301, + "Ġin": 302, + "Ġg": 303, + "Ġof": 304, + "id": 305, + "Ġn": 306, + "ĠS": 307, + "Ġth": 308, + "ad": 309, + "ĠThe": 310, + "Ġ.": 311, + "im": 312, + "le": 313, + "ic": 314, + "ut": 315, + "ot": 316, + "et": 317, + "ĠH": 318, + "Ġit": 319, + "ir": 320, + "Ġ\"": 321, + "Ġe": 322, + "Ġsa": 323, + "el": 324, + "ow": 325, + "ver": 326, + "am": 327, + "ac": 328, + "ig": 329, + "ent": 330, + "Ġher": 331, + "Ġon": 332, + "un": 333, + "Ġbe": 334, + "ĠI": 335, + "Ġst": 336, + "Ġr": 337, + "ith": 338, + "Ġre": 339, + "ve": 340, + "ly": 341, + "Ġwith": 342, + "ĠHe": 343, + "ld": 344, + "ĠShe": 345, + "ion": 346, + "Ġha": 347, + "oo": 348, + "st": 349, + "ĠL": 350, + "Ġthat": 351, + "Ġy": 352, + "Ġu": 353, + "Ġfor": 354, + "ĠB": 355, + "ri": 356, + "pp": 357, + "ĠThey": 358, + "Ġhis": 359, + "ĠA": 360, + "ĠM": 361, + "ke": 362, + "ily": 363, + "Ġsaid": 364, + "ur": 365, + "Ġpl": 366, + "ked": 367, + "ted": 368, + "Ġshe": 369, + "ce": 370, + "Ġas": 371, + "On": 372, + "Ġwh": 373, + "Ġso": 374, + "her": 375, + "Ġal": 376, + "ec": 377, + "ter": 378, + "Ġyou": 379, + "Ġis": 380, + "Ġhad": 381, + "ol": 382, + "very": 383, + "Ġday": 384, + "se": 385, + "ul": 386, + "Ġan": 387, + "Ġ1": 388, + "Ġplay": 389, + "Ġup": 390, + "ĠC": 391, + "Ġthey": 392, + "Ġsh": 393, + "ch": 394, + "ould": 395, + "Ġ@": 396, + "ĠLily": 397, + "ro": 398, + "The": 399, + "Ġat": 400, + "Ġnot": 401, + "ound": 402, + "Ġk": 403, + "Ġmom": 404, + "ain": 405, + "ht": 406, + "ere": 407, + "my": 408, + "Ġli": 409, + "ome": 410, + "Ġne": 411, + "end": 412, + "Ġwere": 413, + "itt": 414, + "ime": 415, + "rom": 416, + "all": 417, + "'s": 418, + "ore": 419, + "ack": 420, + "ra": 421, + "Ġbut": 422, + "Ġse": 423, + "Ġhapp": 424, + "ill": 425, + "ĠJ": 426, + "Ġwan": 427, + "Ġtime": 428, + "um": 429, + "Ġ'": 430, + "ard": 431, + "ĠW": 432, + "ved": 433, + "ĠIt": 434, + "ide": 435, + "ry": 436, + "Ġthere": 437, + "Ġvery": 438, + "Ġare": 439, + "Ġdo": 440, + "ittle": 441, + "-@": 442, + "Ġ@-@": 443, + "ug": 444, + "Ġlittle": 445, + "ag": 446, + "Ġsm": 447, + "Ġlo": 448, + "Ġex": 449, + "th": 450, + "ĠD": 451, + "Ġbig": 452, + "Ġhappy": 453, + "Ġsp": 454, + "us": 455, + "ake": 456, + "riend": 457, + "Ġfriend": 458, + "if": 459, + "uc": 460, + "Ġsaw": 461, + "est": 462, + "ĠĊ": 463, + "ĠF": 464, + "ind": 465, + "Ġtheir": 466, + "op": 467, + "One": 468, + "ation": 469, + ".\"": 470, + "Ġhim": 471, + "Ġgo": 472, + "ĠP": 473, + "Ġby": 474, + "Ġfrom": 475, + "Ġj": 476, + "Ġar": 477, + "hen": 478, + "Ġ2": 479, + "Ġbo": 480, + "ong": 481, + "ear": 482, + "oug": 483, + "Ġout": 484, + "Ġloo": 485, + "and": 486, + "'t": 487, + "ame": 488, + "Ġhave": 489, + "Ġthem": 490, + "hed": 491, + "ers": 492, + "ĠE": 493, + "ight": 494, + "Once": 495, + "!\"": 496, + "Ġtoo": 497, + "way": 498, + "ĠTim": 499, + "ĠR": 500, + "em": 501, + "Ġcon": 502, + "ure": 503, + "ell": 504, + "Ġcl": 505, + "Ġv": 506, + "irl": 507, + "Ġupon": 508, + "Ġall": 509, + "ist": 510, + "ud": 511, + "Ġwanted": 512, + "ĠG": 513, + "ĠN": 514, + "Ġch": 515, + "Ġdid": 516, + "Ġcould": 517, + "ood": 518, + "ab": 519, + "are": 520, + "os": 521, + "Ġgirl": 522, + "Ġcan": 523, + "qu": 524, + "Ġpar": 525, + "Ġkn": 526, + "Ġ)": 527, + "Ġ(": 528, + "Ġcom": 529, + "Ġsc": 530, + "ess": 531, + "one": 532, + "ther": 533, + "own": 534, + "Ġhel": 535, + "Ġsmil": 536, + "ie": 537, + "unk": 538, + "Ġman": 539, + "Ġ19": 540, + "amed": 541, + "Ġwent": 542, + "ate": 543, + "Ġwor": 544, + "Ġor": 545, + "ts": 546, + "ally": 547, + "Ġno": 548, + "oc": 549, + "ks": 550, + "ap": 551, + "ĠBen": 552, + "ep": 553, + "Ġhelp": 554, + "Ġag": 555, + "Ġstar": 556, + "Ġback": 557, + "ast": 558, + "ade": 559, + "ak": 560, + "ust": 561, + "ies": 562, + "00": 563, + "Ġfriends": 564, + "ice": 565, + "ree": 566, + "Ġwould": 567, + "Ġ<": 568, + "?\"": 569, + "ful": 570, + "Ġnamed": 571, + "ous": 572, + "ive": 573, + "Ġfun": 574, + "ings": 575, + "out": 576, + "You": 577, + "ber": 578, + "Ġsome": 579, + "res": 580, + "Ġtr": 581, + "Ġsay": 582, + "hing": 583, + "Ġme": 584, + "elt": 585, + "Ġwho": 586, + "Ġfe": 587, + "Ġab": 588, + "ant": 589, + "Ġle": 590, + "Ġother": 591, + "ĠOne": 592, + "Ġwe": 593, + "side": 594, + "Ġlike": 595, + "Ġpr": 596, + "ird": 597, + "Ġun": 598, + "ĠTom": 599, + "Ġgr": 600, + "pl": 601, + "low": 602, + "ue": 603, + "ct": 604, + "Ġfelt": 605, + "get": 606, + "ort": 607, + "Ġaround": 608, + "Ġloved": 609, + "ater": 610, + "Ġmo": 611, + "ited": 612, + "Ġbr": 613, + "Ġtoy": 614, + "ich": 615, + "Ġasked": 616, + "ĠTimmy": 617, + "Ġsmiled": 618, + "omet": 619, + "ick": 620, + "Ġone": 621, + "Ġmade": 622, + "uch": 623, + "ia": 624, + "Ġnew": 625, + "Ġbec": 626, + "our": 627, + "fter": 628, + "ang": 629, + "Ġwhen": 630, + "ach": 631, + "Ġlooked": 632, + "ial": 633, + "Ġint": 634, + "Ġpro": 635, + "ish": 636, + "Ġsee": 637, + "av": 638, + "Ġagain": 639, + "Ġcar": 640, + "Ġboy": 641, + "ine": 642, + "ace": 643, + "Ġde": 644, + "ub": 645, + "Ġbird": 646, + "ated": 647, + "Ġdec": 648, + "iv": 649, + "ough": 650, + "Ġwhat": 651, + "Ġsomet": 652, + "Ġmake": 653, + "Ġtw": 654, + "gether": 655, + "ond": 656, + "ned": 657, + "ĠYou": 658, + "Ġaway": 659, + "Ġfound": 660, + "ĠBut": 661, + "Lily": 662, + "ity": 663, + "Ġran": 664, + "ite": 665, + "Ġthen": 666, + "Ġtogether": 667, + "ip": 668, + "ew": 669, + "Ġstarted": 670, + "Ġro": 671, + "ĠIn": 672, + "ĠO": 673, + "ĠK": 674, + ",\"": 675, + "ave": 676, + "ought": 677, + "oud": 678, + "Ġad": 679, + "ary": 680, + "âĤ": 681, + "ass": 682, + "â": 683, + "âĤ¬": 684, + "Ġmore": 685, + "Ġput": 686, + "Ġthan": 687, + "ried": 688, + "Ġpark": 689, + "Ġwant": 690, + "Ġhome": 691, + "king": 692, + "Ġexc": 693, + "Ġsomething": 694, + "Ġsays": 695, + "ared": 696, + "Ġits": 697, + "Ġabout": 698, + "Ġsad": 699, + "Ġthis": 700, + "pped": 701, + "ile": 702, + "aug": 703, + "Ġgood": 704, + "ty": 705, + "Ġbl": 706, + "ment": 707, + "Ġen": 708, + "Ġover": 709, + "iz": 710, + "Ġwhich": 711, + "oun": 712, + "Ġpre": 713, + "ook": 714, + "Ġinto": 715, + "hat": 716, + "ect": 717, + "ided": 718, + "irst": 719, + "Ġdown": 720, + "ff": 721, + "Ġhug": 722, + "Ġco": 723, + "Ġsw": 724, + "Ġget": 725, + "so": 726, + "ax": 727, + "Ġplaying": 728, + "ouse": 729, + "Ġop": 730, + "ian": 731, + "Ġoff": 732, + "ĠU": 733, + "Ġwal": 734, + "ise": 735, + "na": 736, + "ny": 737, + "Ġcont": 738, + "ire": 739, + "Ġcame": 740, + "od": 741, + "Ġevery": 742, + "Ġalso": 743, + "Ġcare": 744, + "age": 745, + "Ġim": 746, + "Ġâ": 747, + "Ġev": 748, + "Ġfirst": 749, + "Ġspec": 750, + "reat": 751, + "ĠSt": 752, + "Ġthings": 753, + "Ġgot": 754, + "Ġtwo": 755, + "ge": 756, + "Ġus": 757, + "au": 758, + "Ġfind": 759, + "ord": 760, + "ĠAn": 761, + "ĠâĢ": 762, + "pt": 763, + "Ġdecided": 764, + "Ġwill": 765, + "ild": 766, + "Ġtook": 767, + "Ġpe": 768, + "Ġdog": 769, + "other": 770, + "Ġliked": 771, + "here": 772, + "Ġmy": 773, + "Ġexcited": 774, + "Ġ3": 775, + "Ġhas": 776, + "ara": 777, + "Ġbet": 778, + "Ġfl": 779, + "Ġyour": 780, + "uck": 781, + "Ġfeel": 782, + "Ġqu": 783, + "nder": 784, + "Ġke": 785, + "ened": 786, + "oth": 787, + "ways": 788, + "Ġac": 789, + "Ġshow": 790, + "igh": 791, + "udd": 792, + "og": 793, + "ob": 794, + "als": 795, + "Ġstr": 796, + "ress": 797, + "Ġinc": 798, + "ely": 799, + "Ġany": 800, + "Ġold": 801, + "Ġball": 802, + "oll": 803, + "Ġhow": 804, + "Ġdad": 805, + "able": 806, + "Ġthought": 807, + "Ġcomp": 808, + "Ġbeen": 809, + "ions": 810, + "ause": 811, + "Ġper": 812, + "Ġscared": 813, + "ged": 814, + "ning": 815, + "mer": 816, + "Ġalways": 817, + "ĠCh": 818, + "ical": 819, + "Ġdis": 820, + "Ġapp": 821, + "Ġte": 822, + "Ġafter": 823, + "Ġam": 824, + "Ġtree": 825, + "ory": 826, + "Ġtoys": 827, + "Ġpo": 828, + "Ġrun": 829, + "ance": 830, + "Ġdidn": 831, + "They": 832, + "Ġlear": 833, + "Ġoutside": 834, + "oy": 835, + "ase": 836, + "Ġtake": 837, + "ĠMom": 838, + "Ġyear": 839, + "orm": 840, + "Ġwr": 841, + "Ġknow": 842, + "Ġlot": 843, + "ark": 844, + "Ġend": 845, + "ft": 846, + "Ġmuch": 847, + "Ġ200": 848, + "Ġrem": 849, + "Ġpic": 850, + "atch": 851, + "Ġcall": 852, + "Ġmany": 853, + "Ġho": 854, + "Ġmommy": 855, + "Ġbu": 856, + "ank": 857, + "ll": 858, + "ĠTh": 859, + "Ġlong": 860, + "Ġcr": 861, + "hn": 862, + "Ġspecial": 863, + "les": 864, + "ĠJo": 865, + "Ġ;": 866, + "ock": 867, + "ĠSam": 868, + "ĠV": 869, + "Ġhand": 870, + "Ġplayed": 871, + "ied": 872, + "ĠMax": 873, + "Ġcol": 874, + "Ġbecause": 875, + "Ġunder": 876, + "Ġres": 877, + "Ġsk": 878, + "ble": 879, + "Ġhouse": 880, + "fe": 881, + "Ġeach": 882, + "Ġif": 883, + "ence": 884, + "ving": 885, + "Ġfin": 886, + "led": 887, + "Ġwater": 888, + "Ġrec": 889, + "Ġlaug": 890, + "Ġsmall": 891, + "Ġimp": 892, + "Ġthr": 893, + "Ġknew": 894, + "Ġexpl": 895, + "til": 896, + "elf": 897, + "ered": 898, + "wn": 899, + "udden": 900, + "hes": 901, + "Ġgave": 902, + "ix": 903, + "ĠWe": 904, + "Ġ20": 905, + "ign": 906, + "ious": 907, + "Ġjust": 908, + "Ġwa": 909, + "fore": 910, + "iss": 911, + "ward": 912, + "Ġsur": 913, + "ane": 914, + "ished": 915, + "Ġuntil": 916, + "ans": 917, + "ump": 918, + "Ġnever": 919, + "orry": 920, + "Ġtold": 921, + "art": 922, + "uddenly": 923, + "ors": 924, + "ens": 925, + "ool": 926, + "Ġsun": 927, + "Ġgra": 928, + "ail": 929, + "Ġ:": 930, + "ting": 931, + "fer": 932, + "gan": 933, + "bed": 934, + "Ġwhile": 935, + "Ġcareful": 936, + "Ġ18": 937, + "But": 938, + "Ġboth": 939, + "ĠâĢĵ": 940, + "Ġdes": 941, + "Ġroom": 942, + "Ġsorry": 943, + "anc": 944, + "act": 945, + "ollow": 946, + "Ġtried": 947, + "pr": 948, + "Ġinside": 949, + "Ġneed": 950, + "ph": 951, + "ĠHer": 952, + "uring": 953, + "vel": 954, + "up": 955, + "iver": 956, + "Ġbefore": 957, + "Ġ4": 958, + "Ġatt": 959, + "Ġlook": 960, + "man": 961, + "Ġeat": 962, + "Ġbest": 963, + "Ġproud": 964, + ".@": 965, + "Ġ@.@": 966, + "az": 967, + "ink": 968, + "Ġheard": 969, + "Ġcouldn": 970, + "Ġ5": 971, + "Ġanim": 972, + "Ġfam": 973, + "Ġsl": 974, + "ised": 975, + "ren": 976, + "Ġbox": 977, + "land": 978, + "Ġonly": 979, + "vent": 980, + "Ġcalled": 981, + "air": 982, + "Ġeven": 983, + "ition": 984, + "dy": 985, + "ss": 986, + "Ġpret": 987, + "ĠAnd": 988, + "ople": 989, + "ĠJack": 990, + "ons": 991, + "by": 992, + "Ġcle": 993, + "ady": 994, + "Ġser": 995, + "ĠEvery": 996, + "ations": 997, + "Ġhugged": 998, + "ĠBr": 999, + "Tom": 1000, + "Ġbeing": 1001, + "ose": 1002, + "ĠSara": 1003, + "Ġwhere": 1004, + "Ġthree": 1005, + "we": 1006, + "lud": 1007, + "Ġbear": 1008, + "Ġfollow": 1009, + "ture": 1010, + "ĠAnna": 1011, + "arm": 1012, + "ath": 1013, + "amp": 1014, + "Ġway": 1015, + "ull": 1016, + "Ġtry": 1017, + "Ġgame": 1018, + "Ġcat": 1019, + "ched": 1020, + "Ġtur": 1021, + "Ġred": 1022, + "Ġstill": 1023, + "Ġbetter": 1024, + "Mom": 1025, + "Ġlet": 1026, + "ased": 1027, + "Ġthrough": 1028, + "ĠSo": 1029, + "Ġhur": 1030, + "aking": 1031, + "Ġpeople": 1032, + "ĠHis": 1033, + "self": 1034, + "ember": 1035, + "Ġlearned": 1036, + "xt": 1037, + "Ġpart": 1038, + ",@": 1039, + "Ġ@,@": 1040, + "Ġnice": 1041, + "Ġlist": 1042, + "'m": 1043, + "Ġsn": 1044, + "Ġhigh": 1045, + "Ġfr": 1046, + "Ġsong": 1047, + "Ġflow": 1048, + "gry": 1049, + "Ġ201": 1050, + "Ġkind": 1051, + "aut": 1052, + "Ġclos": 1053, + "Ġche": 1054, + "upp": 1055, + "Ġear": 1056, + "Ġdon": 1057, + "be": 1058, + "Ġbecame": 1059, + "ount": 1060, + "Ġinclud": 1061, + "Ġdif": 1062, + "Ġsec": 1063, + "Ġrel": 1064, + "Th": 1065, + "Ġfamily": 1066, + "ized": 1067, + "Ġsky": 1068, + "Ġwork": 1069, + "Ġfle": 1070, + "Ġlove": 1071, + "ĠSp": 1072, + "Ġinter": 1073, + "cess": 1074, + "Ġnow": 1075, + "Ġused": 1076, + "iny": 1077, + "Ġmost": 1078, + "Yes": 1079, + "ng": 1080, + "Ġdra": 1081, + "Ġcome": 1082, + "Ġbeaut": 1083, + "Ġnear": 1084, + "orn": 1085, + "Ġjump": 1086, + "ents": 1087, + "Ġshould": 1088, + "Ġgl": 1089, + "ĠWhen": 1090, + "Ġhard": 1091, + "ates": 1092, + "arden": 1093, + "ded": 1094, + "Ġfore": 1095, + "Ġlived": 1096, + "He": 1097, + "per": 1098, + "Ġthanked": 1099, + "ĠAs": 1100, + "ĠFrom": 1101, + "ĠJohn": 1102, + "ĠMia": 1103, + "Ġsing": 1104, + "Ġwind": 1105, + "iful": 1106, + "ired": 1107, + "ever": 1108, + "Ġgarden": 1109, + "Ġlaughed": 1110, + "Ġanimals": 1111, + "ves": 1112, + "aw": 1113, + "ric": 1114, + "ames": 1115, + "ream": 1116, + "Ġuse": 1117, + "ange": 1118, + "It": 1119, + "Ġbeautiful": 1120, + "Ġbra": 1121, + "Ġloud": 1122, + "ather": 1123, + "ĠUn": 1124, + "Ġyears": 1125, + "Ġreal": 1126, + "Ġset": 1127, + "Ġperf": 1128, + "Ġ6": 1129, + "Ġstay": 1130, + "outh": 1131, + "Ġdoll": 1132, + "ĠAl": 1133, + "Ġmus": 1134, + "ma": 1135, + "Ġmon": 1136, + "ins": 1137, + "Ġlots": 1138, + "Ġact": 1139, + "Ġcomm": 1140, + "Ġground": 1141, + "Ġnod": 1142, + "Ġhead": 1143, + "Ġnext": 1144, + "duc": 1145, + "Ġown": 1146, + "Åĵ": 1147, + "red": 1148, + "Ġbad": 1149, + "ilm": 1150, + "Ġfly": 1151, + "Ġbel": 1152, + "Ġcent": 1153, + "rew": 1154, + "iel": 1155, + "Ġide": 1156, + "Ġrep": 1157, + "oin": 1158, + "Ġsoon": 1159, + "akes": 1160, + "Ġgreat": 1161, + "Ġsafe": 1162, + "ucy": 1163, + "ĠThis": 1164, + "Ġbegan": 1165, + "Ġ7": 1166, + "ĠThen": 1167, + "When": 1168, + "Ġrepl": 1169, + "Tim": 1170, + "Ġsuch": 1171, + "Ġopened": 1172, + "ope": 1173, + "Ġbro": 1174, + "Ġgoing": 1175, + "Ġclean": 1176, + "Ġlater": 1177, + "Ġdiffer": 1178, + "bit": 1179, + "ular": 1180, + "Ġflew": 1181, + "ained": 1182, + "ult": 1183, + "Ġshare": 1184, + "ason": 1185, + "Ġtre": 1186, + "Ġey": 1187, + "kay": 1188, + "ued": 1189, + "Ġwalked": 1190, + "Ġâ": 1191, + "Ġplace": 1192, + "Ġkeep": 1193, + "Ġfo": 1194, + "me": 1195, + "Ġnum": 1196, + "Ġret": 1197, + "imes": 1198, + "Ġdel": 1199, + "Ġbrave": 1200, + "Ġsurpr": 1201, + "Ġright": 1202, + "Ġstrong": 1203, + "illy": 1204, + "Ġele": 1205, + "Ġkept": 1206, + "tion": 1207, + "Ġhurt": 1208, + "ton": 1209, + "ey": 1210, + "Ġ9": 1211, + "Ġcons": 1212, + "Ġchild": 1213, + "der": 1214, + "uff": 1215, + "Ġduring": 1216, + "Ġangry": 1217, + "Ġcontin": 1218, + "Ġ8": 1219, + "ubl": 1220, + "ĠMar": 1221, + "ĠY": 1222, + "Ġsto": 1223, + "ib": 1224, + "Let": 1225, + "ween": 1226, + "Ġfast": 1227, + "Ġacc": 1228, + "Ġmet": 1229, + "Ġimport": 1230, + "Ġfilm": 1231, + "In": 1232, + "oup": 1233, + "Ġidea": 1234, + "Ġsound": 1235, + "lease": 1236, + "thing": 1237, + "Ġadvent": 1238, + "Ġclim": 1239, + "tern": 1240, + "ross": 1241, + "Ġpretty": 1242, + "Ġstory": 1243, + "ached": 1244, + "ummy": 1245, + "Ġnoise": 1246, + "ĠCan": 1247, + "Ġshiny": 1248, + "ven": 1249, + "Ben": 1250, + "Ġmag": 1251, + "Ġchar": 1252, + "Ġdifferent": 1253, + "orth": 1254, + "oon": 1255, + "str": 1256, + "Ġcry": 1257, + "ield": 1258, + "Ġlar": 1259, + "ters": 1260, + "Ġbetween": 1261, + "ier": 1262, + "Ġrecord": 1263, + "Ġdoor": 1264, + "ash": 1265, + "ision": 1266, + "ee": 1267, + "hip": 1268, + "Ġexplore": 1269, + "Ġworld": 1270, + "cc": 1271, + "Ġrest": 1272, + "Ġfeeling": 1273, + "Ġever": 1274, + "Ġname": 1275, + "uri": 1276, + "att": 1277, + "ĠAr": 1278, + "iew": 1279, + "Ġmar": 1280, + "uit": 1281, + "Ġbook": 1282, + "Ġbuild": 1283, + "ational": 1284, + "Ġprom": 1285, + "Ġbed": 1286, + "Ġimportant": 1287, + "Ġgive": 1288, + "Ġfood": 1289, + "Ġpicked": 1290, + "Ġpos": 1291, + "ĠLucy": 1292, + "br": 1293, + "ener": 1294, + "Ġreg": 1295, + "ient": 1296, + "âĤ¬â": 1297, + "Ġfar": 1298, + "Ġtal": 1299, + "Ġbre": 1300, + "Ġem": 1301, + "Ġpicture": 1302, + "ocks": 1303, + "Ġnodded": 1304, + "What": 1305, + "Ġair": 1306, + "ner": 1307, + "Ġplan": 1308, + "Ġdr": 1309, + "oice": 1310, + "ĠAfter": 1311, + "Ġanother": 1312, + "Ġquick": 1313, + "joy": 1314, + "Ġloc": 1315, + "iced": 1316, + "iet": 1317, + "Ġopen": 1318, + "ident": 1319, + "ĠBob": 1320, + "ont": 1321, + "ual": 1322, + "Ġpres": 1323, + "enc": 1324, + "Ġpoin": 1325, + "Ġblue": 1326, + "Ġind": 1327, + "ĠMay": 1328, + "No": 1329, + "Ġent": 1330, + "Ġ00": 1331, + "ually": 1332, + "Ġhands": 1333, + "ove": 1334, + "Ġmor": 1335, + "iting": 1336, + "reen": 1337, + "That": 1338, + "Ġforest": 1339, + "ale": 1340, + "ĠNew": 1341, + "Ġwell": 1342, + "ury": 1343, + "ures": 1344, + "ating": 1345, + "Ġ199": 1346, + "Ġstopped": 1347, + "Ġrain": 1348, + "Ġdoes": 1349, + "Ġtri": 1350, + "Ġform": 1351, + "Ġwat": 1352, + "Ġmin": 1353, + "Ġfire": 1354, + "Ġsupp": 1355, + "Ġwalking": 1356, + "Ġrock": 1357, + "olog": 1358, + "wards": 1359, + "Ġpol": 1360, + "Ġappear": 1361, + "Ġenjoy": 1362, + "Ġfour": 1363, + "Ġlooking": 1364, + "Ġeyes": 1365, + "Ġwatch": 1366, + "ret": 1367, + "Ġsqu": 1368, + "Ġsub": 1369, + "Ġpain": 1370, + "Ġbeh": 1371, + "ster": 1372, + "Ħ¢": 1373, + "âĤ¬âĦ¢": 1374, + "ower": 1375, + "Ġseason": 1376, + "Ġexp": 1377, + "Ġmusic": 1378, + "Ġhaving": 1379, + "Ġboat": 1380, + "Ġshowed": 1381, + "Ġnight": 1382, + "Ġleft": 1383, + "Ġfav": 1384, + "meric": 1385, + "Ġremember": 1386, + "Ġbus": 1387, + "Ġlisten": 1388, + "Ġsecond": 1389, + "Ġtop": 1390, + "ost": 1391, + "Ġsmile": 1392, + "Ġfish": 1393, + "Ġ/": 1394, + "ĠAmeric": 1395, + "cri": 1396, + "Thank": 1397, + "ĠCom": 1398, + "ral": 1399, + "Ġproduc": 1400, + "ince": 1401, + "Ġwond": 1402, + "hy": 1403, + "Ġtruck": 1404, + "Ġsy": 1405, + "let": 1406, + "Ġour": 1407, + "Ġgrab": 1408, + "illed": 1409, + "aren": 1410, + "Ġreached": 1411, + "Ġquickly": 1412, + "Ġless": 1413, + "ĠAt": 1414, + "Ġslide": 1415, + "Ġyell": 1416, + "Ġvoice": 1417, + "ĠSuddenly": 1418, + "ike": 1419, + "Ġz": 1420, + "Ġamaz": 1421, + "Ġmean": 1422, + "Ġface": 1423, + "ote": 1424, + "Ġdisc": 1425, + "Ġland": 1426, + "Ġinv": 1427, + "She": 1428, + "Ġsame": 1429, + "Ġnoticed": 1430, + "ĠLe": 1431, + "eter": 1432, + "Ġtell": 1433, + "io": 1434, + "Ġvis": 1435, + "Ġass": 1436, + "Ġflowers": 1437, + "vers": 1438, + "ns": 1439, + "Ġdist": 1440, + "Ġdraw": 1441, + "Ġ000": 1442, + "Ġfell": 1443, + "Ġswe": 1444, + "itc": 1445, + "Ġpop": 1446, + "Ġdep": 1447, + "Ġnumber": 1448, + "Ġreplied": 1449, + "ĠDad": 1450, + "Suddenly": 1451, + "day": 1452, + "After": 1453, + "Ġmove": 1454, + "ific": 1455, + "Ġtra": 1456, + "ĠSue": 1457, + "Ġseen": 1458, + "Ġstore": 1459, + "Ġalong": 1460, + "Ġpass": 1461, + "Ġmaking": 1462, + "An": 1463, + "gr": 1464, + "abbit": 1465, + "Ġfur": 1466, + "ute": 1467, + "ined": 1468, + "Ġep": 1469, + "Ġdress": 1470, + "ics": 1471, + "ĠOn": 1472, + "Ġbrother": 1473, + "urious": 1474, + "Ġbit": 1475, + "Ġdro": 1476, + "Ġmay": 1477, + "Ġhimself": 1478, + "Ġeveryone": 1479, + "Ġwatched": 1480, + "Ġob": 1481, + "ms": 1482, + "Ġrabbit": 1483, + "bum": 1484, + "Ġwin": 1485, + "ĠRe": 1486, + "Ġlight": 1487, + "Ġheld": 1488, + "Ġokay": 1489, + "chool": 1490, + "ible": 1491, + "bye": 1492, + "Ġpubl": 1493, + "Ġsuc": 1494, + "Ġste": 1495, + "Ġresp": 1496, + "more": 1497, + "olly": 1498, + "Ġwalk": 1499, + "Ġcloser": 1500, + "Ġlost": 1501, + "ugg": 1502, + "ĠDe": 1503, + "Ġhelped": 1504, + "any": 1505, + "igin": 1506, + "ets": 1507, + "aper": 1508, + "Ġwarm": 1509, + "Ġcap": 1510, + "Ġread": 1511, + "Ġ10": 1512, + "used": 1513, + "We": 1514, + "Ġdri": 1515, + "Ġgiv": 1516, + "ids": 1517, + "Ġhear": 1518, + "Ġagainst": 1519, + "Ġteam": 1520, + "Ġmil": 1521, + "Ġcontinued": 1522, + "Ġ0": 1523, + "Ġsure": 1524, + "Ġretur": 1525, + "ĠAll": 1526, + "Ġbirds": 1527, + "leep": 1528, + "ored": 1529, + "Ġinf": 1530, + "app": 1531, + "kes": 1532, + "Ġstud": 1533, + "Ġfull": 1534, + "Ġlead": 1535, + "Look": 1536, + "Ġflo": 1537, + "Ġgrand": 1538, + "ert": 1539, + "So": 1540, + "Ġforg": 1541, + "Ġalbum": 1542, + "Ġepis": 1543, + "Her": 1544, + "sh": 1545, + "iam": 1546, + "ork": 1547, + "Ġhere": 1548, + "ines": 1549, + "Ġperform": 1550, + "ott": 1551, + "Ġgoodbye": 1552, + "Ġepisod": 1553, + "Ġbar": 1554, + "ger": 1555, + "ities": 1556, + "Ġcurious": 1557, + "Ġarri": 1558, + "aught": 1559, + "Ġwait": 1560, + "Ġcook": 1561, + "ila": 1562, + "Ġstop": 1563, + "mber": 1564, + "ĠHow": 1565, + "Ġpers": 1566, + "ĠJane": 1567, + "reed": 1568, + "leased": 1569, + "Ġwon": 1570, + "ĠThere": 1571, + "Ġbright": 1572, + "Ġanymore": 1573, + "Ġknown": 1574, + "Ġhold": 1575, + "Ġel": 1576, + "Ġfew": 1577, + "aves": 1578, + "ps": 1579, + "Ġsever": 1580, + "Ġdire": 1581, + "Ġmess": 1582, + "Ġseries": 1583, + "over": 1584, + "isy": 1585, + "ling": 1586, + "Ġhun": 1587, + "Ġchildren": 1588, + "Ġfavor": 1589, + "As": 1590, + "Ġwar": 1591, + "Ġrece": 1592, + "Ġcake": 1593, + "Ġbehind": 1594, + "Ġsign": 1595, + "Ġthese": 1596, + "Ġsees": 1597, + "Ġdone": 1598, + "ĠEng": 1599, + "Ġcharac": 1600, + "Ġorigin": 1601, + "Ġbelie": 1602, + "Can": 1603, + "row": 1604, + "Ġreally": 1605, + "Ġext": 1606, + "Ġsand": 1607, + "Sara": 1608, + "Ġsho": 1609, + "Ġgrass": 1610, + "Ġunderst": 1611, + "ĠSh": 1612, + "Ġbutter": 1613, + "Ġjoin": 1614, + "itchen": 1615, + "Ġhappened": 1616, + "Anna": 1617, + "Ġshou": 1618, + "Ġgu": 1619, + "Ġkitchen": 1620, + "Ġparen": 1621, + "ĠSpot": 1622, + "Ġter": 1623, + "ĠMommy": 1624, + "Ġcast": 1625, + "ains": 1626, + "ĠFl": 1627, + "rog": 1628, + "ĠThat": 1629, + "Ġprin": 1630, + "Ġfollowed": 1631, + "Ġ12": 1632, + "Ġcontr": 1633, + "Ġworked": 1634, + "Ġ16": 1635, + "ments": 1636, + "Ġincluding": 1637, + "uary": 1638, + "ĠWh": 1639, + "Ġsoft": 1640, + "atter": 1641, + "aster": 1642, + "Ġsweet": 1643, + "Ġtrans": 1644, + "Jo": 1645, + "oney": 1646, + "Ġstick": 1647, + "ction": 1648, + "where": 1649, + "ister": 1650, + "Ġ198": 1651, + "Ġlearn": 1652, + "Ġgener": 1653, + "Ġship": 1654, + "aj": 1655, + "Ġmill": 1656, + "rand": 1657, + "Ġjumped": 1658, + "avy": 1659, + "oke": 1660, + "ict": 1661, + "velop": 1662, + "aces": 1663, + "Ġwood": 1664, + "Ġconf": 1665, + "Ġpick": 1666, + "Ġrunning": 1667, + "aced": 1668, + "its": 1669, + "Ġearly": 1670, + "Ġtouch": 1671, + "Ġadventure": 1672, + "Ġinst": 1673, + "Ġside": 1674, + "ially": 1675, + "ĠEm": 1676, + "Ġpur": 1677, + "Ġ17": 1678, + "Ġgrabbed": 1679, + "though": 1680, + "ĠZ": 1681, + "Ġleg": 1682, + "son": 1683, + "ĠLet": 1684, + "ĠDo": 1685, + "unny": 1686, + "bo": 1687, + "Ġwhite": 1688, + "Ġslow": 1689, + "Ġcoming": 1690, + "Ġglad": 1691, + "ived": 1692, + "Ġschool": 1693, + "oman": 1694, + "Ġcatch": 1695, + "Ġpus": 1696, + "Ġable": 1697, + "ĠBrit": 1698, + "ĠUnited": 1699, + "Ġmain": 1700, + "ama": 1701, + "Ġhair": 1702, + "Ġrealized": 1703, + "une": 1704, + "Ġclose": 1705, + "Ġready": 1706, + "Ġfinished": 1707, + "anger": 1708, + "Ġfavorite": 1709, + "Ġthing": 1710, + "ended": 1711, + "ured": 1712, + "ley": 1713, + "Ġhop": 1714, + "Ġpaper": 1715, + "'re": 1716, + "ement": 1717, + "ball": 1718, + "Ġ15": 1719, + "ative": 1720, + "ek": 1721, + "Ġtow": 1722, + "ober": 1723, + "Ġref": 1724, + "Ġlarge": 1725, + "Ġbow": 1726, + "Ġdin": 1727, + "Ġhat": 1728, + "Ġshouted": 1729, + "ctor": 1730, + "Ġsuccess": 1731, + "Ġdescri": 1732, + "ced": 1733, + "ots": 1734, + "Ġcentury": 1735, + "Ġfix": 1736, + "Ġlife": 1737, + "Ġcre": 1738, + "Ġsat": 1739, + "Ġart": 1740, + "Ġyellow": 1741, + "Ġest": 1742, + "Ġdark": 1743, + "ooks": 1744, + "zy": 1745, + "Ġmother": 1746, + "Ġlate": 1747, + "Ġate": 1748, + "Ġothers": 1749, + "Ġseveral": 1750, + "ected": 1751, + "Ġgreen": 1752, + "ĠSc": 1753, + "Ġblocks": 1754, + "Ġlady": 1755, + "Ġparents": 1756, + "ĠJen": 1757, + "ask": 1758, + "ĠâĢĶ": 1759, + "ĠEveryone": 1760, + "erv": 1761, + "Ġmiss": 1762, + "Ġyummy": 1763, + "Ġgames": 1764, + "Ġconc": 1765, + "ories": 1766, + "Ġfunny": 1767, + "Ġword": 1768, + "Ġwonder": 1769, + "Ġtrees": 1770, + "Ġepisode": 1771, + "Ġtired": 1772, + "Ġ11": 1773, + "Ġcool": 1774, + "Ġwhy": 1775, + "Ġph": 1776, + "ries": 1777, + "Ġadd": 1778, + "ken": 1779, + "Ġcount": 1780, + "Wow": 1781, + "Ġthin": 1782, + "Ġdevelop": 1783, + "fly": 1784, + "Ġfield": 1785, + "Ġneeded": 1786, + "Ġworry": 1787, + "ature": 1788, + "ĠInd": 1789, + "Ġcour": 1790, + "Ġgroup": 1791, + "Ġcity": 1792, + "Ġpat": 1793, + "Ġstand": 1794, + "Ġlooks": 1795, + "Ġwear": 1796, + "Ġpond": 1797, + "Ġmight": 1798, + "Ġthink": 1799, + "Ġflower": 1800, + "Ġ194": 1801, + "ony": 1802, + "Ġtown": 1803, + "Ġtall": 1804, + "Ġgrow": 1805, + "ĠSarah": 1806, + "Ġ-": 1807, + "aby": 1808, + "ĠBl": 1809, + "Ġcolor": 1810, + "Ġarrived": 1811, + "Ġdef": 1812, + "ĠChr": 1813, + "Ġoper": 1814, + "Ġcrit": 1815, + "Ġkids": 1816, + "Ġwindow": 1817, + "Ġwithout": 1818, + "bers": 1819, + "ness": 1820, + "Ġwaved": 1821, + "els": 1822, + "Ġcla": 1823, + "Ġcried": 1824, + "struc": 1825, + "view": 1826, + "ĠAmerican": 1827, + "less": 1828, + "Ġdoing": 1829, + "Ġcold": 1830, + "Ġclimb": 1831, + "Ġpower": 1832, + "Ġed": 1833, + "Ġmum": 1834, + "ept": 1835, + "idge": 1836, + "Ġins": 1837, + "Mommy": 1838, + "Don": 1839, + "ject": 1840, + "ently": 1841, + "Ġfloor": 1842, + "Ġcreat": 1843, + "Ġfight": 1844, + "Ġhill": 1845, + "key": 1846, + "Ġfall": 1847, + "aisy": 1848, + "Ġ196": 1849, + "ĠCl": 1850, + "Ġsit": 1851, + "Ġbunny": 1852, + "emp": 1853, + "Ġbrought": 1854, + "Ġlaugh": 1855, + "ivers": 1856, + "Ġsim": 1857, + "Ġmed": 1858, + "Ġherself": 1859, + "ĠIs": 1860, + "Ġprot": 1861, + "Ġreleased": 1862, + "Ġswing": 1863, + "Ġmoved": 1864, + "Ġprov": 1865, + "Ġcars": 1866, + "Ġeff": 1867, + "rop": 1868, + "Ġsurprise": 1869, + "Ġyard": 1870, + "ĠFr": 1871, + "andy": 1872, + "Ġhole": 1873, + "Timmy": 1874, + "idd": 1875, + "Ġwall": 1876, + "Ġwished": 1877, + "Ġswim": 1878, + "Ġcut": 1879, + "Ġevent": 1880, + "mb": 1881, + "Ġenjoyed": 1882, + "Ġbag": 1883, + "ĠCar": 1884, + "Ġdelic": 1885, + "Ġenough": 1886, + "Ġorgan": 1887, + "Ġ197": 1888, + "asure": 1889, + "ĠGer": 1890, + "Ġsleep": 1891, + "Ġthough": 1892, + "Ġclass": 1893, + "ead": 1894, + "yp": 1895, + "Ġhist": 1896, + "room": 1897, + "Ġhot": 1898, + "oring": 1899, + "ilt": 1900, + "ĠWar": 1901, + "Ġbuy": 1902, + "Ġremembered": 1903, + "Ġfrog": 1904, + "Ġmouse": 1905, + "Ġice": 1906, + "Ġtowards": 1907, + "Ġocc": 1908, + "Ġbooks": 1909, + "Ġspot": 1910, + "ium": 1911, + "old": 1912, + "Ġcra": 1913, + "uth": 1914, + "Ġblack": 1915, + "rel": 1916, + "Ġagreed": 1917, + "Ġes": 1918, + "Ġhappily": 1919, + "Ġband": 1920, + "ello": 1921, + "itten": 1922, + "Ġfair": 1923, + "Ġanything": 1924, + "Ġstorm": 1925, + "ape": 1926, + "Ġoffic": 1927, + "alth": 1928, + "Ġturned": 1929, + "John": 1930, + "ately": 1931, + "Ġline": 1932, + "Ġacross": 1933, + "ten": 1934, + "Ġkm": 1935, + "Ġarea": 1936, + "Ġsnow": 1937, + "Ġunderstand": 1938, + "und": 1939, + "Ġcarefully": 1940, + "ues": 1941, + "ĠPar": 1942, + "Ġhopped": 1943, + "Ġsometimes": 1944, + "Ġtail": 1945, + "Ġwrong": 1946, + "ĠJoe": 1947, + "aur": 1948, + "Ġsix": 1949, + "eddy": 1950, + "Ġmakes": 1951, + "Ġwrote": 1952, + "ĠWor": 1953, + "but": 1954, + "ina": 1955, + "Ġyoung": 1956, + "Ġgun": 1957, + "Ġhig": 1958, + "orted": 1959, + "ĠTr": 1960, + "ides": 1961, + "cted": 1962, + "ney": 1963, + "Ġlesson": 1964, + "Ġtable": 1965, + "Ġcolle": 1966, + "urch": 1967, + "Hello": 1968, + "Ġfive": 1969, + "icy": 1970, + "irt": 1971, + "Ġperson": 1972, + "Ġfollowing": 1973, + "ists": 1974, + "ĠBritish": 1975, + "Sam": 1976, + "Ġlast": 1977, + "Ġhum": 1978, + "Ġcoun": 1979, + "Ġbutterfly": 1980, + "Ġfree": 1981, + "lo": 1982, + "Ġmix": 1983, + "At": 1984, + "inally": 1985, + "igned": 1986, + "ĠAust": 1987, + "Ġfriendly": 1988, + "ajor": 1989, + "Ġmillion": 1990, + "stem": 1991, + "Ġdays": 1992, + "Ġlikes": 1993, + "ĠBenny": 1994, + "ck": 1995, + "cle": 1996, + "Ġ13": 1997, + "Ġ195": 1998, + "Ġbroken": 1999, + "Ġow": 2000, + "ize": 2001, + "med": 2002, + "ects": 2003, + "thern": 2004, + "Ġfinally": 2005, + "orts": 2006, + "Ġtrain": 2007, + "Ġmorning": 2008, + "\".": 2009, + "Ġpresent": 2010, + "Ġcond": 2011, + "Ġcharacter": 2012, + "ĠBe": 2013, + "Ġdeep": 2014, + "Ġsurprised": 2015, + "Ġve": 2016, + "Ġmem": 2017, + "Ġnorth": 2018, + "Ġleaves": 2019, + "Ġfilled": 2020, + "ĠNow": 2021, + "uz": 2022, + "Ġgone": 2023, + "ital": 2024, + "ĠAug": 2025, + "Ġallow": 2026, + "ipp": 2027, + "Ġelse": 2028, + "gy": 2029, + "Ġcolors": 2030, + "ĠAugust": 2031, + "ĠSally": 2032, + "ages": 2033, + "Ġroad": 2034, + "From": 2035, + "Ġgover": 2036, + "Ġtight": 2037, + "Ġsomeone": 2038, + "Ġstate": 2039, + "ex": 2040, + "Ġsear": 2041, + "ĠHowever": 2042, + "Ġbug": 2043, + "Ġplease": 2044, + "Ġseem": 2045, + "Ġtreat": 2046, + "Ġpupp": 2047, + "ĠGrand": 2048, + "ĠAd": 2049, + "Ġbreak": 2050, + "ĠMc": 2051, + "ĠCol": 2052, + "osed": 2053, + "acks": 2054, + "Ġ191": 2055, + "Ġeas": 2056, + "cept": 2057, + "hel": 2058, + "Ġwonderful": 2059, + "Ġann": 2060, + "Ġadv": 2061, + "Ġwants": 2062, + "Ġperfect": 2063, + "Ġconsid": 2064, + "Ġdanc": 2065, + "Ġdesign": 2066, + "uffy": 2067, + "ĠDaisy": 2068, + "ĠSept": 2069, + "ises": 2070, + "Ġheavy": 2071, + "..": 2072, + "que": 2073, + "ray": 2074, + "vious": 2075, + "reet": 2076, + "Ġsail": 2077, + "Ġthank": 2078, + "Ġgetting": 2079, + "oom": 2080, + "Ġask": 2081, + "Ġmoment": 2082, + "Ġcover": 2083, + "iter": 2084, + "ĠUS": 2085, + "ism": 2086, + "Ġcamp": 2087, + "Ġfoot": 2088, + "ats": 2089, + "Ġant": 2090, + "ĠJu": 2091, + "Ġdelicious": 2092, + "ural": 2093, + "Ġsince": 2094, + "Ġpartic": 2095, + "port": 2096, + "Ġvar": 2097, + "ĠSeptember": 2098, + "ife": 2099, + "Ġtrying": 2100, + "Ġcastle": 2101, + "gin": 2102, + "Ġvisit": 2103, + "Ġreceived": 2104, + "Ġspl": 2105, + "Ġ193": 2106, + "Ġlion": 2107, + "Ġ$": 2108, + "Ġleave": 2109, + "Ġparty": 2110, + "Ġdam": 2111, + "ese": 2112, + "Ġincre": 2113, + "to": 2114, + "arr": 2115, + "Ġrace": 2116, + "Ġliving": 2117, + "Ġstart": 2118, + "Ġalone": 2119, + "Ġoften": 2120, + "Ġroll": 2121, + "ĠPl": 2122, + "Ġdream": 2123, + "This": 2124, + "ces": 2125, + "Ġriver": 2126, + "Ġjob": 2127, + "Ġdinner": 2128, + "ĠGerman": 2129, + "é": 2130, + "Ġ14": 2131, + "Ġspe": 2132, + "Ġgovern": 2133, + "ours": 2134, + "ĠWhat": 2135, + "Ġclot": 2136, + "Ġca": 2137, + "Ġbuilt": 2138, + "iec": 2139, + "te": 2140, + "ĠChrist": 2141, + "ĠStates": 2142, + "ales": 2143, + "Jack": 2144, + "Then": 2145, + "Ġfeat": 2146, + "iding": 2147, + "Ġpictures": 2148, + "Ġthose": 2149, + "Ġteac": 2150, + "ĠQ": 2151, + "ants": 2152, + "ĠJan": 2153, + "ording": 2154, + "Ġwet": 2155, + "Ġsongs": 2156, + "Ġoriginal": 2157, + "la": 2158, + "Ġshort": 2159, + "Ġ%": 2160, + "Ġmust": 2161, + "ĠLila": 2162, + "Ġpri": 2163, + "Ġruns": 2164, + "ung": 2165, + "aged": 2166, + "ĠWorld": 2167, + "Ġmoney": 2168, + "ĠBilly": 2169, + "'ll": 2170, + "ron": 2171, + "alf": 2172, + "Ġeverything": 2173, + "Ġgrandma": 2174, + "ĠNorth": 2175, + "Ġyes": 2176, + "Ġscary": 2177, + "ĠCon": 2178, + "ĠJune": 2179, + "sw": 2180, + "Ġdest": 2181, + "ested": 2182, + "Ġsmell": 2183, + "Ġtalk": 2184, + "Ġamazing": 2185, + "Ġsouth": 2186, + "Ġpuppy": 2187, + "Ġmajor": 2188, + "ility": 2189, + "Ġbuilding": 2190, + "unch": 2191, + "Ġpot": 2192, + "anch": 2193, + "Ġpink": 2194, + "Ġfox": 2195, + "Ġstars": 2196, + "ĠComm": 2197, + "ĠKing": 2198, + "ience": 2199, + "pril": 2200, + "eth": 2201, + "Ġflying": 2202, + "Ġstayed": 2203, + "ĠFor": 2204, + "Ġbeach": 2205, + "ĠApril": 2206, + "Ġsystem": 2207, + "ĠPr": 2208, + "Ġsingle": 2209, + "Ġposs": 2210, + "Ġsister": 2211, + "Ġappro": 2212, + "yl": 2213, + "Ġsold": 2214, + "Ġfinal": 2215, + "Ġturn": 2216, + "Ġpet": 2217, + "ĠTo": 2218, + "Ġtast": 2219, + "Ġpublic": 2220, + "Ġcookies": 2221, + "ze": 2222, + "ery": 2223, + "Ġdanger": 2224, + "Ġpul": 2225, + "ivision": 2226, + "aid": 2227, + "isted": 2228, + "ech": 2229, + "ieces": 2230, + "Ġclimbed": 2231, + "ple": 2232, + "Ġhungry": 2233, + "Ġcloud": 2234, + "Ġclothes": 2235, + "Ġmen": 2236, + "Ġbecome": 2237, + "Ġwasn": 2238, + "His": 2239, + "ene": 2240, + "ucky": 2241, + "Ġnec": 2242, + "ĠJim": 2243, + "ĠGe": 2244, + "Ġpretend": 2245, + "ideo": 2246, + "Ġbaby": 2247, + "Ġride": 2248, + "Ġsugg": 2249, + "Ġled": 2250, + "ague": 2251, + "Ġav": 2252, + "ne": 2253, + "eng": 2254, + "ham": 2255, + "ĠSouth": 2256, + "Ġadm": 2257, + "Ġdescribed": 2258, + "Ġpie": 2259, + "Ġforgot": 2260, + "icks": 2261, + "ĠII": 2262, + "Ġround": 2263, + "ĠAustral": 2264, + "Ġtit": 2265, + "igg": 2266, + "ively": 2267, + "ĠOct": 2268, + "Ġlistened": 2269, + "ush": 2270, + "ĠMaybe": 2271, + "Ġcur": 2272, + "Ġview": 2273, + "ĠNo": 2274, + "Ġinstead": 2275, + "Ġincluded": 2276, + "Ġ]": 2277, + "Ġpieces": 2278, + "ĠEur": 2279, + "lish": 2280, + "uss": 2281, + "Ġcomple": 2282, + "lev": 2283, + "Ġsmiles": 2284, + "bs": 2285, + "Ġbatt": 2286, + "Ġcir": 2287, + "ically": 2288, + "Ġasks": 2289, + "ination": 2290, + "Ġvill": 2291, + "ĠGr": 2292, + "ĠOctober": 2293, + "Ġ[": 2294, + "Ġfeet": 2295, + "Ġvers": 2296, + "Ġwhe": 2297, + "ified": 2298, + "May": 2299, + "Ġrequ": 2300, + "Ġbur": 2301, + "Ġdue": 2302, + "Ġjour": 2303, + "board": 2304, + "Ġshar": 2305, + "Ġmoral": 2306, + "Ġsupport": 2307, + "ipped": 2308, + "Ġdisapp": 2309, + "Ġport": 2310, + "Ġdance": 2311, + "Ġreach": 2312, + "Ġarm": 2313, + "Ġeng": 2314, + "ians": 2315, + "Ġstrange": 2316, + "Ġdaddy": 2317, + "ah": 2318, + "aken": 2319, + "Ġwaited": 2320, + "ĠJuly": 2321, + "ĠMr": 2322, + "ift": 2323, + "ison": 2324, + "ator": 2325, + "Ġpast": 2326, + "Ġmark": 2327, + "Ġclosed": 2328, + "ĠFe": 2329, + "uper": 2330, + "Ġlake": 2331, + "Ġpulled": 2332, + "Ġmouth": 2333, + "Ġval": 2334, + "ution": 2335, + "irrel": 2336, + "Ġbased": 2337, + "gon": 2338, + "iant": 2339, + "acked": 2340, + "Ġdeath": 2341, + "Ġ...": 2342, + "elc": 2343, + "ensive": 2344, + "Ġhide": 2345, + "Ġcream": 2346, + "Ġwords": 2347, + "Ġsilly": 2348, + "iod": 2349, + "Ġinterest": 2350, + "ĠWill": 2351, + "Ġcourse": 2352, + "ĠWith": 2353, + "ology": 2354, + "set": 2355, + "Ġbott": 2356, + "Ġhit": 2357, + "ense": 2358, + "Ġteddy": 2359, + "Ġce": 2360, + "ountain": 2361, + "Ġmeet": 2362, + "Ġpromised": 2363, + "Ġansw": 2364, + "Ġshared": 2365, + "Ġreturned": 2366, + "tain": 2367, + "ĠYork": 2368, + "ĠMary": 2369, + "Ġsquirrel": 2370, + "Ġcompet": 2371, + "Ġtaking": 2372, + "osp": 2373, + "Ġwoods": 2374, + "ager": 2375, + "augh": 2376, + "Ġamazed": 2377, + "Ġ25": 2378, + "ĠJanuary": 2379, + "Ġmatch": 2380, + "Ġsea": 2381, + "Maybe": 2382, + "ilar": 2383, + "Ġclub": 2384, + "Ġfront": 2385, + "Ġowner": 2386, + "Ġtower": 2387, + "ying": 2388, + "Ġwithin": 2389, + "Ġspark": 2390, + "Ġking": 2391, + "Ġlonger": 2392, + "Ġbowl": 2393, + "Ġsent": 2394, + "ars": 2395, + "Ġbring": 2396, + "Ġslowly": 2397, + "Ġcard": 2398, + "ention": 2399, + "Ġconstruc": 2400, + "fort": 2401, + "Ġchang": 2402, + "Ġproble": 2403, + "Ġbroke": 2404, + "ches": 2405, + "irty": 2406, + "Oh": 2407, + "ection": 2408, + "Ġra": 2409, + "Ġjoy": 2410, + "Ġmonth": 2411, + "Ġdem": 2412, + "ressed": 2413, + "par": 2414, + "ighb": 2415, + "ances": 2416, + "read": 2417, + "Ġthird": 2418, + "Ġexper": 2419, + "Ġpaint": 2420, + "eal": 2421, + "Ġcup": 2422, + "Ġbody": 2423, + "Ġ30": 2424, + "Ġlow": 2425, + "Ġthrow": 2426, + "ĠTommy": 2427, + "Ġhigher": 2428, + "ices": 2429, + "Ġneighb": 2430, + "Ġquest": 2431, + "ones": 2432, + "ĠDece": 2433, + "Ġtoday": 2434, + "ĠAmy": 2435, + "Ġju": 2436, + "ĠNove": 2437, + "iversity": 2438, + "ĠNovember": 2439, + "Ġhalf": 2440, + "Ġer": 2441, + "Ġappeared": 2442, + "ĠDecember": 2443, + "Ġspecies": 2444, + "ĠMarch": 2445, + "Max": 2446, + "Ġtyp": 2447, + "itions": 2448, + "Ġprevious": 2449, + "Ġhelping": 2450, + "Ġperiod": 2451, + "Ġestab": 2452, + "Ġord": 2453, + "Ġvideo": 2454, + "Ġpract": 2455, + "Ġthinks": 2456, + "Ġbigger": 2457, + "Ġmagical": 2458, + "itch": 2459, + "Ġfruit": 2460, + "Ġreview": 2461, + "rit": 2462, + "ission": 2463, + "ok": 2464, + "Ġcross": 2465, + "Ġfather": 2466, + "olf": 2467, + "Ġdolls": 2468, + "Ġcal": 2469, + "Ġcorn": 2470, + "irth": 2471, + "Ġfarmer": 2472, + "Ġeventually": 2473, + "Ġgovernment": 2474, + "most": 2475, + "ulation": 2476, + "Ġanimal": 2477, + "ional": 2478, + "Ġbrown": 2479, + "sc": 2480, + "ering": 2481, + "orse": 2482, + "Ġkey": 2483, + "ming": 2484, + "Ġcandy": 2485, + "itting": 2486, + "Ġorder": 2487, + "Ġtimes": 2488, + "Ġballoon": 2489, + "Ġfurther": 2490, + "Ġtour": 2491, + "ogra": 2492, + "umb": 2493, + "Ġmod": 2494, + "Ġbelieve": 2495, + "Ġopp": 2496, + "Ġalthough": 2497, + "Ġrespect": 2498, + "aughter": 2499, + "Ġrad": 2500, + "Ġeverywhere": 2501, + "ences": 2502, + "Ġdiscover": 2503, + "Ġ100": 2504, + "uzz": 2505, + "ped": 2506, + "asket": 2507, + "fic": 2508, + "Ġsol": 2509, + "Ġworried": 2510, + "Ġrelie": 2511, + "Ġbike": 2512, + "Ġstories": 2513, + "Ġ192": 2514, + "ĠÂ": 2515, + "ocked": 2516, + "Ġdangerous": 2517, + "ĠEurope": 2518, + "gg": 2519, + "Ġpoint": 2520, + "Ġpull": 2521, + "Ġfaster": 2522, + "ĠNational": 2523, + "ateful": 2524, + "ov": 2525, + "Ġmot": 2526, + "Ġwelc": 2527, + "aff": 2528, + "Ġduck": 2529, + "ler": 2530, + "ald": 2531, + "Ġdoctor": 2532, + "ropical": 2533, + "iation": 2534, + "Ġhon": 2535, + "Ġsecret": 2536, + "ĠSe": 2537, + "ĠBy": 2538, + "Ġgrateful": 2539, + "Ġexplained": 2540, + "ae": 2541, + "ĠPh": 2542, + "OK": 2543, + "iness": 2544, + "Ġprincess": 2545, + "Okay": 2546, + "ĠRo": 2547, + "Ġblank": 2548, + "ring": 2549, + "Ġnearby": 2550, + "ĠEngland": 2551, + "Ġeight": 2552, + "ana": 2553, + "Ġrole": 2554, + "Ġauth": 2555, + "Ġkiss": 2556, + "Ġmoder": 2557, + "Ġpen": 2558, + "sp": 2559, + "ĠRiver": 2560, + "althy": 2561, + "Ġwag": 2562, + "itary": 2563, + "Ġcarry": 2564, + "dom": 2565, + "Ġisland": 2566, + "Ġquiet": 2567, + "int": 2568, + "ĠCoun": 2569, + "Ġteacher": 2570, + "roduc": 2571, + "Ġlocal": 2572, + "use": 2573, + "Ġtakes": 2574, + "ucks": 2575, + "Ġstepped": 2576, + "Ġpost": 2577, + "Ġhoped": 2578, + "ior": 2579, + "Ġiss": 2580, + "orrow": 2581, + "ĠMan": 2582, + "roy": 2583, + "ĠOr": 2584, + "ither": 2585, + "Ġ2010": 2586, + "aining": 2587, + "Ġfarm": 2588, + "Ġwritten": 2589, + "Ġdragon": 2590, + "Ġchair": 2591, + "Ġstat": 2592, + "ĠEd": 2593, + "Ġcrying": 2594, + "imed": 2595, + "ĠCity": 2596, + "ubb": 2597, + "Ġusing": 2598, + "ining": 2599, + "Ġheart": 2600, + "Ġplayer": 2601, + "levision": 2602, + "pping": 2603, + "Ġdropped": 2604, + "Ġsimilar": 2605, + "ĠGeor": 2606, + "Ġdaughter": 2607, + "Ġlaw": 2608, + "Ġtrad": 2609, + "Ġtrack": 2610, + "Ġweek": 2611, + "ives": 2612, + "nam": 2613, + "ising": 2614, + "Ġmonkey": 2615, + "Ġcarr": 2616, + "Ġpopular": 2617, + "Ġbasket": 2618, + "mp": 2619, + "ouble": 2620, + "ĠJill": 2621, + "Ġcommon": 2622, + "aul": 2623, + "Ġcolorful": 2624, + "ĠSome": 2625, + "Ġtwins": 2626, + "Ġcompany": 2627, + "Ġbirth": 2628, + "Ġpiece": 2629, + "Ġbelong": 2630, + "Sure": 2631, + "asing": 2632, + "Ġhowever": 2633, + "eder": 2634, + "Ġthrew": 2635, + "ĠWest": 2636, + "Ġfig": 2637, + "Ġsmart": 2638, + "Ġcomb": 2639, + "Ġobs": 2640, + "Ġgiven": 2641, + "Ġprop": 2642, + "Ġpushed": 2643, + "aving": 2644, + "Ġrecorded": 2645, + "Ġaddition": 2646, + "Hi": 2647, + "ĠDuring": 2648, + "Ġ2008": 2649, + "Ġeating": 2650, + "omin": 2651, + "ĠMolly": 2652, + "af": 2653, + "ude": 2654, + "Why": 2655, + "Ġarch": 2656, + "Ġdirty": 2657, + "Ġmach": 2658, + "bow": 2659, + "ole": 2660, + "Ġbuck": 2661, + "Ġcountry": 2662, + "aly": 2663, + "weet": 2664, + "lu": 2665, + "pper": 2666, + "Ġconsidered": 2667, + "Ġparticular": 2668, + "Ġtaken": 2669, + "Ġcommand": 2670, + "Ġsinging": 2671, + "Ġpolit": 2672, + "ĠEl": 2673, + "Ġdry": 2674, + "ĠMich": 2675, + "Ġwide": 2676, + "rench": 2677, + "yard": 2678, + "Ġ2009": 2679, + "Ġgent": 2680, + "Ġshop": 2681, + "Ġadded": 2682, + "Ġamong": 2683, + "Ġspent": 2684, + "play": 2685, + "Ġturns": 2686, + "Ġshap": 2687, + "Ġenc": 2688, + "ĠSm": 2689, + "Ġformer": 2690, + "Ġsuccessful": 2691, + "Ġwoman": 2692, + "Ġ21": 2693, + "Ġsour": 2694, + "Ġpig": 2695, + "Ġinit": 2696, + "Ġnet": 2697, + "Ġfeels": 2698, + "Ġhistory": 2699, + "yle": 2700, + "Ġflag": 2701, + "itive": 2702, + "ground": 2703, + "estern": 2704, + "ĠAb": 2705, + "Ġalmost": 2706, + "Ġten": 2707, + "Ġarms": 2708, + "Ġbranch": 2709, + "cial": 2710, + "Ġnest": 2711, + "Ġbath": 2712, + "Ġstuck": 2713, + "Ġaccident": 2714, + "Ġmagic": 2715, + "Ġupset": 2716, + "Ġonce": 2717, + "ĠBatt": 2718, + "Ġlevel": 2719, + "Ġneck": 2720, + "Ġgentle": 2721, + "Ġson": 2722, + "Ġwest": 2723, + "Ġru": 2724, + "ĠFluffy": 2725, + "Ġfact": 2726, + "Ġdeter": 2727, + "Ġeast": 2728, + "Ġcray": 2729, + "Ġcirc": 2730, + "uce": 2731, + "Ġcou": 2732, + "ribut": 2733, + "Ġdirect": 2734, + "tle": 2735, + "Ġversion": 2736, + "Ġnap": 2737, + "Ġcaught": 2738, + "Ġpath": 2739, + "ĠChar": 2740, + "ĠEnglish": 2741, + "pite": 2742, + "Ġserv": 2743, + "Ġstri": 2744, + "Ġwouldn": 2745, + "Ġvillage": 2746, + "Ġmonster": 2747, + "Ġsang": 2748, + "Ġgold": 2749, + "Ġdiffic": 2750, + "Ġcomes": 2751, + "Ġpublished": 2752, + "Ġseemed": 2753, + "Ġlon": 2754, + "Ġlive": 2755, + "Ġtreasure": 2756, + "Ġcomplet": 2757, + "Ġtot": 2758, + "Ġmine": 2759, + "Ġhappen": 2760, + "Ġcor": 2761, + "Ġlay": 2762, + "nel": 2763, + "osaur": 2764, + "Ġshoes": 2765, + "Ġwings": 2766, + "Ġrocks": 2767, + "Ġequ": 2768, + "epend": 2769, + "Ġowl": 2770, + "Ġtest": 2771, + "Ġrelease": 2772, + "cean": 2773, + "ival": 2774, + "iddle": 2775, + "Ġdrove": 2776, + "Ġfit": 2777, + "ĠDivision": 2778, + "Ġfairy": 2779, + "ricane": 2780, + "ai": 2781, + "ges": 2782, + "Ġwhole": 2783, + "Ġstruc": 2784, + "Ġclear": 2785, + "Ġmodern": 2786, + "Ġbite": 2787, + "ĠFrench": 2788, + "ounced": 2789, + "ĠGu": 2790, + "Ġpeace": 2791, + "raft": 2792, + "ĠBar": 2793, + "Ġadventures": 2794, + "Ġposition": 2795, + "Ġmat": 2796, + "Ġorange": 2797, + "Ġlonely": 2798, + "Ġpock": 2799, + "utes": 2800, + "Ġnovel": 2801, + "Ġwelcome": 2802, + "Ġvict": 2803, + "oss": 2804, + "Ġdestroy": 2805, + "Ġtelevision": 2806, + "Ġemb": 2807, + "vely": 2808, + "Ġforget": 2809, + "ointed": 2810, + "Ġrainbow": 2811, + "Ġblanket": 2812, + "ique": 2813, + "Ġsuddenly": 2814, + "Ġlunch": 2815, + "Ġvol": 2816, + "Ġattack": 2817, + "Ġwish": 2818, + "Ġ2007": 2819, + "ĠCanad": 2820, + "Ġrefer": 2821, + "Ġsounds": 2822, + "Ġhuman": 2823, + "pec": 2824, + "resent": 2825, + "ĠWhile": 2826, + "Ġclapped": 2827, + "ik": 2828, + "ĠNe": 2829, + "Ġnoises": 2830, + "Ġwrite": 2831, + "Ġhours": 2832, + "Ġswings": 2833, + "gram": 2834, + "lebr": 2835, + "Ġbee": 2836, + "Ġauthor": 2837, + "ĠDav": 2838, + "Ġnothing": 2839, + "Ġarg": 2840, + "Ġearl": 2841, + "St": 2842, + "Ġpress": 2843, + "ody": 2844, + "Ġproduced": 2845, + "Ġtravel": 2846, + "een": 2847, + "ern": 2848, + "Ġmist": 2849, + "Ġegg": 2850, + "Ġinclude": 2851, + "bruary": 2852, + "ĠFebruary": 2853, + "sel": 2854, + "Mia": 2855, + "reamed": 2856, + "ishing": 2857, + "Ġforward": 2858, + "ears": 2859, + "ĠEar": 2860, + "Ġimpro": 2861, + "Ġpassed": 2862, + "ograph": 2863, + "Ġcommun": 2864, + "Ġcontrol": 2865, + "Ġ23": 2866, + "Ġeleph": 2867, + "uitar": 2868, + "Ġcelebr": 2869, + "Ġdeterm": 2870, + "ĠCr": 2871, + "Ġcareer": 2872, + "Ġwriting": 2873, + "line": 2874, + "Ġsum": 2875, + "ably": 2876, + "ĠState": 2877, + "Ġcheered": 2878, + "ĠComp": 2879, + "Ġsuff": 2880, + "Ġpra": 2881, + "Ġworking": 2882, + "Ġoccur": 2883, + "Ġlim": 2884, + "ccording": 2885, + "Ġprof": 2886, + "Ġinvol": 2887, + "Ġ22": 2888, + "Ġchurch": 2889, + "iment": 2890, + "oose": 2891, + "ĠPark": 2892, + "Ġreturn": 2893, + "ĠEmma": 2894, + "Ġsearch": 2895, + "Finally": 2896, + "Wh": 2897, + "erry": 2898, + "Ġap": 2899, + "Ġimag": 2900, + "iety": 2901, + "nal": 2902, + "Ġdet": 2903, + "ĠThese": 2904, + "Ġonto": 2905, + "Ġla": 2906, + "ĠSte": 2907, + "Ġdriver": 2908, + "work": 2909, + "Ġaff": 2910, + "Ġfence": 2911, + "Ġmembers": 2912, + "Ġrout": 2913, + "Ġcost": 2914, + "ogn": 2915, + "Ġholding": 2916, + "Ġshel": 2917, + "Ġesc": 2918, + "Lila": 2919, + "Ġaf": 2920, + "nings": 2921, + "Ġexploring": 2922, + "Ġgen": 2923, + "Ġwave": 2924, + "reek": 2925, + "ĠX": 2926, + "ĠTV": 2927, + "ĠRed": 2928, + "Ġlarg": 2929, + "asted": 2930, + "ĠMy": 2931, + "Ġdefe": 2932, + "Ġestabl": 2933, + "Ġwise": 2934, + "Ġpoor": 2935, + "Ġgives": 2936, + "Ġ24": 2937, + "Ġmilitary": 2938, + "ĠDaddy": 2939, + "Ġtom": 2940, + "atic": 2941, + "ĠDon": 2942, + "ĠWilliam": 2943, + "sequ": 2944, + "isc": 2945, + "Ġmad": 2946, + "Ġnose": 2947, + "Ġcarried": 2948, + "Ġproduction": 2949, + "ider": 2950, + "elly": 2951, + "Ġhugs": 2952, + "Ġgift": 2953, + "ampions": 2954, + "Ġcoll": 2955, + "Ġpuzz": 2956, + "Ġdiv": 2957, + "adow": 2958, + "iction": 2959, + "Ġcave": 2960, + "ĠMin": 2961, + "Ġbackyard": 2962, + "ustr": 2963, + "Ġ2011": 2964, + "Ġinflu": 2965, + "Ġjourney": 2966, + "Ġsoup": 2967, + "Ġstreet": 2968, + "stit": 2969, + "Ġ190": 2970, + "ĠMcC": 2971, + "Ġpocket": 2972, + "Ġsil": 2973, + "Ġbought": 2974, + "Ġcell": 2975, + "omen": 2976, + "Ġ26": 2977, + "Ġ2006": 2978, + "Ġrecogn": 2979, + "Ġsal": 2980, + "ades": 2981, + "iff": 2982, + "echn": 2983, + "Ġ2012": 2984, + "Ġfail": 2985, + "icket": 2986, + "Ġswam": 2987, + "Ġtotal": 2988, + "Ġsick": 2989, + "ittens": 2990, + "Ġcoin": 2991, + "ending": 2992, + "Ġresult": 2993, + "Ġcritic": 2994, + "Ġespec": 2995, + "Ġespecially": 2996, + "onom": 2997, + "Ġnaught": 2998, + "itty": 2999, + "raid": 3000, + "orthern": 3001, + "Ġstated": 3002, + "ĠCent": 3003, + "Ġcreated": 3004, + "Ġfighting": 3005, + "Ġhorse": 3006, + "ases": 3007, + "ĠTw": 3008, + "Ġcann": 3009, + "Ġ&": 3010, + "Ġsaying": 3011, + "Ġtitle": 3012, + "Ġble": 3013, + "outhern": 3014, + "amb": 3015, + "Ġwee": 3016, + "Ġben": 3017, + "Ġshook": 3018, + "Ġreported": 3019, + "Ġnaughty": 3020, + "men": 3021, + "Ġself": 3022, + "Ġwild": 3023, + "Ġ28": 3024, + "ĠGener": 3025, + "Ġchange": 3026, + "Ġstyle": 3027, + "apan": 3028, + "cl": 3029, + "Ġtiny": 3030, + "ites": 3031, + "ĠCome": 3032, + "Ġapple": 3033, + "Ġban": 3034, + "ĠSong": 3035, + "Ġwhist": 3036, + "ume": 3037, + "Ġresul": 3038, + "Ġdied": 3039, + "Ġmail": 3040, + "Ġmeant": 3041, + "iers": 3042, + "Ġplaces": 3043, + "Ġkite": 3044, + "Ġintroduc": 3045, + "Ġrub": 3046, + "Ġwoke": 3047, + "Ġpay": 3048, + "ĠBrown": 3049, + "ospital": 3050, + "head": 3051, + "ĠJapan": 3052, + "Ġbusy": 3053, + "Ġstructure": 3054, + "ief": 3055, + "Ġpointed": 3056, + "Ġwatching": 3057, + "Ġsuper": 3058, + "ĠAf": 3059, + "illa": 3060, + "ĠUniversity": 3061, + "Ġdifficult": 3062, + "Ġwife": 3063, + "Ġhuge": 3064, + "ĠPol": 3065, + "Ġrob": 3066, + "Ġ2013": 3067, + "ĠLeague": 3068, + "val": 3069, + "Ġrepresent": 3070, + "Ġafraid": 3071, + "Ġcop": 3072, + "ĠMe": 3073, + "Ġexam": 3074, + "Ġsitting": 3075, + "ĠTheir": 3076, + "ĠAm": 3077, + "ĠAtl": 3078, + "Ġjar": 3079, + "airs": 3080, + "Ġregular": 3081, + "Ġminutes": 3082, + "Ġships": 3083, + "ĠGrandma": 3084, + "Later": 3085, + "empt": 3086, + "Ġhistor": 3087, + "selves": 3088, + "ĠJames": 3089, + "Ġabove": 3090, + "iron": 3091, + "lder": 3092, + "ĠJust": 3093, + "Ġbench": 3094, + "Ġjuice": 3095, + "And": 3096, + "Ġeither": 3097, + "Ġsignific": 3098, + "ĠRoman": 3099, + "Ġ50": 3100, + "arn": 3101, + "Ġgather": 3102, + "Ġshr": 3103, + "Ġremained": 3104, + "Ġbegin": 3105, + "Ġsepar": 3106, + "Bob": 3107, + "Do": 3108, + "Ġtouc": 3109, + "ression": 3110, + "rent": 3111, + "ĠSoon": 3112, + "Ġmiles": 3113, + "Ġlab": 3114, + "Ġgoal": 3115, + "Ġ27": 3116, + "Ġshows": 3117, + "Ġactiv": 3118, + "com": 3119, + "Ġhope": 3120, + "ĠPort": 3121, + "ĠPeter": 3122, + "Ġjoined": 3123, + "Ġsharp": 3124, + "Of": 3125, + "Ġsite": 3126, + "Ġseven": 3127, + "Ġexciting": 3128, + "Ġthroughout": 3129, + "ĠLond": 3130, + "ceed": 3131, + "Ġlaughing": 3132, + "Ġpatient": 3133, + "Ġallowed": 3134, + "Ġrelieved": 3135, + "icked": 3136, + "Ġstep": 3137, + "ument": 3138, + "Ġweak": 3139, + "angu": 3140, + "Ġnational": 3141, + "Ġstone": 3142, + "ĠEx": 3143, + "Ġplaced": 3144, + "ĠInside": 3145, + "ĠThank": 3146, + "Ġshapes": 3147, + "Ġwand": 3148, + "isa": 3149, + "Ġrul": 3150, + "Ġprogram": 3151, + "ĠAlthough": 3152, + "ĠLondon": 3153, + "ĠBill": 3154, + "Ġbucket": 3155, + "Ġfing": 3156, + "Ġnoted": 3157, + "Ġpopulation": 3158, + "Ġft": 3159, + "Ġmatter": 3160, + "ĠFinally": 3161, + "Ġanyone": 3162, + "ĠChurch": 3163, + "Ġpoints": 3164, + "oot": 3165, + "Ġwra": 3166, + "Ġmind": 3167, + "ĠAmerica": 3168, + "nes": 3169, + "idence": 3170, + "ĠFin": 3171, + "ĠRoy": 3172, + "Ġdrive": 3173, + "á": 3174, + "Ġcute": 3175, + "alion": 3176, + "Ġmoving": 3177, + "Ġwondered": 3178, + "Ġinteresting": 3179, + "gel": 3180, + "ĠTweet": 3181, + "Ġboard": 3182, + "ancy": 3183, + "Ġproblem": 3184, + "Ġmachine": 3185, + "Ġmass": 3186, + "Ġplane": 3187, + "Ġshell": 3188, + "ĠGl": 3189, + "ĠArmy": 3190, + "Ġshoot": 3191, + "Ġcannot": 3192, + "Ġbecom": 3193, + "Ġpoem": 3194, + "Ġmilk": 3195, + "Ġdeveloped": 3196, + "Ġsuggested": 3197, + "Ġtor": 3198, + "Ġstage": 3199, + "Ġspo": 3200, + "Ġdiscovered": 3201, + "Ġestablished": 3202, + "Ġtun": 3203, + "ready": 3204, + "Ġmm": 3205, + "oof": 3206, + "Ġworks": 3207, + "Ġstudy": 3208, + "Ġforces": 3209, + "ĠMiss": 3210, + "Ġaccidentally": 3211, + "ĠIf": 3212, + "Ġfem": 3213, + "Ġrare": 3214, + "ĠMed": 3215, + "Ġsunny": 3216, + "Ġbirthday": 3217, + "Ġelephant": 3218, + "Ġbas": 3219, + "Ġgrew": 3220, + "rie": 3221, + "ĠPro": 3222, + "shine": 3223, + "ĠJimmy": 3224, + "Ġtropical": 3225, + "Ġpudd": 3226, + "Ġperformed": 3227, + "Ġlangu": 3228, + "ĠMus": 3229, + "ĠCor": 3230, + "Ġeffect": 3231, + "Ġaward": 3232, + "Ġbi": 3233, + "elling": 3234, + "ĠGeorge": 3235, + "Ġtouched": 3236, + "Ġbreat": 3237, + "Ġentire": 3238, + "ford": 3239, + "light": 3240, + "pa": 3241, + "Ġign": 3242, + "Ġbase": 3243, + "ĠCal": 3244, + "Ġareas": 3245, + "ĠGod": 3246, + "Ġcolour": 3247, + "Ġswimming": 3248, + "Ġcraw": 3249, + "Ġcampa": 3250, + "Ġcaused": 3251, + "Ġalready": 3252, + "ĠPe": 3253, + "Ġoffice": 3254, + "Ġmyster": 3255, + "Ġpurple": 3256, + "craft": 3257, + "Ġstra": 3258, + "Ġstation": 3259, + "ills": 3260, + "Ġvi": 3261, + "Ġmixed": 3262, + "Ġdanced": 3263, + "Ġ!": 3264, + "ĠEn": 3265, + "aps": 3266, + "Ġtrip": 3267, + "Ġpowerful": 3268, + "ĠAtlant": 3269, + "Ġsaf": 3270, + "Ġforever": 3271, + "Ġdrink": 3272, + "Ġindepend": 3273, + "ael": 3274, + "het": 3275, + "ato": 3276, + "Ġanc": 3277, + "Ġgoes": 3278, + "Ġsunshine": 3279, + "ĠGeneral": 3280, + "Al": 3281, + "ille": 3282, + "Ġplant": 3283, + "Ġcompleted": 3284, + "Ġfeather": 3285, + "Ġprim": 3286, + "Ġsurf": 3287, + "Ġprotect": 3288, + "fortable": 3289, + "ĠAfric": 3290, + "Ġgigg": 3291, + "Ġfinish": 3292, + "Ġ189": 3293, + "Ġaccom": 3294, + "Ġfootball": 3295, + "ÃŃ": 3296, + "Ġdi": 3297, + "ption": 3298, + "Ġvarious": 3299, + "ampionship": 3300, + "imately": 3301, + "ĠRober": 3302, + "Ġtechn": 3303, + "ĠSim": 3304, + "ĠMad": 3305, + "Ġpromise": 3306, + "Ġperformance": 3307, + "cast": 3308, + "Ġcoo": 3309, + "Ġring": 3310, + "Ġspread": 3311, + "Ġpolice": 3312, + "Ġsignificant": 3313, + "Ġgiant": 3314, + "ĠDes": 3315, + "Ġspin": 3316, + "Ġsnowman": 3317, + "ĠCounty": 3318, + "Ġcy": 3319, + "ĠMag": 3320, + "Ġage": 3321, + "Ġquar": 3322, + "yal": 3323, + "Ġcheese": 3324, + "Ġofficial": 3325, + "Ġhar": 3326, + "ĠSomet": 3327, + "ging": 3328, + "Ġbal": 3329, + "Ġdevelopment": 3330, + "Ġwearing": 3331, + "ror": 3332, + "hest": 3333, + "Ġreve": 3334, + "ĠAccording": 3335, + "Ġdecl": 3336, + "ivil": 3337, + "Ġletter": 3338, + "Ġterm": 3339, + "Ġocean": 3340, + "ĠIr": 3341, + "Ġhello": 3342, + "Ġfeed": 3343, + "Ġrese": 3344, + "Ġevents": 3345, + "Ġguns": 3346, + "Ġlucky": 3347, + "Ġconstruction": 3348, + "Ġhous": 3349, + "Ġmonths": 3350, + "Ġmid": 3351, + "igade": 3352, + "chie": 3353, + "Ġaud": 3354, + "Ġfaces": 3355, + "Ġcand": 3356, + "aser": 3357, + "Ġbush": 3358, + "ĠMama": 3359, + "Ġsmo": 3360, + "Ġserved": 3361, + "Hey": 3362, + "Ġdrum": 3363, + "lect": 3364, + "Ġsave": 3365, + "Ġavail": 3366, + "Ġneighbor": 3367, + "Ġpolitical": 3368, + "de": 3369, + "Ġmountain": 3370, + "Ġfort": 3371, + "ĠMark": 3372, + "ĠPer": 3373, + "Ġcozy": 3374, + "ublic": 3375, + "Ġash": 3376, + "ĠDan": 3377, + "Ġbattle": 3378, + "ky": 3379, + "Ġpan": 3380, + "Ġkilled": 3381, + "Ġsmiling": 3382, + "Ġbridge": 3383, + "ĠOld": 3384, + "Ġcharacters": 3385, + "Ġbelieved": 3386, + "za": 3387, + "Ġwolf": 3388, + "ĠRich": 3389, + "Ġeye": 3390, + "Ġbread": 3391, + "Ġformed": 3392, + "ylan": 3393, + "kin": 3394, + "Ġstret": 3395, + "Ġengine": 3396, + "ĠHigh": 3397, + "ĠGo": 3398, + "Ġsandw": 3399, + "Ġsearched": 3400, + "Ġcorner": 3401, + "han": 3402, + "Ġspoon": 3403, + "ĠRep": 3404, + "Ġsmaller": 3405, + "Ġweeks": 3406, + "ological": 3407, + "uel": 3408, + "Ġhealthy": 3409, + "Ġrelations": 3410, + "Ġelect": 3411, + "Ġtalked": 3412, + "Ġtalking": 3413, + "enced": 3414, + "ertain": 3415, + "Ġforce": 3416, + "roph": 3417, + "Ġtells": 3418, + "Ġfac": 3419, + "Ġplayers": 3420, + "Ġscar": 3421, + "Ġtrue": 3422, + "Ġproject": 3423, + "Ġcovered": 3424, + "Ġcampaign": 3425, + "ĠHar": 3426, + "ĠPaul": 3427, + "Ġconn": 3428, + "Ġmarket": 3429, + "useum": 3430, + "Ġborn": 3431, + "Ġpill": 3432, + "Ġgas": 3433, + "unt": 3434, + "Ġearlier": 3435, + "Ġmiddle": 3436, + "Ġrev": 3437, + "Ġpred": 3438, + "Ġveget": 3439, + "Ġclouds": 3440, + "Lucy": 3441, + "azine": 3442, + "Ġtries": 3443, + "Ġbottle": 3444, + "iated": 3445, + "ĠMittens": 3446, + "Ġstanding": 3447, + "idden": 3448, + "Ġtasty": 3449, + "ĠCo": 3450, + "Ġbutton": 3451, + "ĠPet": 3452, + "Ġtrust": 3453, + "Ġtradition": 3454, + "Ġhospital": 3455, + "vert": 3456, + "amer": 3457, + "Ġlog": 3458, + "ella": 3459, + "ables": 3460, + "ĠRoad": 3461, + "iest": 3462, + "ests": 3463, + "Ġknee": 3464, + "medi": 3465, + "Ġquestion": 3466, + "oub": 3467, + "Ġthick": 3468, + "icated": 3469, + "ecut": 3470, + "ĠPen": 3471, + "Ġ29": 3472, + "Ġputs": 3473, + "Ġdisappear": 3474, + "Ġobser": 3475, + "Ġcow": 3476, + "ĠPal": 3477, + "Ġcase": 3478, + "Ġrange": 3479, + "ĠMor": 3480, + "Ġloves": 3481, + "Ġdecor": 3482, + "Ġemp": 3483, + "Ġconfused": 3484, + "Good": 3485, + "iber": 3486, + "Ġ2005": 3487, + "Ġattr": 3488, + "ency": 3489, + "Ġzoom": 3490, + "round": 3491, + "inc": 3492, + "arch": 3493, + "Ġthemselves": 3494, + "ivid": 3495, + "Ġteeth": 3496, + "ĠSammy": 3497, + "Ġcollect": 3498, + "Ġrolled": 3499, + "Ġaver": 3500, + "Ġpool": 3501, + "ĠFred": 3502, + "ĠIndian": 3503, + "Ġavailable": 3504, + "reg": 3505, + "reland": 3506, + "Ġleast": 3507, + "Ġleaving": 3508, + "ization": 3509, + "Ġhoney": 3510, + "ĠSw": 3511, + "oles": 3512, + "Ġitself": 3513, + "ĠReg": 3514, + "ĠIsland": 3515, + "Ġviol": 3516, + "Ġfear": 3517, + "ashed": 3518, + "Ġdrew": 3519, + "Ġmov": 3520, + "Ġdead": 3521, + "Ġzoo": 3522, + "rest": 3523, + "Ġpack": 3524, + "Ġmater": 3525, + "ĠSec": 3526, + "There": 3527, + "ĠDylan": 3528, + "Ġtrouble": 3529, + "Ġattempt": 3530, + "hys": 3531, + "ĠMo": 3532, + "ols": 3533, + "Ġgray": 3534, + "Ġwaiting": 3535, + "Ġannounced": 3536, + "Ġcrayons": 3537, + "aked": 3538, + "field": 3539, + "Ġbat": 3540, + "oura": 3541, + "Ġrelig": 3542, + "Ġspotted": 3543, + "omb": 3544, + "ĠRec": 3545, + "Ġsurv": 3546, + "Ġsmelled": 3547, + "itted": 3548, + "iser": 3549, + "Ġnames": 3550, + "Ġbeg": 3551, + "Ġstren": 3552, + "Ġscreen": 3553, + "ffic": 3554, + "ĠThom": 3555, + "Ġlocated": 3556, + "ĠAir": 3557, + "Ġmeasure": 3558, + "Ġprocess": 3559, + "Ġdistance": 3560, + "ĠJenny": 3561, + "ĠAustralia": 3562, + "aled": 3563, + "Ġnumbers": 3564, + "Ġgiving": 3565, + "mar": 3566, + "Ġident": 3567, + "ico": 3568, + "ĠIreland": 3569, + "pted": 3570, + "Ġsize": 3571, + "Ġoffered": 3572, + "ĠâĢĻ": 3573, + "Ġfixed": 3574, + "Ġinsp": 3575, + "Ġducks": 3576, + "Ġlovely": 3577, + "Ġdig": 3578, + "Ġrope": 3579, + "Ġgod": 3580, + "ĠEven": 3581, + "Ġcomment": 3582, + "Ġpush": 3583, + "Ġfif": 3584, + "ĠEll": 3585, + "Ġcoast": 3586, + "Ġ188": 3587, + "Ġhurricane": 3588, + "Ġdiscuss": 3589, + "fall": 3590, + "ĠHa": 3591, + "Ġscored": 3592, + "Ġ2004": 3593, + "Come": 3594, + "Ġpile": 3595, + "Ġlif": 3596, + "Ġhelpful": 3597, + "Ġsnake": 3598, + "Ġcouch": 3599, + "Ġstreng": 3600, + "ality": 3601, + "Ġbroad": 3602, + "Ġachie": 3603, + "Ġur": 3604, + "Ġjog": 3605, + "ha": 3606, + "now": 3607, + "lex": 3608, + "Ġteach": 3609, + "Ġfeatures": 3610, + "ĠSy": 3611, + "ĠHen": 3612, + "Ġchanged": 3613, + "Ġdetermined": 3614, + "Ġpil": 3615, + "Ġseat": 3616, + "Ġmole": 3617, + "ĠKe": 3618, + "assed": 3619, + "Ġrespons": 3620, + "arian": 3621, + "Ġcoat": 3622, + "ĠDavid": 3623, + "cy": 3624, + "cent": 3625, + "Ġbell": 3626, + "Ġlad": 3627, + "ado": 3628, + "Ġspace": 3629, + "Ġhost": 3630, + "Tommy": 3631, + "Ġcapt": 3632, + "Ġphone": 3633, + "ĠBlack": 3634, + "Ġrough": 3635, + "Ġ31": 3636, + "ample": 3637, + "Ġassoc": 3638, + "Ġgently": 3639, + "Ġnon": 3640, + "Ġshining": 3641, + "Ġdisplay": 3642, + "Ġ40": 3643, + "Ġclever": 3644, + "jects": 3645, + "Ġnut": 3646, + "Ġnature": 3647, + "Ġexample": 3648, + "Ġcloth": 3649, + "Ġpraised": 3650, + "Ġwomen": 3651, + "Ġsack": 3652, + "ĠAss": 3653, + "Ġcalling": 3654, + "Ġnorm": 3655, + "ĠBo": 3656, + "Ġloss": 3657, + "ocol": 3658, + "Ġmeans": 3659, + "ĠOl": 3660, + "Ġprevent": 3661, + "oday": 3662, + "Ġending": 3663, + "Ġsmooth": 3664, + "Ġstir": 3665, + "Ġblock": 3666, + "ĠAnn": 3667, + "Ġcritics": 3668, + "Ġ186": 3669, + "Ġattemp": 3670, + "ustrated": 3671, + "Ġfre": 3672, + "Ġfoc": 3673, + "ĠRose": 3674, + "Ġaircraft": 3675, + "Ġphot": 3676, + "Ġrobot": 3677, + "Ġaction": 3678, + "Ġmotor": 3679, + "Ġpin": 3680, + "Ġasleep": 3681, + "astic": 3682, + "Ġseek": 3683, + "Ġregion": 3684, + "Ġindivid": 3685, + "form": 3686, + "ano": 3687, + "Ġstood": 3688, + "ully": 3689, + "Ġcontent": 3690, + "Ġleading": 3691, + "aded": 3692, + "Ġremind": 3693, + "Ġearth": 3694, + "Ġobject": 3695, + "empor": 3696, + "Ġpuzzle": 3697, + "ĠRoyal": 3698, + "Ġoven": 3699, + "Ġcompl": 3700, + "Ġdamage": 3701, + "Ġpossible": 3702, + "Ġtaste": 3703, + "Ġrather": 3704, + "ĠWal": 3705, + "Ġmanaged": 3706, + "Ġmoon": 3707, + "Ġdebut": 3708, + "Ġcomplete": 3709, + "ĠTown": 3710, + "iled": 3711, + "Ġyet": 3712, + "aker": 3713, + "Ġ185": 3714, + "Ġinvest": 3715, + "Ġmissed": 3716, + "Ġfigure": 3717, + "Ġembarr": 3718, + "Ġtaught": 3719, + "Ġtasted": 3720, + "ino": 3721, + "ari": 3722, + "Ġmud": 3723, + "Ġplants": 3724, + "Ġextra": 3725, + "Ġanswer": 3726, + "under": 3727, + "Ġsuit": 3728, + "Ġpir": 3729, + "rab": 3730, + "oph": 3731, + "ĠPat": 3732, + "Ġchocol": 3733, + "Ġproper": 3734, + "Ġpretended": 3735, + "Ġbuildings": 3736, + "Ġcreate": 3737, + "ength": 3738, + "Ġmic": 3739, + "oted": 3740, + "aven": 3741, + "Ġspeed": 3742, + "ĠTur": 3743, + "Ġwhenever": 3744, + "Ġmagn": 3745, + "Ġoriginally": 3746, + "Every": 3747, + "Ġsouthern": 3748, + "Ġdirt": 3749, + "Ġ2003": 3750, + "Ġlanded": 3751, + "Ġprovided": 3752, + "ĠKingdom": 3753, + "ĠSometimes": 3754, + "ucle": 3755, + "Ġscreamed": 3756, + "antry": 3757, + "Ġfourth": 3758, + "Ġfurry": 3759, + "Ġroute": 3760, + "Ġrelationship": 3761, + "Ġhero": 3762, + "Ġrat": 3763, + "Ġended": 3764, + "Ġorganized": 3765, + "ĠCompany": 3766, + "ida": 3767, + "rib": 3768, + "Ġfamous": 3769, + "Ġprofess": 3770, + "Ġmaterial": 3771, + "Ġwore": 3772, + "Ġscore": 3773, + "Ġdev": 3774, + "Ġsurround": 3775, + "ĠChristian": 3776, + "ashing": 3777, + "Ġkick": 3778, + "Ġchick": 3779, + "Ġglass": 3780, + "Ġrocket": 3781, + "Ġforgive": 3782, + "Ġservice": 3783, + "Just": 3784, + "Ġcrew": 3785, + "Ġgar": 3786, + "ĠEnd": 3787, + "Ġcalm": 3788, + "Ġec": 3789, + "Ġcommer": 3790, + "Ġcreative": 3791, + "ĠLa": 3792, + "Ġshot": 3793, + "Ġestim": 3794, + "Ġlanguage": 3795, + "rang": 3796, + "Ġfa": 3797, + "ĠSus": 3798, + "Ġnote": 3799, + "Ġpray": 3800, + "Ġgenerally": 3801, + "ĠAustralian": 3802, + "Ġhom": 3803, + "ĠMill": 3804, + "Ġgeneral": 3805, + "Ġblow": 3806, + "elp": 3807, + "ĠDay": 3808, + "Ġlegs": 3809, + "Ġparticularly": 3810, + "Ġancient": 3811, + "ĠRobert": 3812, + "Ġchocolate": 3813, + "Ġill": 3814, + "Ġhiding": 3815, + "Ġhidden": 3816, + "ential": 3817, + "Ġradio": 3818, + "olution": 3819, + "Ġshore": 3820, + "Ġscr": 3821, + "Ġflood": 3822, + "Ġdesigned": 3823, + "Jim": 3824, + "inary": 3825, + "Ġpour": 3826, + "ston": 3827, + "istic": 3828, + "ĠIntern": 3829, + "Ġcarrot": 3830, + "Ġvictory": 3831, + "Ġtomorrow": 3832, + "ators": 3833, + "acy": 3834, + "Ġunique": 3835, + "nown": 3836, + "leg": 3837, + "ighed": 3838, + "Ġshirt": 3839, + "Ġstring": 3840, + "Ġ2014": 3841, + "Ġ2015": 3842, + "ÅĵI": 3843, + "Molly": 3844, + "Ġaut": 3845, + "Ġconv": 3846, + "Ġparts": 3847, + "ipe": 3848, + "Ġserious": 3849, + "Ġeastern": 3850, + "Ġblew": 3851, + "lies": 3852, + "Ġfund": 3853, + "iger": 3854, + "rey": 3855, + "ĠTe": 3856, + "Ġeager": 3857, + "hod": 3858, + "sy": 3859, + "Ġdiam": 3860, + "ica": 3861, + "Ġshy": 3862, + "Ġspir": 3863, + "ights": 3864, + "Ġsummer": 3865, + "hood": 3866, + "Ġmer": 3867, + "ĠAct": 3868, + "urg": 3869, + "Ġappearance": 3870, + "Ġwid": 3871, + "Ġmember": 3872, + "ĠSom": 3873, + "Ġsex": 3874, + "ĠVal": 3875, + "Ġsquare": 3876, + "cil": 3877, + "Ġreac": 3878, + "ĠAre": 3879, + "ĠPres": 3880, + "Ġpractice": 3881, + "ĠSmith": 3882, + "ĠHouse": 3883, + "Ġunl": 3884, + "Ġtea": 3885, + "ĠAlice": 3886, + "Ġopening": 3887, + "ĠFlor": 3888, + "box": 3889, + "Ġpuddle": 3890, + "ĠLittle": 3891, + "Ġspicy": 3892, + "Ġcart": 3893, + "Ġapples": 3894, + "ĠLisa": 3895, + "Ġseed": 3896, + "ĠJennings": 3897, + "Ġlength": 3898, + "Ġwash": 3899, + "Ġguitar": 3900, + "ĠDr": 3901, + "ĠKitty": 3902, + "ollowing": 3903, + "ĠJew": 3904, + "Ġexist": 3905, + "Ġpeaceful": 3906, + "Now": 3907, + "ration": 3908, + "Ġchart": 3909, + "Ġknocked": 3910, + "Ġedge": 3911, + "Ġlit": 3912, + "Ġreb": 3913, + "oops": 3914, + "ĠEv": 3915, + "Ġcheer": 3916, + "Ġregard": 3917, + "Ġcookie": 3918, + "Ġdirected": 3919, + "nt": 3920, + "Ġtem": 3921, + "Ġfut": 3922, + "Ġcere": 3923, + "Ġunus": 3924, + "Ġimmedi": 3925, + "Ġwalls": 3926, + "ĠMichael": 3927, + "ĠTwo": 3928, + "Ġtent": 3929, + "Ġhang": 3930, + "ĠMex": 3931, + "Ġneg": 3932, + "ploy": 3933, + "lower": 3934, + "Ġintern": 3935, + "Ġelements": 3936, + "Ġsubsequ": 3937, + "Ġsymb": 3938, + "Ġdepend": 3939, + "Ġrefused": 3940, + "Ġeasy": 3941, + "Soon": 3942, + "ru": 3943, + "rag": 3944, + "Ġstrugg": 3945, + "Ġreplaced": 3946, + "Ġbugs": 3947, + "Ġfeatured": 3948, + "Ġ°": 3949, + "Ġhouses": 3950, + "My": 3951, + "Ġmel": 3952, + "Ġnucle": 3953, + "acing": 3954, + "Ġsoc": 3955, + "olves": 3956, + "Ġsnack": 3957, + "Ġclaim": 3958, + "ĠThomas": 3959, + "Mum": 3960, + "ĠFeder": 3961, + "Ġprep": 3962, + "Ġpicn": 3963, + "Ġhighway": 3964, + "Ġmaybe": 3965, + "ungle": 3966, + "Ġmysterious": 3967, + "Ġhid": 3968, + "ago": 3969, + "ĠEmily": 3970, + "atural": 3971, + "Ġmention": 3972, + "ĠSqu": 3973, + "achel": 3974, + "Ġvoc": 3975, + "action": 3976, + "Ġbusiness": 3977, + "Ġterrit": 3978, + "Ġtightly": 3979, + "Ġladder": 3980, + "hi": 3981, + "omm": 3982, + "ĠBur": 3983, + "Ġusually": 3984, + "ĠFrance": 3985, + "ĠPhil": 3986, + "Ġboun": 3987, + "Ġpow": 3988, + "Ġsticks": 3989, + "Ġprob": 3990, + "iano": 3991, + "Ġexpensive": 3992, + "Ġintroduced": 3993, + "ĠHenry": 3994, + "ĠHall": 3995, + "Ġplate": 3996, + "Ġjungle": 3997, + "ube": 3998, + "Ġjumping": 3999, + "Ġmetal": 4000, + "Ġdrawing": 4001, + "Ġinform": 4002, + "Ġsitu": 4003, + "Ġcurrent": 4004, + "Ġneckl": 4005, + "stant": 4006, + "Be": 4007, + "go": 4008, + "ĠJake": 4009, + "resh": 4010, + "Ġshelf": 4011, + "Ġwhistle": 4012, + "ĠSan": 4013, + "icle": 4014, + "ĠLove": 4015, + "ola": 4016, + "ĠEast": 4017, + "ĠStreet": 4018, + "Ġhighest": 4019, + "ires": 4020, + "Ġsaved": 4021, + "Ġdirector": 4022, + "ĠTogether": 4023, + "co": 4024, + "Ġbatter": 4025, + "isk": 4026, + "ota": 4027, + "ĠCup": 4028, + "roc": 4029, + "ords": 4030, + "ĠJohnny": 4031, + "west": 4032, + "Ġharm": 4033, + "Ġ187": 4034, + "Ġcentral": 4035, + "Ġindust": 4036, + "Ġdisappointed": 4037, + "Ġembarrassed": 4038, + "liam": 4039, + "ti": 4040, + "ishes": 4041, + "Ġresc": 4042, + "ĠBlue": 4043, + "gly": 4044, + "off": 4045, + "wood": 4046, + "hem": 4047, + "Ġhy": 4048, + "ĠSer": 4049, + "Ġchest": 4050, + "rict": 4051, + "Ġdinosaur": 4052, + "ĠPlay": 4053, + "met": 4054, + "Ġtid": 4055, + "Ġsigned": 4056, + "Ġfill": 4057, + "enn": 4058, + "ĠSun": 4059, + "ĠHam": 4060, + "ĠAlex": 4061, + "ibility": 4062, + "Ġmarried": 4063, + "Ġcreature": 4064, + "Ġsheep": 4065, + "ĠRob": 4066, + "artment": 4067, + "Ġ500": 4068, + "ĠBattalion": 4069, + "Ġeggs": 4070, + "aks": 4071, + "Ġmi": 4072, + "Ġones": 4073, + "Ġugly": 4074, + "Ġshape": 4075, + "ĠWhite": 4076, + "Ġlower": 4077, + "Ġinj": 4078, + "Ġnerv": 4079, + "acter": 4080, + "ugar": 4081, + "ĠStar": 4082, + "Ġunderstood": 4083, + "Ġcounter": 4084, + "ĠQu": 4085, + "Ġsilver": 4086, + "Ġpicnic": 4087, + "Ġnervous": 4088, + "ĠBra": 4089, + "Ġwriter": 4090, + "Ġsett": 4091, + "BC": 4092, + "Ġnorthern": 4093, + "lected": 4094, + "ĠCong": 4095 + }, + "merges": [ + [ + "Ġ", + "t" + ], + [ + "h", + "e" + ], + [ + "Ġ", + "a" + ], + [ + "Ġ", + "s" + ], + [ + "Ġt", + "he" + ], + [ + "Ġ", + "w" + ], + [ + "n", + "d" + ], + [ + "i", + "n" + ], + [ + "e", + "d" + ], + [ + "e", + "r" + ], + [ + "Ġa", + "nd" + ], + [ + "Ġ", + "b" + ], + [ + "Ġt", + "o" + ], + [ + "r", + "e" + ], + [ + "Ġ", + "o" + ], + [ + "Ġ", + "f" + ], + [ + "i", + "t" + ], + [ + "Ġ", + "h" + ], + [ + "Ġ", + "c" + ], + [ + "a", + "s" + ], + [ + "o", + "u" + ], + [ + "a", + "t" + ], + [ + "Ġ", + "p" + ], + [ + "Ġ", + "d" + ], + [ + "a", + "r" + ], + [ + "i", + "s" + ], + [ + "o", + "n" + ], + [ + "a", + "n" + ], + [ + "Ġ", + "m" + ], + [ + "Ġ", + "l" + ], + [ + "e", + "n" + ], + [ + "in", + "g" + ], + [ + "o", + "r" + ], + [ + "o", + "m" + ], + [ + "Ġ", + "T" + ], + [ + "Ġ", + "he" + ], + [ + "Ġw", + "as" + ], + [ + "e", + "s" + ], + [ + "i", + "l" + ], + [ + "Ġ", + "," + ], + [ + "a", + "l" + ], + [ + "a", + "y" + ], + [ + "Ġ", + "in" + ], + [ + "Ġ", + "g" + ], + [ + "Ġo", + "f" + ], + [ + "i", + "d" + ], + [ + "Ġ", + "n" + ], + [ + "Ġ", + "S" + ], + [ + "Ġt", + "h" + ], + [ + "a", + "d" + ], + [ + "ĠT", + "he" + ], + [ + "Ġ", + "." + ], + [ + "i", + "m" + ], + [ + "l", + "e" + ], + [ + "i", + "c" + ], + [ + "u", + "t" + ], + [ + "o", + "t" + ], + [ + "e", + "t" + ], + [ + "Ġ", + "H" + ], + [ + "Ġ", + "it" + ], + [ + "i", + "r" + ], + [ + "Ġ", + "\"" + ], + [ + "Ġ", + "e" + ], + [ + "Ġs", + "a" + ], + [ + "e", + "l" + ], + [ + "o", + "w" + ], + [ + "v", + "er" + ], + [ + "a", + "m" + ], + [ + "a", + "c" + ], + [ + "i", + "g" + ], + [ + "en", + "t" + ], + [ + "Ġhe", + "r" + ], + [ + "Ġo", + "n" + ], + [ + "u", + "n" + ], + [ + "Ġb", + "e" + ], + [ + "Ġ", + "I" + ], + [ + "Ġs", + "t" + ], + [ + "Ġ", + "r" + ], + [ + "it", + "h" + ], + [ + "Ġ", + "re" + ], + [ + "v", + "e" + ], + [ + "l", + "y" + ], + [ + "Ġw", + "ith" + ], + [ + "ĠH", + "e" + ], + [ + "l", + "d" + ], + [ + "ĠS", + "he" + ], + [ + "i", + "on" + ], + [ + "Ġh", + "a" + ], + [ + "o", + "o" + ], + [ + "s", + "t" + ], + [ + "Ġ", + "L" + ], + [ + "Ġth", + "at" + ], + [ + "Ġ", + "y" + ], + [ + "Ġ", + "u" + ], + [ + "Ġf", + "or" + ], + [ + "Ġ", + "B" + ], + [ + "r", + "i" + ], + [ + "p", + "p" + ], + [ + "ĠThe", + "y" + ], + [ + "Ġh", + "is" + ], + [ + "Ġ", + "A" + ], + [ + "Ġ", + "M" + ], + [ + "k", + "e" + ], + [ + "il", + "y" + ], + [ + "Ġsa", + "id" + ], + [ + "u", + "r" + ], + [ + "Ġp", + "l" + ], + [ + "k", + "ed" + ], + [ + "t", + "ed" + ], + [ + "Ġs", + "he" + ], + [ + "c", + "e" + ], + [ + "Ġa", + "s" + ], + [ + "O", + "n" + ], + [ + "Ġw", + "h" + ], + [ + "Ġs", + "o" + ], + [ + "he", + "r" + ], + [ + "Ġa", + "l" + ], + [ + "e", + "c" + ], + [ + "t", + "er" + ], + [ + "Ġy", + "ou" + ], + [ + "Ġ", + "is" + ], + [ + "Ġh", + "ad" + ], + [ + "o", + "l" + ], + [ + "ver", + "y" + ], + [ + "Ġd", + "ay" + ], + [ + "s", + "e" + ], + [ + "u", + "l" + ], + [ + "Ġa", + "n" + ], + [ + "Ġ", + "1" + ], + [ + "Ġpl", + "ay" + ], + [ + "Ġu", + "p" + ], + [ + "Ġ", + "C" + ], + [ + "Ġthe", + "y" + ], + [ + "Ġs", + "h" + ], + [ + "c", + "h" + ], + [ + "ou", + "ld" + ], + [ + "Ġ", + "@" + ], + [ + "ĠL", + "ily" + ], + [ + "r", + "o" + ], + [ + "T", + "he" + ], + [ + "Ġa", + "t" + ], + [ + "Ġn", + "ot" + ], + [ + "ou", + "nd" + ], + [ + "Ġ", + "k" + ], + [ + "Ġm", + "om" + ], + [ + "a", + "in" + ], + [ + "h", + "t" + ], + [ + "er", + "e" + ], + [ + "m", + "y" + ], + [ + "Ġl", + "i" + ], + [ + "om", + "e" + ], + [ + "Ġn", + "e" + ], + [ + "e", + "nd" + ], + [ + "Ġw", + "ere" + ], + [ + "it", + "t" + ], + [ + "im", + "e" + ], + [ + "r", + "om" + ], + [ + "al", + "l" + ], + [ + "'", + "s" + ], + [ + "o", + "re" + ], + [ + "ac", + "k" + ], + [ + "r", + "a" + ], + [ + "Ġb", + "ut" + ], + [ + "Ġs", + "e" + ], + [ + "Ġha", + "pp" + ], + [ + "il", + "l" + ], + [ + "Ġ", + "J" + ], + [ + "Ġw", + "an" + ], + [ + "Ġt", + "ime" + ], + [ + "u", + "m" + ], + [ + "Ġ", + "'" + ], + [ + "ar", + "d" + ], + [ + "Ġ", + "W" + ], + [ + "v", + "ed" + ], + [ + "ĠI", + "t" + ], + [ + "id", + "e" + ], + [ + "r", + "y" + ], + [ + "Ġthe", + "re" + ], + [ + "Ġ", + "very" + ], + [ + "Ġa", + "re" + ], + [ + "Ġd", + "o" + ], + [ + "itt", + "le" + ], + [ + "-", + "@" + ], + [ + "Ġ@", + "-@" + ], + [ + "u", + "g" + ], + [ + "Ġl", + "ittle" + ], + [ + "a", + "g" + ], + [ + "Ġs", + "m" + ], + [ + "Ġl", + "o" + ], + [ + "Ġe", + "x" + ], + [ + "t", + "h" + ], + [ + "Ġ", + "D" + ], + [ + "Ġb", + "ig" + ], + [ + "Ġhapp", + "y" + ], + [ + "Ġs", + "p" + ], + [ + "u", + "s" + ], + [ + "a", + "ke" + ], + [ + "ri", + "end" + ], + [ + "Ġf", + "riend" + ], + [ + "i", + "f" + ], + [ + "u", + "c" + ], + [ + "Ġsa", + "w" + ], + [ + "es", + "t" + ], + [ + "Ġ", + "Ċ" + ], + [ + "Ġ", + "F" + ], + [ + "i", + "nd" + ], + [ + "Ġthe", + "ir" + ], + [ + "o", + "p" + ], + [ + "On", + "e" + ], + [ + "at", + "ion" + ], + [ + ".", + "\"" + ], + [ + "Ġh", + "im" + ], + [ + "Ġg", + "o" + ], + [ + "Ġ", + "P" + ], + [ + "Ġb", + "y" + ], + [ + "Ġf", + "rom" + ], + [ + "Ġ", + "j" + ], + [ + "Ġa", + "r" + ], + [ + "he", + "n" + ], + [ + "Ġ", + "2" + ], + [ + "Ġb", + "o" + ], + [ + "on", + "g" + ], + [ + "e", + "ar" + ], + [ + "ou", + "g" + ], + [ + "Ġo", + "ut" + ], + [ + "Ġl", + "oo" + ], + [ + "a", + "nd" + ], + [ + "'", + "t" + ], + [ + "am", + "e" + ], + [ + "Ġha", + "ve" + ], + [ + "Ġthe", + "m" + ], + [ + "he", + "d" + ], + [ + "er", + "s" + ], + [ + "Ġ", + "E" + ], + [ + "ig", + "ht" + ], + [ + "On", + "ce" + ], + [ + "!", + "\"" + ], + [ + "Ġto", + "o" + ], + [ + "w", + "ay" + ], + [ + "ĠT", + "im" + ], + [ + "Ġ", + "R" + ], + [ + "e", + "m" + ], + [ + "Ġc", + "on" + ], + [ + "u", + "re" + ], + [ + "el", + "l" + ], + [ + "Ġc", + "l" + ], + [ + "Ġ", + "v" + ], + [ + "ir", + "l" + ], + [ + "Ġup", + "on" + ], + [ + "Ġal", + "l" + ], + [ + "is", + "t" + ], + [ + "u", + "d" + ], + [ + "Ġwan", + "ted" + ], + [ + "Ġ", + "G" + ], + [ + "Ġ", + "N" + ], + [ + "Ġc", + "h" + ], + [ + "Ġd", + "id" + ], + [ + "Ġc", + "ould" + ], + [ + "oo", + "d" + ], + [ + "a", + "b" + ], + [ + "a", + "re" + ], + [ + "o", + "s" + ], + [ + "Ġg", + "irl" + ], + [ + "Ġc", + "an" + ], + [ + "q", + "u" + ], + [ + "Ġp", + "ar" + ], + [ + "Ġk", + "n" + ], + [ + "Ġ", + ")" + ], + [ + "Ġ", + "(" + ], + [ + "Ġc", + "om" + ], + [ + "Ġs", + "c" + ], + [ + "es", + "s" + ], + [ + "on", + "e" + ], + [ + "t", + "her" + ], + [ + "ow", + "n" + ], + [ + "Ġhe", + "l" + ], + [ + "Ġsm", + "il" + ], + [ + "i", + "e" + ], + [ + "un", + "k" + ], + [ + "Ġm", + "an" + ], + [ + "Ġ1", + "9" + ], + [ + "am", + "ed" + ], + [ + "Ġw", + "ent" + ], + [ + "at", + "e" + ], + [ + "Ġw", + "or" + ], + [ + "Ġo", + "r" + ], + [ + "t", + "s" + ], + [ + "al", + "ly" + ], + [ + "Ġn", + "o" + ], + [ + "o", + "c" + ], + [ + "k", + "s" + ], + [ + "a", + "p" + ], + [ + "ĠB", + "en" + ], + [ + "e", + "p" + ], + [ + "Ġhel", + "p" + ], + [ + "Ġa", + "g" + ], + [ + "Ġst", + "ar" + ], + [ + "Ġb", + "ack" + ], + [ + "as", + "t" + ], + [ + "ad", + "e" + ], + [ + "a", + "k" + ], + [ + "u", + "st" + ], + [ + "i", + "es" + ], + [ + "0", + "0" + ], + [ + "Ġfriend", + "s" + ], + [ + "ic", + "e" + ], + [ + "re", + "e" + ], + [ + "Ġw", + "ould" + ], + [ + "Ġ", + "<" + ], + [ + "?", + "\"" + ], + [ + "f", + "ul" + ], + [ + "Ġn", + "amed" + ], + [ + "ou", + "s" + ], + [ + "i", + "ve" + ], + [ + "Ġf", + "un" + ], + [ + "ing", + "s" + ], + [ + "ou", + "t" + ], + [ + "Y", + "ou" + ], + [ + "b", + "er" + ], + [ + "Ġs", + "ome" + ], + [ + "re", + "s" + ], + [ + "Ġt", + "r" + ], + [ + "Ġs", + "ay" + ], + [ + "h", + "ing" + ], + [ + "Ġm", + "e" + ], + [ + "el", + "t" + ], + [ + "Ġwh", + "o" + ], + [ + "Ġf", + "e" + ], + [ + "Ġa", + "b" + ], + [ + "an", + "t" + ], + [ + "Ġl", + "e" + ], + [ + "Ġo", + "ther" + ], + [ + "Ġ", + "One" + ], + [ + "Ġw", + "e" + ], + [ + "s", + "ide" + ], + [ + "Ġli", + "ke" + ], + [ + "Ġp", + "r" + ], + [ + "ir", + "d" + ], + [ + "Ġ", + "un" + ], + [ + "ĠT", + "om" + ], + [ + "Ġg", + "r" + ], + [ + "p", + "l" + ], + [ + "l", + "ow" + ], + [ + "u", + "e" + ], + [ + "c", + "t" + ], + [ + "Ġf", + "elt" + ], + [ + "g", + "et" + ], + [ + "or", + "t" + ], + [ + "Ġar", + "ound" + ], + [ + "Ġlo", + "ved" + ], + [ + "at", + "er" + ], + [ + "Ġm", + "o" + ], + [ + "it", + "ed" + ], + [ + "Ġb", + "r" + ], + [ + "Ġto", + "y" + ], + [ + "ic", + "h" + ], + [ + "Ġas", + "ked" + ], + [ + "ĠTim", + "my" + ], + [ + "Ġsmil", + "ed" + ], + [ + "om", + "et" + ], + [ + "ic", + "k" + ], + [ + "Ġon", + "e" + ], + [ + "Ġm", + "ade" + ], + [ + "u", + "ch" + ], + [ + "i", + "a" + ], + [ + "Ġne", + "w" + ], + [ + "Ġbe", + "c" + ], + [ + "ou", + "r" + ], + [ + "f", + "ter" + ], + [ + "an", + "g" + ], + [ + "Ġw", + "hen" + ], + [ + "ac", + "h" + ], + [ + "Ġloo", + "ked" + ], + [ + "i", + "al" + ], + [ + "Ġin", + "t" + ], + [ + "Ġp", + "ro" + ], + [ + "is", + "h" + ], + [ + "Ġse", + "e" + ], + [ + "a", + "v" + ], + [ + "Ġag", + "ain" + ], + [ + "Ġc", + "ar" + ], + [ + "Ġbo", + "y" + ], + [ + "in", + "e" + ], + [ + "ac", + "e" + ], + [ + "Ġd", + "e" + ], + [ + "u", + "b" + ], + [ + "Ġb", + "ird" + ], + [ + "at", + "ed" + ], + [ + "Ġd", + "ec" + ], + [ + "i", + "v" + ], + [ + "oug", + "h" + ], + [ + "Ġwh", + "at" + ], + [ + "Ġs", + "omet" + ], + [ + "Ġm", + "ake" + ], + [ + "Ġt", + "w" + ], + [ + "get", + "her" + ], + [ + "o", + "nd" + ], + [ + "n", + "ed" + ], + [ + "Ġ", + "You" + ], + [ + "Ġa", + "way" + ], + [ + "Ġf", + "ound" + ], + [ + "ĠB", + "ut" + ], + [ + "L", + "ily" + ], + [ + "it", + "y" + ], + [ + "Ġr", + "an" + ], + [ + "it", + "e" + ], + [ + "Ġthe", + "n" + ], + [ + "Ġto", + "gether" + ], + [ + "i", + "p" + ], + [ + "e", + "w" + ], + [ + "Ġstar", + "ted" + ], + [ + "Ġr", + "o" + ], + [ + "ĠI", + "n" + ], + [ + "Ġ", + "O" + ], + [ + "Ġ", + "K" + ], + [ + ",", + "\"" + ], + [ + "a", + "ve" + ], + [ + "oug", + "ht" + ], + [ + "ou", + "d" + ], + [ + "Ġa", + "d" + ], + [ + "ar", + "y" + ], + [ + "â", + "Ĥ" + ], + [ + "as", + "s" + ], + [ + "Ã", + "¢" + ], + [ + "âĤ", + "¬" + ], + [ + "Ġm", + "ore" + ], + [ + "Ġp", + "ut" + ], + [ + "Ġth", + "an" + ], + [ + "ri", + "ed" + ], + [ + "Ġpar", + "k" + ], + [ + "Ġwan", + "t" + ], + [ + "Ġh", + "ome" + ], + [ + "k", + "ing" + ], + [ + "Ġex", + "c" + ], + [ + "Ġsomet", + "hing" + ], + [ + "Ġsay", + "s" + ], + [ + "ar", + "ed" + ], + [ + "Ġit", + "s" + ], + [ + "Ġab", + "out" + ], + [ + "Ġs", + "ad" + ], + [ + "Ġth", + "is" + ], + [ + "pp", + "ed" + ], + [ + "il", + "e" + ], + [ + "a", + "ug" + ], + [ + "Ġg", + "ood" + ], + [ + "t", + "y" + ], + [ + "Ġb", + "l" + ], + [ + "m", + "ent" + ], + [ + "Ġ", + "en" + ], + [ + "Ġo", + "ver" + ], + [ + "i", + "z" + ], + [ + "Ġwh", + "ich" + ], + [ + "ou", + "n" + ], + [ + "Ġp", + "re" + ], + [ + "oo", + "k" + ], + [ + "Ġint", + "o" + ], + [ + "h", + "at" + ], + [ + "ec", + "t" + ], + [ + "id", + "ed" + ], + [ + "ir", + "st" + ], + [ + "Ġd", + "own" + ], + [ + "f", + "f" + ], + [ + "Ġh", + "ug" + ], + [ + "Ġc", + "o" + ], + [ + "Ġs", + "w" + ], + [ + "Ġg", + "et" + ], + [ + "s", + "o" + ], + [ + "a", + "x" + ], + [ + "Ġplay", + "ing" + ], + [ + "ou", + "se" + ], + [ + "Ġo", + "p" + ], + [ + "i", + "an" + ], + [ + "Ġof", + "f" + ], + [ + "Ġ", + "U" + ], + [ + "Ġw", + "al" + ], + [ + "is", + "e" + ], + [ + "n", + "a" + ], + [ + "n", + "y" + ], + [ + "Ġcon", + "t" + ], + [ + "i", + "re" + ], + [ + "Ġc", + "ame" + ], + [ + "o", + "d" + ], + [ + "Ġe", + "very" + ], + [ + "Ġal", + "so" + ], + [ + "Ġc", + "are" + ], + [ + "ag", + "e" + ], + [ + "Ġ", + "im" + ], + [ + "Ġ", + "â" + ], + [ + "Ġe", + "v" + ], + [ + "Ġf", + "irst" + ], + [ + "Ġsp", + "ec" + ], + [ + "re", + "at" + ], + [ + "ĠS", + "t" + ], + [ + "Ġth", + "ings" + ], + [ + "Ġg", + "ot" + ], + [ + "Ġtw", + "o" + ], + [ + "g", + "e" + ], + [ + "Ġu", + "s" + ], + [ + "a", + "u" + ], + [ + "Ġf", + "ind" + ], + [ + "or", + "d" + ], + [ + "ĠA", + "n" + ], + [ + "Ġâ", + "Ģ" + ], + [ + "p", + "t" + ], + [ + "Ġdec", + "ided" + ], + [ + "Ġw", + "ill" + ], + [ + "il", + "d" + ], + [ + "Ġtoo", + "k" + ], + [ + "Ġp", + "e" + ], + [ + "Ġdo", + "g" + ], + [ + "ot", + "her" + ], + [ + "Ġli", + "ked" + ], + [ + "he", + "re" + ], + [ + "Ġm", + "y" + ], + [ + "Ġexc", + "ited" + ], + [ + "Ġ", + "3" + ], + [ + "Ġh", + "as" + ], + [ + "ar", + "a" + ], + [ + "Ġb", + "et" + ], + [ + "Ġf", + "l" + ], + [ + "Ġyou", + "r" + ], + [ + "uc", + "k" + ], + [ + "Ġfe", + "el" + ], + [ + "Ġ", + "qu" + ], + [ + "nd", + "er" + ], + [ + "Ġ", + "ke" + ], + [ + "en", + "ed" + ], + [ + "ot", + "h" + ], + [ + "way", + "s" + ], + [ + "Ġa", + "c" + ], + [ + "Ġsh", + "ow" + ], + [ + "ig", + "h" + ], + [ + "ud", + "d" + ], + [ + "o", + "g" + ], + [ + "o", + "b" + ], + [ + "al", + "s" + ], + [ + "Ġst", + "r" + ], + [ + "res", + "s" + ], + [ + "Ġin", + "c" + ], + [ + "el", + "y" + ], + [ + "Ġan", + "y" + ], + [ + "Ġo", + "ld" + ], + [ + "Ġb", + "all" + ], + [ + "ol", + "l" + ], + [ + "Ġh", + "ow" + ], + [ + "Ġd", + "ad" + ], + [ + "ab", + "le" + ], + [ + "Ġth", + "ought" + ], + [ + "Ġcom", + "p" + ], + [ + "Ġbe", + "en" + ], + [ + "ion", + "s" + ], + [ + "au", + "se" + ], + [ + "Ġp", + "er" + ], + [ + "Ġsc", + "ared" + ], + [ + "g", + "ed" + ], + [ + "n", + "ing" + ], + [ + "m", + "er" + ], + [ + "Ġal", + "ways" + ], + [ + "ĠC", + "h" + ], + [ + "ic", + "al" + ], + [ + "Ġd", + "is" + ], + [ + "Ġa", + "pp" + ], + [ + "Ġt", + "e" + ], + [ + "Ġa", + "fter" + ], + [ + "Ġa", + "m" + ], + [ + "Ġt", + "ree" + ], + [ + "or", + "y" + ], + [ + "Ġtoy", + "s" + ], + [ + "Ġp", + "o" + ], + [ + "Ġr", + "un" + ], + [ + "an", + "ce" + ], + [ + "Ġdid", + "n" + ], + [ + "The", + "y" + ], + [ + "Ġl", + "ear" + ], + [ + "Ġout", + "side" + ], + [ + "o", + "y" + ], + [ + "as", + "e" + ], + [ + "Ġt", + "ake" + ], + [ + "ĠM", + "om" + ], + [ + "Ġy", + "ear" + ], + [ + "or", + "m" + ], + [ + "Ġw", + "r" + ], + [ + "Ġkn", + "ow" + ], + [ + "Ġl", + "ot" + ], + [ + "ar", + "k" + ], + [ + "Ġe", + "nd" + ], + [ + "f", + "t" + ], + [ + "Ġm", + "uch" + ], + [ + "Ġ2", + "00" + ], + [ + "Ġre", + "m" + ], + [ + "Ġp", + "ic" + ], + [ + "at", + "ch" + ], + [ + "Ġc", + "all" + ], + [ + "Ġman", + "y" + ], + [ + "Ġh", + "o" + ], + [ + "Ġmom", + "my" + ], + [ + "Ġb", + "u" + ], + [ + "an", + "k" + ], + [ + "l", + "l" + ], + [ + "ĠT", + "h" + ], + [ + "Ġl", + "ong" + ], + [ + "Ġc", + "r" + ], + [ + "h", + "n" + ], + [ + "Ġspec", + "ial" + ], + [ + "l", + "es" + ], + [ + "ĠJ", + "o" + ], + [ + "Ġ", + ";" + ], + [ + "oc", + "k" + ], + [ + "ĠS", + "am" + ], + [ + "Ġ", + "V" + ], + [ + "Ġha", + "nd" + ], + [ + "Ġplay", + "ed" + ], + [ + "i", + "ed" + ], + [ + "ĠM", + "ax" + ], + [ + "Ġc", + "ol" + ], + [ + "Ġbec", + "ause" + ], + [ + "Ġu", + "nder" + ], + [ + "Ġre", + "s" + ], + [ + "Ġs", + "k" + ], + [ + "b", + "le" + ], + [ + "Ġh", + "ouse" + ], + [ + "f", + "e" + ], + [ + "Ġe", + "ach" + ], + [ + "Ġ", + "if" + ], + [ + "en", + "ce" + ], + [ + "v", + "ing" + ], + [ + "Ġf", + "in" + ], + [ + "l", + "ed" + ], + [ + "Ġw", + "ater" + ], + [ + "Ġre", + "c" + ], + [ + "Ġl", + "aug" + ], + [ + "Ġsm", + "all" + ], + [ + "Ġim", + "p" + ], + [ + "Ġth", + "r" + ], + [ + "Ġkn", + "ew" + ], + [ + "Ġex", + "pl" + ], + [ + "t", + "il" + ], + [ + "el", + "f" + ], + [ + "er", + "ed" + ], + [ + "w", + "n" + ], + [ + "udd", + "en" + ], + [ + "he", + "s" + ], + [ + "Ġg", + "ave" + ], + [ + "i", + "x" + ], + [ + "ĠW", + "e" + ], + [ + "Ġ2", + "0" + ], + [ + "ig", + "n" + ], + [ + "i", + "ous" + ], + [ + "Ġj", + "ust" + ], + [ + "Ġw", + "a" + ], + [ + "f", + "ore" + ], + [ + "is", + "s" + ], + [ + "w", + "ard" + ], + [ + "Ġs", + "ur" + ], + [ + "an", + "e" + ], + [ + "is", + "hed" + ], + [ + "Ġun", + "til" + ], + [ + "an", + "s" + ], + [ + "um", + "p" + ], + [ + "Ġne", + "ver" + ], + [ + "or", + "ry" + ], + [ + "Ġto", + "ld" + ], + [ + "ar", + "t" + ], + [ + "udden", + "ly" + ], + [ + "or", + "s" + ], + [ + "en", + "s" + ], + [ + "oo", + "l" + ], + [ + "Ġs", + "un" + ], + [ + "Ġg", + "ra" + ], + [ + "a", + "il" + ], + [ + "Ġ", + ":" + ], + [ + "t", + "ing" + ], + [ + "f", + "er" + ], + [ + "g", + "an" + ], + [ + "b", + "ed" + ], + [ + "Ġwh", + "ile" + ], + [ + "Ġcare", + "ful" + ], + [ + "Ġ1", + "8" + ], + [ + "B", + "ut" + ], + [ + "Ġb", + "oth" + ], + [ + "ĠâĢ", + "ĵ" + ], + [ + "Ġd", + "es" + ], + [ + "Ġro", + "om" + ], + [ + "Ġs", + "orry" + ], + [ + "an", + "c" + ], + [ + "ac", + "t" + ], + [ + "ol", + "low" + ], + [ + "Ġt", + "ried" + ], + [ + "p", + "r" + ], + [ + "Ġin", + "side" + ], + [ + "Ġne", + "ed" + ], + [ + "p", + "h" + ], + [ + "ĠH", + "er" + ], + [ + "ur", + "ing" + ], + [ + "v", + "el" + ], + [ + "u", + "p" + ], + [ + "i", + "ver" + ], + [ + "Ġbe", + "fore" + ], + [ + "Ġ", + "4" + ], + [ + "Ġat", + "t" + ], + [ + "Ġloo", + "k" + ], + [ + "m", + "an" + ], + [ + "Ġe", + "at" + ], + [ + "Ġb", + "est" + ], + [ + "Ġpr", + "oud" + ], + [ + ".", + "@" + ], + [ + "Ġ@", + ".@" + ], + [ + "a", + "z" + ], + [ + "in", + "k" + ], + [ + "Ġhe", + "ard" + ], + [ + "Ġcould", + "n" + ], + [ + "Ġ", + "5" + ], + [ + "Ġan", + "im" + ], + [ + "Ġf", + "am" + ], + [ + "Ġs", + "l" + ], + [ + "is", + "ed" + ], + [ + "re", + "n" + ], + [ + "Ġbo", + "x" + ], + [ + "l", + "and" + ], + [ + "Ġon", + "ly" + ], + [ + "v", + "ent" + ], + [ + "Ġcall", + "ed" + ], + [ + "a", + "ir" + ], + [ + "Ġev", + "en" + ], + [ + "it", + "ion" + ], + [ + "d", + "y" + ], + [ + "s", + "s" + ], + [ + "Ġpre", + "t" + ], + [ + "ĠA", + "nd" + ], + [ + "op", + "le" + ], + [ + "ĠJ", + "ack" + ], + [ + "on", + "s" + ], + [ + "b", + "y" + ], + [ + "Ġc", + "le" + ], + [ + "ad", + "y" + ], + [ + "Ġs", + "er" + ], + [ + "ĠE", + "very" + ], + [ + "ation", + "s" + ], + [ + "Ġhug", + "ged" + ], + [ + "ĠB", + "r" + ], + [ + "T", + "om" + ], + [ + "Ġbe", + "ing" + ], + [ + "o", + "se" + ], + [ + "ĠS", + "ara" + ], + [ + "Ġw", + "here" + ], + [ + "Ġth", + "ree" + ], + [ + "w", + "e" + ], + [ + "l", + "ud" + ], + [ + "Ġbe", + "ar" + ], + [ + "Ġf", + "ollow" + ], + [ + "t", + "ure" + ], + [ + "ĠAn", + "na" + ], + [ + "ar", + "m" + ], + [ + "at", + "h" + ], + [ + "am", + "p" + ], + [ + "Ġw", + "ay" + ], + [ + "ul", + "l" + ], + [ + "Ġt", + "ry" + ], + [ + "Ġg", + "ame" + ], + [ + "Ġc", + "at" + ], + [ + "c", + "hed" + ], + [ + "Ġt", + "ur" + ], + [ + "Ġr", + "ed" + ], + [ + "Ġst", + "ill" + ], + [ + "Ġbet", + "ter" + ], + [ + "M", + "om" + ], + [ + "Ġl", + "et" + ], + [ + "as", + "ed" + ], + [ + "Ġthr", + "ough" + ], + [ + "ĠS", + "o" + ], + [ + "Ġh", + "ur" + ], + [ + "ak", + "ing" + ], + [ + "Ġpe", + "ople" + ], + [ + "ĠH", + "is" + ], + [ + "s", + "elf" + ], + [ + "em", + "ber" + ], + [ + "Ġlear", + "ned" + ], + [ + "x", + "t" + ], + [ + "Ġpar", + "t" + ], + [ + ",", + "@" + ], + [ + "Ġ@", + ",@" + ], + [ + "Ġn", + "ice" + ], + [ + "Ġl", + "ist" + ], + [ + "'", + "m" + ], + [ + "Ġs", + "n" + ], + [ + "Ġh", + "igh" + ], + [ + "Ġf", + "r" + ], + [ + "Ġs", + "ong" + ], + [ + "Ġf", + "low" + ], + [ + "g", + "ry" + ], + [ + "Ġ20", + "1" + ], + [ + "Ġk", + "ind" + ], + [ + "a", + "ut" + ], + [ + "Ġcl", + "os" + ], + [ + "Ġc", + "he" + ], + [ + "u", + "pp" + ], + [ + "Ġe", + "ar" + ], + [ + "Ġd", + "on" + ], + [ + "b", + "e" + ], + [ + "Ġbec", + "ame" + ], + [ + "oun", + "t" + ], + [ + "Ġinc", + "lud" + ], + [ + "Ġd", + "if" + ], + [ + "Ġs", + "ec" + ], + [ + "Ġre", + "l" + ], + [ + "T", + "h" + ], + [ + "Ġfam", + "ily" + ], + [ + "iz", + "ed" + ], + [ + "Ġsk", + "y" + ], + [ + "Ġwor", + "k" + ], + [ + "Ġf", + "le" + ], + [ + "Ġlo", + "ve" + ], + [ + "ĠS", + "p" + ], + [ + "Ġin", + "ter" + ], + [ + "c", + "ess" + ], + [ + "Ġn", + "ow" + ], + [ + "Ġus", + "ed" + ], + [ + "in", + "y" + ], + [ + "Ġmo", + "st" + ], + [ + "Y", + "es" + ], + [ + "n", + "g" + ], + [ + "Ġd", + "ra" + ], + [ + "Ġc", + "ome" + ], + [ + "Ġbe", + "aut" + ], + [ + "Ġne", + "ar" + ], + [ + "or", + "n" + ], + [ + "Ġj", + "ump" + ], + [ + "ent", + "s" + ], + [ + "Ġsh", + "ould" + ], + [ + "Ġg", + "l" + ], + [ + "ĠW", + "hen" + ], + [ + "Ġh", + "ard" + ], + [ + "at", + "es" + ], + [ + "ard", + "en" + ], + [ + "d", + "ed" + ], + [ + "Ġf", + "ore" + ], + [ + "Ġli", + "ved" + ], + [ + "H", + "e" + ], + [ + "p", + "er" + ], + [ + "Ġthan", + "ked" + ], + [ + "ĠA", + "s" + ], + [ + "ĠF", + "rom" + ], + [ + "ĠJo", + "hn" + ], + [ + "ĠM", + "ia" + ], + [ + "Ġs", + "ing" + ], + [ + "Ġw", + "ind" + ], + [ + "if", + "ul" + ], + [ + "ir", + "ed" + ], + [ + "e", + "ver" + ], + [ + "Ġg", + "arden" + ], + [ + "Ġlaug", + "hed" + ], + [ + "Ġanim", + "als" + ], + [ + "v", + "es" + ], + [ + "a", + "w" + ], + [ + "r", + "ic" + ], + [ + "am", + "es" + ], + [ + "re", + "am" + ], + [ + "Ġu", + "se" + ], + [ + "ang", + "e" + ], + [ + "I", + "t" + ], + [ + "Ġbeaut", + "iful" + ], + [ + "Ġb", + "ra" + ], + [ + "Ġl", + "oud" + ], + [ + "at", + "her" + ], + [ + "ĠU", + "n" + ], + [ + "Ġyear", + "s" + ], + [ + "Ġre", + "al" + ], + [ + "Ġs", + "et" + ], + [ + "Ġper", + "f" + ], + [ + "Ġ", + "6" + ], + [ + "Ġst", + "ay" + ], + [ + "ou", + "th" + ], + [ + "Ġd", + "oll" + ], + [ + "ĠA", + "l" + ], + [ + "Ġm", + "us" + ], + [ + "m", + "a" + ], + [ + "Ġm", + "on" + ], + [ + "in", + "s" + ], + [ + "Ġlot", + "s" + ], + [ + "Ġa", + "ct" + ], + [ + "Ġcom", + "m" + ], + [ + "Ġgr", + "ound" + ], + [ + "Ġno", + "d" + ], + [ + "Ġhe", + "ad" + ], + [ + "Ġne", + "xt" + ], + [ + "d", + "uc" + ], + [ + "Ġo", + "wn" + ], + [ + "Å", + "ĵ" + ], + [ + "r", + "ed" + ], + [ + "Ġb", + "ad" + ], + [ + "il", + "m" + ], + [ + "Ġf", + "ly" + ], + [ + "Ġb", + "el" + ], + [ + "Ġc", + "ent" + ], + [ + "re", + "w" + ], + [ + "i", + "el" + ], + [ + "Ġ", + "ide" + ], + [ + "Ġre", + "p" + ], + [ + "o", + "in" + ], + [ + "Ġso", + "on" + ], + [ + "ak", + "es" + ], + [ + "Ġg", + "reat" + ], + [ + "Ġsa", + "fe" + ], + [ + "uc", + "y" + ], + [ + "ĠTh", + "is" + ], + [ + "Ġbe", + "gan" + ], + [ + "Ġ", + "7" + ], + [ + "ĠThe", + "n" + ], + [ + "W", + "hen" + ], + [ + "Ġre", + "pl" + ], + [ + "T", + "im" + ], + [ + "Ġs", + "uch" + ], + [ + "Ġop", + "ened" + ], + [ + "op", + "e" + ], + [ + "Ġb", + "ro" + ], + [ + "Ġgo", + "ing" + ], + [ + "Ġcle", + "an" + ], + [ + "Ġl", + "ater" + ], + [ + "Ġdif", + "fer" + ], + [ + "b", + "it" + ], + [ + "ul", + "ar" + ], + [ + "Ġfle", + "w" + ], + [ + "ain", + "ed" + ], + [ + "ul", + "t" + ], + [ + "Ġsh", + "are" + ], + [ + "as", + "on" + ], + [ + "Ġt", + "re" + ], + [ + "Ġe", + "y" + ], + [ + "k", + "ay" + ], + [ + "u", + "ed" + ], + [ + "Ġwal", + "ked" + ], + [ + "Ġ", + "â" + ], + [ + "Ġpl", + "ace" + ], + [ + "Ġke", + "ep" + ], + [ + "Ġf", + "o" + ], + [ + "m", + "e" + ], + [ + "Ġn", + "um" + ], + [ + "Ġre", + "t" + ], + [ + "im", + "es" + ], + [ + "Ġd", + "el" + ], + [ + "Ġbra", + "ve" + ], + [ + "Ġsur", + "pr" + ], + [ + "Ġr", + "ight" + ], + [ + "Ġstr", + "ong" + ], + [ + "il", + "ly" + ], + [ + "Ġe", + "le" + ], + [ + "Ġke", + "pt" + ], + [ + "t", + "ion" + ], + [ + "Ġhur", + "t" + ], + [ + "t", + "on" + ], + [ + "e", + "y" + ], + [ + "Ġ", + "9" + ], + [ + "Ġcon", + "s" + ], + [ + "Ġch", + "ild" + ], + [ + "d", + "er" + ], + [ + "u", + "ff" + ], + [ + "Ġd", + "uring" + ], + [ + "Ġan", + "gry" + ], + [ + "Ġcont", + "in" + ], + [ + "Ġ", + "8" + ], + [ + "ub", + "l" + ], + [ + "ĠM", + "ar" + ], + [ + "Ġ", + "Y" + ], + [ + "Ġst", + "o" + ], + [ + "i", + "b" + ], + [ + "L", + "et" + ], + [ + "we", + "en" + ], + [ + "Ġf", + "ast" + ], + [ + "Ġac", + "c" + ], + [ + "Ġm", + "et" + ], + [ + "Ġimp", + "ort" + ], + [ + "Ġf", + "ilm" + ], + [ + "I", + "n" + ], + [ + "ou", + "p" + ], + [ + "Ġide", + "a" + ], + [ + "Ġs", + "ound" + ], + [ + "le", + "ase" + ], + [ + "th", + "ing" + ], + [ + "Ġad", + "vent" + ], + [ + "Ġcl", + "im" + ], + [ + "ter", + "n" + ], + [ + "ro", + "ss" + ], + [ + "Ġpret", + "ty" + ], + [ + "Ġst", + "ory" + ], + [ + "ac", + "hed" + ], + [ + "um", + "my" + ], + [ + "Ġno", + "ise" + ], + [ + "ĠC", + "an" + ], + [ + "Ġsh", + "iny" + ], + [ + "v", + "en" + ], + [ + "B", + "en" + ], + [ + "Ġm", + "ag" + ], + [ + "Ġch", + "ar" + ], + [ + "Ġdiffer", + "ent" + ], + [ + "or", + "th" + ], + [ + "o", + "on" + ], + [ + "st", + "r" + ], + [ + "Ġc", + "ry" + ], + [ + "iel", + "d" + ], + [ + "Ġl", + "ar" + ], + [ + "ter", + "s" + ], + [ + "Ġbet", + "ween" + ], + [ + "i", + "er" + ], + [ + "Ġrec", + "ord" + ], + [ + "Ġdo", + "or" + ], + [ + "as", + "h" + ], + [ + "is", + "ion" + ], + [ + "e", + "e" + ], + [ + "h", + "ip" + ], + [ + "Ġexpl", + "ore" + ], + [ + "Ġwor", + "ld" + ], + [ + "c", + "c" + ], + [ + "Ġre", + "st" + ], + [ + "Ġfeel", + "ing" + ], + [ + "Ġe", + "ver" + ], + [ + "Ġn", + "ame" + ], + [ + "u", + "ri" + ], + [ + "at", + "t" + ], + [ + "ĠA", + "r" + ], + [ + "ie", + "w" + ], + [ + "Ġm", + "ar" + ], + [ + "u", + "it" + ], + [ + "Ġb", + "ook" + ], + [ + "Ġbu", + "ild" + ], + [ + "ation", + "al" + ], + [ + "Ġp", + "rom" + ], + [ + "Ġb", + "ed" + ], + [ + "Ġimport", + "ant" + ], + [ + "Ġg", + "ive" + ], + [ + "Ġf", + "ood" + ], + [ + "Ġpic", + "ked" + ], + [ + "Ġp", + "os" + ], + [ + "ĠL", + "ucy" + ], + [ + "b", + "r" + ], + [ + "en", + "er" + ], + [ + "Ġre", + "g" + ], + [ + "i", + "ent" + ], + [ + "âĤ¬", + "â" + ], + [ + "Ġf", + "ar" + ], + [ + "Ġt", + "al" + ], + [ + "Ġb", + "re" + ], + [ + "Ġe", + "m" + ], + [ + "Ġpic", + "ture" + ], + [ + "oc", + "ks" + ], + [ + "Ġnod", + "ded" + ], + [ + "W", + "hat" + ], + [ + "Ġa", + "ir" + ], + [ + "n", + "er" + ], + [ + "Ġpl", + "an" + ], + [ + "Ġd", + "r" + ], + [ + "o", + "ice" + ], + [ + "ĠA", + "fter" + ], + [ + "Ġan", + "other" + ], + [ + "Ġqu", + "ick" + ], + [ + "j", + "oy" + ], + [ + "Ġlo", + "c" + ], + [ + "ic", + "ed" + ], + [ + "i", + "et" + ], + [ + "Ġop", + "en" + ], + [ + "id", + "ent" + ], + [ + "ĠB", + "ob" + ], + [ + "on", + "t" + ], + [ + "u", + "al" + ], + [ + "Ġp", + "res" + ], + [ + "en", + "c" + ], + [ + "Ġpo", + "in" + ], + [ + "Ġbl", + "ue" + ], + [ + "Ġ", + "ind" + ], + [ + "ĠM", + "ay" + ], + [ + "N", + "o" + ], + [ + "Ġ", + "ent" + ], + [ + "Ġ", + "00" + ], + [ + "u", + "ally" + ], + [ + "Ġhand", + "s" + ], + [ + "o", + "ve" + ], + [ + "Ġm", + "or" + ], + [ + "it", + "ing" + ], + [ + "re", + "en" + ], + [ + "T", + "hat" + ], + [ + "Ġfore", + "st" + ], + [ + "al", + "e" + ], + [ + "ĠN", + "ew" + ], + [ + "Ġw", + "ell" + ], + [ + "ur", + "y" + ], + [ + "ure", + "s" + ], + [ + "at", + "ing" + ], + [ + "Ġ19", + "9" + ], + [ + "Ġsto", + "pped" + ], + [ + "Ġr", + "ain" + ], + [ + "Ġdo", + "es" + ], + [ + "Ġt", + "ri" + ], + [ + "Ġfor", + "m" + ], + [ + "Ġw", + "at" + ], + [ + "Ġm", + "in" + ], + [ + "Ġf", + "ire" + ], + [ + "Ġs", + "upp" + ], + [ + "Ġwal", + "king" + ], + [ + "Ġr", + "ock" + ], + [ + "ol", + "og" + ], + [ + "ward", + "s" + ], + [ + "Ġp", + "ol" + ], + [ + "Ġapp", + "ear" + ], + [ + "Ġen", + "joy" + ], + [ + "Ġf", + "our" + ], + [ + "Ġloo", + "king" + ], + [ + "Ġey", + "es" + ], + [ + "Ġw", + "atch" + ], + [ + "re", + "t" + ], + [ + "Ġs", + "qu" + ], + [ + "Ġs", + "ub" + ], + [ + "Ġp", + "ain" + ], + [ + "Ġbe", + "h" + ], + [ + "st", + "er" + ], + [ + "Ħ", + "¢" + ], + [ + "âĤ¬â", + "Ħ¢" + ], + [ + "ow", + "er" + ], + [ + "Ġse", + "ason" + ], + [ + "Ġex", + "p" + ], + [ + "Ġmus", + "ic" + ], + [ + "Ġha", + "ving" + ], + [ + "Ġbo", + "at" + ], + [ + "Ġshow", + "ed" + ], + [ + "Ġn", + "ight" + ], + [ + "Ġle", + "ft" + ], + [ + "Ġf", + "av" + ], + [ + "mer", + "ic" + ], + [ + "Ġrem", + "ember" + ], + [ + "Ġb", + "us" + ], + [ + "Ġlist", + "en" + ], + [ + "Ġsec", + "ond" + ], + [ + "Ġto", + "p" + ], + [ + "o", + "st" + ], + [ + "Ġsmil", + "e" + ], + [ + "Ġf", + "ish" + ], + [ + "Ġ", + "/" + ], + [ + "ĠA", + "meric" + ], + [ + "c", + "ri" + ], + [ + "Th", + "ank" + ], + [ + "ĠC", + "om" + ], + [ + "r", + "al" + ], + [ + "Ġpro", + "duc" + ], + [ + "in", + "ce" + ], + [ + "Ġw", + "ond" + ], + [ + "h", + "y" + ], + [ + "Ġtr", + "uck" + ], + [ + "Ġs", + "y" + ], + [ + "le", + "t" + ], + [ + "Ġo", + "ur" + ], + [ + "Ġgra", + "b" + ], + [ + "ill", + "ed" + ], + [ + "are", + "n" + ], + [ + "Ġre", + "ached" + ], + [ + "Ġquick", + "ly" + ], + [ + "Ġl", + "ess" + ], + [ + "ĠA", + "t" + ], + [ + "Ġsl", + "ide" + ], + [ + "Ġy", + "ell" + ], + [ + "Ġv", + "oice" + ], + [ + "ĠS", + "uddenly" + ], + [ + "i", + "ke" + ], + [ + "Ġ", + "z" + ], + [ + "Ġam", + "az" + ], + [ + "Ġme", + "an" + ], + [ + "Ġf", + "ace" + ], + [ + "ot", + "e" + ], + [ + "Ġdis", + "c" + ], + [ + "Ġl", + "and" + ], + [ + "Ġin", + "v" + ], + [ + "S", + "he" + ], + [ + "Ġsa", + "me" + ], + [ + "Ġnot", + "iced" + ], + [ + "ĠL", + "e" + ], + [ + "et", + "er" + ], + [ + "Ġt", + "ell" + ], + [ + "i", + "o" + ], + [ + "Ġv", + "is" + ], + [ + "Ġas", + "s" + ], + [ + "Ġflow", + "ers" + ], + [ + "ver", + "s" + ], + [ + "n", + "s" + ], + [ + "Ġd", + "ist" + ], + [ + "Ġdra", + "w" + ], + [ + "Ġ00", + "0" + ], + [ + "Ġf", + "ell" + ], + [ + "Ġsw", + "e" + ], + [ + "it", + "c" + ], + [ + "Ġp", + "op" + ], + [ + "Ġd", + "ep" + ], + [ + "Ġnum", + "ber" + ], + [ + "Ġrepl", + "ied" + ], + [ + "ĠD", + "ad" + ], + [ + "S", + "uddenly" + ], + [ + "d", + "ay" + ], + [ + "A", + "fter" + ], + [ + "Ġmo", + "ve" + ], + [ + "if", + "ic" + ], + [ + "Ġt", + "ra" + ], + [ + "ĠS", + "ue" + ], + [ + "Ġse", + "en" + ], + [ + "Ġst", + "ore" + ], + [ + "Ġal", + "ong" + ], + [ + "Ġp", + "ass" + ], + [ + "Ġm", + "aking" + ], + [ + "A", + "n" + ], + [ + "g", + "r" + ], + [ + "ab", + "bit" + ], + [ + "Ġf", + "ur" + ], + [ + "ut", + "e" + ], + [ + "in", + "ed" + ], + [ + "Ġe", + "p" + ], + [ + "Ġd", + "ress" + ], + [ + "ic", + "s" + ], + [ + "Ġ", + "On" + ], + [ + "Ġbr", + "other" + ], + [ + "uri", + "ous" + ], + [ + "Ġb", + "it" + ], + [ + "Ġd", + "ro" + ], + [ + "Ġm", + "ay" + ], + [ + "Ġhim", + "self" + ], + [ + "Ġevery", + "one" + ], + [ + "Ġwat", + "ched" + ], + [ + "Ġo", + "b" + ], + [ + "m", + "s" + ], + [ + "Ġr", + "abbit" + ], + [ + "b", + "um" + ], + [ + "Ġw", + "in" + ], + [ + "ĠR", + "e" + ], + [ + "Ġl", + "ight" + ], + [ + "Ġhe", + "ld" + ], + [ + "Ġo", + "kay" + ], + [ + "ch", + "ool" + ], + [ + "i", + "ble" + ], + [ + "by", + "e" + ], + [ + "Ġp", + "ubl" + ], + [ + "Ġs", + "uc" + ], + [ + "Ġst", + "e" + ], + [ + "Ġres", + "p" + ], + [ + "m", + "ore" + ], + [ + "ol", + "ly" + ], + [ + "Ġwal", + "k" + ], + [ + "Ġclos", + "er" + ], + [ + "Ġlo", + "st" + ], + [ + "ug", + "g" + ], + [ + "ĠD", + "e" + ], + [ + "Ġhelp", + "ed" + ], + [ + "an", + "y" + ], + [ + "ig", + "in" + ], + [ + "et", + "s" + ], + [ + "ap", + "er" + ], + [ + "Ġw", + "arm" + ], + [ + "Ġc", + "ap" + ], + [ + "Ġre", + "ad" + ], + [ + "Ġ1", + "0" + ], + [ + "us", + "ed" + ], + [ + "W", + "e" + ], + [ + "Ġd", + "ri" + ], + [ + "Ġg", + "iv" + ], + [ + "id", + "s" + ], + [ + "Ġhe", + "ar" + ], + [ + "Ġagain", + "st" + ], + [ + "Ġte", + "am" + ], + [ + "Ġm", + "il" + ], + [ + "Ġcontin", + "ued" + ], + [ + "Ġ", + "0" + ], + [ + "Ġs", + "ure" + ], + [ + "Ġret", + "ur" + ], + [ + "ĠA", + "ll" + ], + [ + "Ġbird", + "s" + ], + [ + "le", + "ep" + ], + [ + "or", + "ed" + ], + [ + "Ġin", + "f" + ], + [ + "a", + "pp" + ], + [ + "k", + "es" + ], + [ + "Ġst", + "ud" + ], + [ + "Ġf", + "ull" + ], + [ + "Ġle", + "ad" + ], + [ + "L", + "ook" + ], + [ + "Ġfl", + "o" + ], + [ + "Ġgra", + "nd" + ], + [ + "er", + "t" + ], + [ + "S", + "o" + ], + [ + "Ġfor", + "g" + ], + [ + "Ġal", + "bum" + ], + [ + "Ġep", + "is" + ], + [ + "H", + "er" + ], + [ + "s", + "h" + ], + [ + "i", + "am" + ], + [ + "or", + "k" + ], + [ + "Ġhe", + "re" + ], + [ + "in", + "es" + ], + [ + "Ġperf", + "orm" + ], + [ + "ot", + "t" + ], + [ + "Ġgood", + "bye" + ], + [ + "Ġepis", + "od" + ], + [ + "Ġb", + "ar" + ], + [ + "g", + "er" + ], + [ + "it", + "ies" + ], + [ + "Ġc", + "urious" + ], + [ + "Ġar", + "ri" + ], + [ + "aug", + "ht" + ], + [ + "Ġwa", + "it" + ], + [ + "Ġc", + "ook" + ], + [ + "il", + "a" + ], + [ + "Ġst", + "op" + ], + [ + "m", + "ber" + ], + [ + "ĠH", + "ow" + ], + [ + "Ġp", + "ers" + ], + [ + "ĠJ", + "ane" + ], + [ + "re", + "ed" + ], + [ + "le", + "ased" + ], + [ + "Ġw", + "on" + ], + [ + "ĠThe", + "re" + ], + [ + "Ġbr", + "ight" + ], + [ + "Ġany", + "more" + ], + [ + "Ġkn", + "own" + ], + [ + "Ġho", + "ld" + ], + [ + "Ġe", + "l" + ], + [ + "Ġfe", + "w" + ], + [ + "av", + "es" + ], + [ + "p", + "s" + ], + [ + "Ġse", + "ver" + ], + [ + "Ġd", + "ire" + ], + [ + "Ġm", + "ess" + ], + [ + "Ġser", + "ies" + ], + [ + "o", + "ver" + ], + [ + "is", + "y" + ], + [ + "l", + "ing" + ], + [ + "Ġh", + "un" + ], + [ + "Ġchild", + "ren" + ], + [ + "Ġfav", + "or" + ], + [ + "A", + "s" + ], + [ + "Ġw", + "ar" + ], + [ + "Ġre", + "ce" + ], + [ + "Ġc", + "ake" + ], + [ + "Ġbeh", + "ind" + ], + [ + "Ġs", + "ign" + ], + [ + "Ġthe", + "se" + ], + [ + "Ġse", + "es" + ], + [ + "Ġd", + "one" + ], + [ + "ĠE", + "ng" + ], + [ + "Ġchar", + "ac" + ], + [ + "Ġor", + "igin" + ], + [ + "Ġbel", + "ie" + ], + [ + "C", + "an" + ], + [ + "r", + "ow" + ], + [ + "Ġre", + "ally" + ], + [ + "Ġex", + "t" + ], + [ + "Ġsa", + "nd" + ], + [ + "S", + "ara" + ], + [ + "Ġsh", + "o" + ], + [ + "Ġgr", + "ass" + ], + [ + "Ġunder", + "st" + ], + [ + "ĠS", + "h" + ], + [ + "Ġbut", + "ter" + ], + [ + "Ġj", + "oin" + ], + [ + "itc", + "hen" + ], + [ + "Ġhapp", + "ened" + ], + [ + "An", + "na" + ], + [ + "Ġsh", + "ou" + ], + [ + "Ġg", + "u" + ], + [ + "Ġk", + "itchen" + ], + [ + "Ġp", + "aren" + ], + [ + "ĠSp", + "ot" + ], + [ + "Ġt", + "er" + ], + [ + "ĠMom", + "my" + ], + [ + "Ġc", + "ast" + ], + [ + "ain", + "s" + ], + [ + "ĠF", + "l" + ], + [ + "ro", + "g" + ], + [ + "ĠT", + "hat" + ], + [ + "Ġpr", + "in" + ], + [ + "Ġfollow", + "ed" + ], + [ + "Ġ1", + "2" + ], + [ + "Ġcont", + "r" + ], + [ + "Ġwor", + "ked" + ], + [ + "Ġ1", + "6" + ], + [ + "ment", + "s" + ], + [ + "Ġinclud", + "ing" + ], + [ + "u", + "ary" + ], + [ + "ĠW", + "h" + ], + [ + "Ġso", + "ft" + ], + [ + "at", + "ter" + ], + [ + "as", + "ter" + ], + [ + "Ġswe", + "et" + ], + [ + "Ġtr", + "ans" + ], + [ + "J", + "o" + ], + [ + "one", + "y" + ], + [ + "Ġst", + "ick" + ], + [ + "ct", + "ion" + ], + [ + "w", + "here" + ], + [ + "is", + "ter" + ], + [ + "Ġ19", + "8" + ], + [ + "Ġlear", + "n" + ], + [ + "Ġg", + "ener" + ], + [ + "Ġsh", + "ip" + ], + [ + "a", + "j" + ], + [ + "Ġm", + "ill" + ], + [ + "ra", + "nd" + ], + [ + "Ġjump", + "ed" + ], + [ + "av", + "y" + ], + [ + "o", + "ke" + ], + [ + "ic", + "t" + ], + [ + "vel", + "op" + ], + [ + "ac", + "es" + ], + [ + "Ġw", + "ood" + ], + [ + "Ġcon", + "f" + ], + [ + "Ġp", + "ick" + ], + [ + "Ġrun", + "ning" + ], + [ + "ac", + "ed" + ], + [ + "it", + "s" + ], + [ + "Ġear", + "ly" + ], + [ + "Ġto", + "uch" + ], + [ + "Ġadvent", + "ure" + ], + [ + "Ġin", + "st" + ], + [ + "Ġs", + "ide" + ], + [ + "i", + "ally" + ], + [ + "ĠE", + "m" + ], + [ + "Ġp", + "ur" + ], + [ + "Ġ1", + "7" + ], + [ + "Ġgrab", + "bed" + ], + [ + "th", + "ough" + ], + [ + "Ġ", + "Z" + ], + [ + "Ġle", + "g" + ], + [ + "s", + "on" + ], + [ + "ĠL", + "et" + ], + [ + "ĠD", + "o" + ], + [ + "un", + "ny" + ], + [ + "b", + "o" + ], + [ + "Ġwh", + "ite" + ], + [ + "Ġs", + "low" + ], + [ + "Ġcom", + "ing" + ], + [ + "Ġgl", + "ad" + ], + [ + "i", + "ved" + ], + [ + "Ġs", + "chool" + ], + [ + "om", + "an" + ], + [ + "Ġc", + "atch" + ], + [ + "Ġp", + "us" + ], + [ + "Ġab", + "le" + ], + [ + "ĠBr", + "it" + ], + [ + "ĠUn", + "ited" + ], + [ + "Ġm", + "ain" + ], + [ + "am", + "a" + ], + [ + "Ġha", + "ir" + ], + [ + "Ġreal", + "ized" + ], + [ + "un", + "e" + ], + [ + "Ġcl", + "ose" + ], + [ + "Ġre", + "ady" + ], + [ + "Ġfin", + "ished" + ], + [ + "ang", + "er" + ], + [ + "Ġfavor", + "ite" + ], + [ + "Ġth", + "ing" + ], + [ + "end", + "ed" + ], + [ + "ur", + "ed" + ], + [ + "le", + "y" + ], + [ + "Ġh", + "op" + ], + [ + "Ġp", + "aper" + ], + [ + "'", + "re" + ], + [ + "em", + "ent" + ], + [ + "b", + "all" + ], + [ + "Ġ1", + "5" + ], + [ + "at", + "ive" + ], + [ + "e", + "k" + ], + [ + "Ġto", + "w" + ], + [ + "o", + "ber" + ], + [ + "Ġre", + "f" + ], + [ + "Ġlar", + "ge" + ], + [ + "Ġb", + "ow" + ], + [ + "Ġd", + "in" + ], + [ + "Ġh", + "at" + ], + [ + "Ġshou", + "ted" + ], + [ + "ct", + "or" + ], + [ + "Ġsuc", + "cess" + ], + [ + "Ġdes", + "cri" + ], + [ + "c", + "ed" + ], + [ + "ot", + "s" + ], + [ + "Ġcent", + "ury" + ], + [ + "Ġf", + "ix" + ], + [ + "Ġli", + "fe" + ], + [ + "Ġc", + "re" + ], + [ + "Ġs", + "at" + ], + [ + "Ġar", + "t" + ], + [ + "Ġyell", + "ow" + ], + [ + "Ġ", + "est" + ], + [ + "Ġd", + "ark" + ], + [ + "oo", + "ks" + ], + [ + "z", + "y" + ], + [ + "Ġm", + "other" + ], + [ + "Ġl", + "ate" + ], + [ + "Ġat", + "e" + ], + [ + "Ġother", + "s" + ], + [ + "Ġsever", + "al" + ], + [ + "ec", + "ted" + ], + [ + "Ġg", + "reen" + ], + [ + "ĠS", + "c" + ], + [ + "Ġbl", + "ocks" + ], + [ + "Ġl", + "ady" + ], + [ + "Ġparen", + "ts" + ], + [ + "ĠJ", + "en" + ], + [ + "as", + "k" + ], + [ + "ĠâĢ", + "Ķ" + ], + [ + "ĠEvery", + "one" + ], + [ + "er", + "v" + ], + [ + "Ġm", + "iss" + ], + [ + "Ġy", + "ummy" + ], + [ + "Ġg", + "ames" + ], + [ + "Ġcon", + "c" + ], + [ + "or", + "ies" + ], + [ + "Ġfun", + "ny" + ], + [ + "Ġwor", + "d" + ], + [ + "Ġwond", + "er" + ], + [ + "Ġtre", + "es" + ], + [ + "Ġepisod", + "e" + ], + [ + "Ġt", + "ired" + ], + [ + "Ġ1", + "1" + ], + [ + "Ġc", + "ool" + ], + [ + "Ġwh", + "y" + ], + [ + "Ġp", + "h" + ], + [ + "ri", + "es" + ], + [ + "Ġad", + "d" + ], + [ + "k", + "en" + ], + [ + "Ġc", + "ount" + ], + [ + "W", + "ow" + ], + [ + "Ġth", + "in" + ], + [ + "Ġde", + "velop" + ], + [ + "f", + "ly" + ], + [ + "Ġf", + "ield" + ], + [ + "Ġneed", + "ed" + ], + [ + "Ġwor", + "ry" + ], + [ + "at", + "ure" + ], + [ + "ĠI", + "nd" + ], + [ + "Ġc", + "our" + ], + [ + "Ġgr", + "oup" + ], + [ + "Ġc", + "ity" + ], + [ + "Ġp", + "at" + ], + [ + "Ġst", + "and" + ], + [ + "Ġloo", + "ks" + ], + [ + "Ġw", + "ear" + ], + [ + "Ġp", + "ond" + ], + [ + "Ġm", + "ight" + ], + [ + "Ġth", + "ink" + ], + [ + "Ġflow", + "er" + ], + [ + "Ġ19", + "4" + ], + [ + "on", + "y" + ], + [ + "Ġto", + "wn" + ], + [ + "Ġt", + "all" + ], + [ + "Ġgr", + "ow" + ], + [ + "ĠSara", + "h" + ], + [ + "Ġ", + "-" + ], + [ + "ab", + "y" + ], + [ + "ĠB", + "l" + ], + [ + "Ġcol", + "or" + ], + [ + "Ġarri", + "ved" + ], + [ + "Ġde", + "f" + ], + [ + "ĠCh", + "r" + ], + [ + "Ġop", + "er" + ], + [ + "Ġcr", + "it" + ], + [ + "Ġk", + "ids" + ], + [ + "Ġwind", + "ow" + ], + [ + "Ġwith", + "out" + ], + [ + "b", + "ers" + ], + [ + "n", + "ess" + ], + [ + "Ġwa", + "ved" + ], + [ + "el", + "s" + ], + [ + "Ġcl", + "a" + ], + [ + "Ġc", + "ried" + ], + [ + "str", + "uc" + ], + [ + "v", + "iew" + ], + [ + "ĠAmeric", + "an" + ], + [ + "l", + "ess" + ], + [ + "Ġdo", + "ing" + ], + [ + "Ġco", + "ld" + ], + [ + "Ġclim", + "b" + ], + [ + "Ġp", + "ower" + ], + [ + "Ġ", + "ed" + ], + [ + "Ġm", + "um" + ], + [ + "ep", + "t" + ], + [ + "id", + "ge" + ], + [ + "Ġin", + "s" + ], + [ + "Mom", + "my" + ], + [ + "D", + "on" + ], + [ + "j", + "ect" + ], + [ + "ent", + "ly" + ], + [ + "Ġflo", + "or" + ], + [ + "Ġc", + "reat" + ], + [ + "Ġf", + "ight" + ], + [ + "Ġh", + "ill" + ], + [ + "ke", + "y" + ], + [ + "Ġf", + "all" + ], + [ + "a", + "isy" + ], + [ + "Ġ19", + "6" + ], + [ + "ĠC", + "l" + ], + [ + "Ġs", + "it" + ], + [ + "Ġb", + "unny" + ], + [ + "em", + "p" + ], + [ + "Ġbr", + "ought" + ], + [ + "Ġlaug", + "h" + ], + [ + "iver", + "s" + ], + [ + "Ġs", + "im" + ], + [ + "Ġm", + "ed" + ], + [ + "Ġher", + "self" + ], + [ + "ĠI", + "s" + ], + [ + "Ġpr", + "ot" + ], + [ + "Ġre", + "leased" + ], + [ + "Ġsw", + "ing" + ], + [ + "Ġmo", + "ved" + ], + [ + "Ġpro", + "v" + ], + [ + "Ġcar", + "s" + ], + [ + "Ġe", + "ff" + ], + [ + "ro", + "p" + ], + [ + "Ġsurpr", + "ise" + ], + [ + "Ġy", + "ard" + ], + [ + "ĠF", + "r" + ], + [ + "and", + "y" + ], + [ + "Ġho", + "le" + ], + [ + "Tim", + "my" + ], + [ + "id", + "d" + ], + [ + "Ġw", + "all" + ], + [ + "Ġw", + "ished" + ], + [ + "Ġsw", + "im" + ], + [ + "Ġc", + "ut" + ], + [ + "Ġev", + "ent" + ], + [ + "m", + "b" + ], + [ + "Ġenjoy", + "ed" + ], + [ + "Ġb", + "ag" + ], + [ + "ĠC", + "ar" + ], + [ + "Ġdel", + "ic" + ], + [ + "Ġen", + "ough" + ], + [ + "Ġor", + "gan" + ], + [ + "Ġ19", + "7" + ], + [ + "as", + "ure" + ], + [ + "ĠG", + "er" + ], + [ + "Ġs", + "leep" + ], + [ + "Ġth", + "ough" + ], + [ + "Ġcl", + "ass" + ], + [ + "e", + "ad" + ], + [ + "y", + "p" + ], + [ + "Ġhis", + "t" + ], + [ + "ro", + "om" + ], + [ + "Ġh", + "ot" + ], + [ + "or", + "ing" + ], + [ + "il", + "t" + ], + [ + "ĠW", + "ar" + ], + [ + "Ġbu", + "y" + ], + [ + "Ġremember", + "ed" + ], + [ + "Ġf", + "rog" + ], + [ + "Ġm", + "ouse" + ], + [ + "Ġ", + "ice" + ], + [ + "Ġto", + "wards" + ], + [ + "Ġo", + "cc" + ], + [ + "Ġb", + "ooks" + ], + [ + "Ġsp", + "ot" + ], + [ + "i", + "um" + ], + [ + "o", + "ld" + ], + [ + "Ġc", + "ra" + ], + [ + "ut", + "h" + ], + [ + "Ġbl", + "ack" + ], + [ + "re", + "l" + ], + [ + "Ġag", + "reed" + ], + [ + "Ġ", + "es" + ], + [ + "Ġhapp", + "ily" + ], + [ + "Ġb", + "and" + ], + [ + "ell", + "o" + ], + [ + "itt", + "en" + ], + [ + "Ġf", + "air" + ], + [ + "Ġany", + "thing" + ], + [ + "Ġst", + "orm" + ], + [ + "ap", + "e" + ], + [ + "Ġoff", + "ic" + ], + [ + "al", + "th" + ], + [ + "Ġtur", + "ned" + ], + [ + "Jo", + "hn" + ], + [ + "at", + "ely" + ], + [ + "Ġl", + "ine" + ], + [ + "Ġac", + "ross" + ], + [ + "t", + "en" + ], + [ + "Ġk", + "m" + ], + [ + "Ġare", + "a" + ], + [ + "Ġsn", + "ow" + ], + [ + "Ġunderst", + "and" + ], + [ + "u", + "nd" + ], + [ + "Ġcareful", + "ly" + ], + [ + "u", + "es" + ], + [ + "ĠP", + "ar" + ], + [ + "Ġho", + "pped" + ], + [ + "Ġsomet", + "imes" + ], + [ + "Ġt", + "ail" + ], + [ + "Ġwr", + "ong" + ], + [ + "ĠJo", + "e" + ], + [ + "a", + "ur" + ], + [ + "Ġs", + "ix" + ], + [ + "ed", + "dy" + ], + [ + "Ġm", + "akes" + ], + [ + "Ġwr", + "ote" + ], + [ + "ĠW", + "or" + ], + [ + "b", + "ut" + ], + [ + "in", + "a" + ], + [ + "Ġyou", + "ng" + ], + [ + "Ġg", + "un" + ], + [ + "Ġh", + "ig" + ], + [ + "or", + "ted" + ], + [ + "ĠT", + "r" + ], + [ + "id", + "es" + ], + [ + "c", + "ted" + ], + [ + "n", + "ey" + ], + [ + "Ġless", + "on" + ], + [ + "Ġt", + "able" + ], + [ + "Ġcol", + "le" + ], + [ + "ur", + "ch" + ], + [ + "H", + "ello" + ], + [ + "Ġf", + "ive" + ], + [ + "ic", + "y" + ], + [ + "ir", + "t" + ], + [ + "Ġpers", + "on" + ], + [ + "Ġfollow", + "ing" + ], + [ + "ist", + "s" + ], + [ + "ĠBrit", + "ish" + ], + [ + "S", + "am" + ], + [ + "Ġl", + "ast" + ], + [ + "Ġh", + "um" + ], + [ + "Ġc", + "oun" + ], + [ + "Ġbutter", + "fly" + ], + [ + "Ġf", + "ree" + ], + [ + "l", + "o" + ], + [ + "Ġm", + "ix" + ], + [ + "A", + "t" + ], + [ + "in", + "ally" + ], + [ + "ig", + "ned" + ], + [ + "ĠA", + "ust" + ], + [ + "Ġfriend", + "ly" + ], + [ + "aj", + "or" + ], + [ + "Ġmill", + "ion" + ], + [ + "st", + "em" + ], + [ + "Ġday", + "s" + ], + [ + "Ġli", + "kes" + ], + [ + "ĠBen", + "ny" + ], + [ + "c", + "k" + ], + [ + "c", + "le" + ], + [ + "Ġ1", + "3" + ], + [ + "Ġ19", + "5" + ], + [ + "Ġbro", + "ken" + ], + [ + "Ġo", + "w" + ], + [ + "iz", + "e" + ], + [ + "m", + "ed" + ], + [ + "ec", + "ts" + ], + [ + "ther", + "n" + ], + [ + "Ġfin", + "ally" + ], + [ + "or", + "ts" + ], + [ + "Ġtr", + "ain" + ], + [ + "Ġmor", + "ning" + ], + [ + "\"", + "." + ], + [ + "Ġpres", + "ent" + ], + [ + "Ġc", + "ond" + ], + [ + "Ġcharac", + "ter" + ], + [ + "ĠB", + "e" + ], + [ + "Ġde", + "ep" + ], + [ + "Ġsurpr", + "ised" + ], + [ + "Ġ", + "ve" + ], + [ + "Ġm", + "em" + ], + [ + "Ġn", + "orth" + ], + [ + "Ġle", + "aves" + ], + [ + "Ġf", + "illed" + ], + [ + "ĠN", + "ow" + ], + [ + "u", + "z" + ], + [ + "Ġg", + "one" + ], + [ + "it", + "al" + ], + [ + "ĠA", + "ug" + ], + [ + "Ġall", + "ow" + ], + [ + "i", + "pp" + ], + [ + "Ġel", + "se" + ], + [ + "g", + "y" + ], + [ + "Ġcol", + "ors" + ], + [ + "ĠAug", + "ust" + ], + [ + "ĠS", + "ally" + ], + [ + "ag", + "es" + ], + [ + "Ġro", + "ad" + ], + [ + "F", + "rom" + ], + [ + "Ġgo", + "ver" + ], + [ + "Ġt", + "ight" + ], + [ + "Ġsome", + "one" + ], + [ + "Ġst", + "ate" + ], + [ + "e", + "x" + ], + [ + "Ġse", + "ar" + ], + [ + "ĠHow", + "ever" + ], + [ + "Ġb", + "ug" + ], + [ + "Ġp", + "lease" + ], + [ + "Ġse", + "em" + ], + [ + "Ġt", + "reat" + ], + [ + "Ġp", + "upp" + ], + [ + "ĠG", + "rand" + ], + [ + "ĠA", + "d" + ], + [ + "Ġbre", + "ak" + ], + [ + "ĠM", + "c" + ], + [ + "ĠC", + "ol" + ], + [ + "os", + "ed" + ], + [ + "ack", + "s" + ], + [ + "Ġ19", + "1" + ], + [ + "Ġe", + "as" + ], + [ + "ce", + "pt" + ], + [ + "he", + "l" + ], + [ + "Ġwonder", + "ful" + ], + [ + "Ġan", + "n" + ], + [ + "Ġad", + "v" + ], + [ + "Ġwan", + "ts" + ], + [ + "Ġperf", + "ect" + ], + [ + "Ġcons", + "id" + ], + [ + "Ġd", + "anc" + ], + [ + "Ġdes", + "ign" + ], + [ + "uff", + "y" + ], + [ + "ĠD", + "aisy" + ], + [ + "ĠS", + "ept" + ], + [ + "is", + "es" + ], + [ + "Ġhe", + "avy" + ], + [ + ".", + "." + ], + [ + "qu", + "e" + ], + [ + "r", + "ay" + ], + [ + "v", + "ious" + ], + [ + "re", + "et" + ], + [ + "Ġsa", + "il" + ], + [ + "Ġthan", + "k" + ], + [ + "Ġget", + "ting" + ], + [ + "o", + "om" + ], + [ + "Ġas", + "k" + ], + [ + "Ġmom", + "ent" + ], + [ + "Ġco", + "ver" + ], + [ + "it", + "er" + ], + [ + "ĠU", + "S" + ], + [ + "is", + "m" + ], + [ + "Ġc", + "amp" + ], + [ + "Ġfo", + "ot" + ], + [ + "at", + "s" + ], + [ + "Ġan", + "t" + ], + [ + "ĠJ", + "u" + ], + [ + "Ġdelic", + "ious" + ], + [ + "ur", + "al" + ], + [ + "Ġs", + "ince" + ], + [ + "Ġpart", + "ic" + ], + [ + "p", + "ort" + ], + [ + "Ġv", + "ar" + ], + [ + "ĠSept", + "ember" + ], + [ + "if", + "e" + ], + [ + "Ġtry", + "ing" + ], + [ + "Ġcast", + "le" + ], + [ + "g", + "in" + ], + [ + "Ġvis", + "it" + ], + [ + "Ġrece", + "ived" + ], + [ + "Ġsp", + "l" + ], + [ + "Ġ19", + "3" + ], + [ + "Ġl", + "ion" + ], + [ + "Ġ", + "$" + ], + [ + "Ġle", + "ave" + ], + [ + "Ġpar", + "ty" + ], + [ + "Ġd", + "am" + ], + [ + "es", + "e" + ], + [ + "Ġinc", + "re" + ], + [ + "t", + "o" + ], + [ + "ar", + "r" + ], + [ + "Ġr", + "ace" + ], + [ + "Ġli", + "ving" + ], + [ + "Ġstar", + "t" + ], + [ + "Ġal", + "one" + ], + [ + "Ġof", + "ten" + ], + [ + "Ġr", + "oll" + ], + [ + "ĠP", + "l" + ], + [ + "Ġd", + "ream" + ], + [ + "Th", + "is" + ], + [ + "c", + "es" + ], + [ + "Ġr", + "iver" + ], + [ + "Ġj", + "ob" + ], + [ + "Ġdin", + "ner" + ], + [ + "ĠGer", + "man" + ], + [ + "Ã", + "©" + ], + [ + "Ġ1", + "4" + ], + [ + "Ġsp", + "e" + ], + [ + "Ġgover", + "n" + ], + [ + "our", + "s" + ], + [ + "ĠW", + "hat" + ], + [ + "Ġcl", + "ot" + ], + [ + "Ġc", + "a" + ], + [ + "Ġbu", + "ilt" + ], + [ + "i", + "ec" + ], + [ + "t", + "e" + ], + [ + "ĠChr", + "ist" + ], + [ + "ĠSt", + "ates" + ], + [ + "al", + "es" + ], + [ + "J", + "ack" + ], + [ + "The", + "n" + ], + [ + "Ġfe", + "at" + ], + [ + "id", + "ing" + ], + [ + "Ġpicture", + "s" + ], + [ + "Ġth", + "ose" + ], + [ + "Ġte", + "ac" + ], + [ + "Ġ", + "Q" + ], + [ + "an", + "ts" + ], + [ + "ĠJ", + "an" + ], + [ + "ord", + "ing" + ], + [ + "Ġw", + "et" + ], + [ + "Ġsong", + "s" + ], + [ + "Ġorigin", + "al" + ], + [ + "l", + "a" + ], + [ + "Ġsh", + "ort" + ], + [ + "Ġ", + "%" + ], + [ + "Ġm", + "ust" + ], + [ + "ĠL", + "ila" + ], + [ + "Ġp", + "ri" + ], + [ + "Ġrun", + "s" + ], + [ + "un", + "g" + ], + [ + "ag", + "ed" + ], + [ + "ĠWor", + "ld" + ], + [ + "Ġm", + "oney" + ], + [ + "ĠB", + "illy" + ], + [ + "'", + "ll" + ], + [ + "r", + "on" + ], + [ + "al", + "f" + ], + [ + "Ġevery", + "thing" + ], + [ + "Ġgrand", + "ma" + ], + [ + "ĠN", + "orth" + ], + [ + "Ġy", + "es" + ], + [ + "Ġsc", + "ary" + ], + [ + "ĠC", + "on" + ], + [ + "ĠJ", + "une" + ], + [ + "s", + "w" + ], + [ + "Ġd", + "est" + ], + [ + "es", + "ted" + ], + [ + "Ġsm", + "ell" + ], + [ + "Ġtal", + "k" + ], + [ + "Ġamaz", + "ing" + ], + [ + "Ġs", + "outh" + ], + [ + "Ġpupp", + "y" + ], + [ + "Ġm", + "ajor" + ], + [ + "il", + "ity" + ], + [ + "Ġbuild", + "ing" + ], + [ + "un", + "ch" + ], + [ + "Ġp", + "ot" + ], + [ + "an", + "ch" + ], + [ + "Ġp", + "ink" + ], + [ + "Ġfo", + "x" + ], + [ + "Ġstar", + "s" + ], + [ + "ĠCom", + "m" + ], + [ + "ĠK", + "ing" + ], + [ + "i", + "ence" + ], + [ + "pr", + "il" + ], + [ + "et", + "h" + ], + [ + "Ġfly", + "ing" + ], + [ + "Ġstay", + "ed" + ], + [ + "ĠF", + "or" + ], + [ + "Ġbe", + "ach" + ], + [ + "ĠA", + "pril" + ], + [ + "Ġsy", + "stem" + ], + [ + "ĠP", + "r" + ], + [ + "Ġsing", + "le" + ], + [ + "Ġpos", + "s" + ], + [ + "Ġs", + "ister" + ], + [ + "Ġapp", + "ro" + ], + [ + "y", + "l" + ], + [ + "Ġso", + "ld" + ], + [ + "Ġfin", + "al" + ], + [ + "Ġtur", + "n" + ], + [ + "Ġp", + "et" + ], + [ + "ĠT", + "o" + ], + [ + "Ġt", + "ast" + ], + [ + "Ġpubl", + "ic" + ], + [ + "Ġcook", + "ies" + ], + [ + "z", + "e" + ], + [ + "er", + "y" + ], + [ + "Ġd", + "anger" + ], + [ + "Ġp", + "ul" + ], + [ + "iv", + "ision" + ], + [ + "a", + "id" + ], + [ + "is", + "ted" + ], + [ + "ec", + "h" + ], + [ + "iec", + "es" + ], + [ + "Ġclim", + "bed" + ], + [ + "p", + "le" + ], + [ + "Ġhun", + "gry" + ], + [ + "Ġcl", + "oud" + ], + [ + "Ġclot", + "hes" + ], + [ + "Ġm", + "en" + ], + [ + "Ġbec", + "ome" + ], + [ + "Ġwas", + "n" + ], + [ + "H", + "is" + ], + [ + "en", + "e" + ], + [ + "uck", + "y" + ], + [ + "Ġn", + "ec" + ], + [ + "ĠJ", + "im" + ], + [ + "ĠG", + "e" + ], + [ + "Ġpret", + "end" + ], + [ + "ide", + "o" + ], + [ + "Ġb", + "aby" + ], + [ + "Ġr", + "ide" + ], + [ + "Ġs", + "ugg" + ], + [ + "Ġl", + "ed" + ], + [ + "ag", + "ue" + ], + [ + "Ġa", + "v" + ], + [ + "n", + "e" + ], + [ + "en", + "g" + ], + [ + "h", + "am" + ], + [ + "ĠS", + "outh" + ], + [ + "Ġad", + "m" + ], + [ + "Ġdescri", + "bed" + ], + [ + "Ġp", + "ie" + ], + [ + "Ġforg", + "ot" + ], + [ + "ic", + "ks" + ], + [ + "ĠI", + "I" + ], + [ + "Ġr", + "ound" + ], + [ + "ĠAust", + "ral" + ], + [ + "Ġt", + "it" + ], + [ + "ig", + "g" + ], + [ + "iv", + "ely" + ], + [ + "ĠO", + "ct" + ], + [ + "Ġlist", + "ened" + ], + [ + "us", + "h" + ], + [ + "ĠMay", + "be" + ], + [ + "Ġc", + "ur" + ], + [ + "Ġv", + "iew" + ], + [ + "ĠN", + "o" + ], + [ + "Ġinst", + "ead" + ], + [ + "Ġinclud", + "ed" + ], + [ + "Ġ", + "]" + ], + [ + "Ġp", + "ieces" + ], + [ + "ĠE", + "ur" + ], + [ + "l", + "ish" + ], + [ + "us", + "s" + ], + [ + "Ġcomp", + "le" + ], + [ + "le", + "v" + ], + [ + "Ġsmil", + "es" + ], + [ + "b", + "s" + ], + [ + "Ġb", + "att" + ], + [ + "Ġc", + "ir" + ], + [ + "ic", + "ally" + ], + [ + "Ġas", + "ks" + ], + [ + "in", + "ation" + ], + [ + "Ġv", + "ill" + ], + [ + "ĠG", + "r" + ], + [ + "ĠOct", + "ober" + ], + [ + "Ġ", + "[" + ], + [ + "Ġfe", + "et" + ], + [ + "Ġ", + "vers" + ], + [ + "Ġw", + "he" + ], + [ + "if", + "ied" + ], + [ + "M", + "ay" + ], + [ + "Ġre", + "qu" + ], + [ + "Ġb", + "ur" + ], + [ + "Ġd", + "ue" + ], + [ + "Ġj", + "our" + ], + [ + "bo", + "ard" + ], + [ + "Ġsh", + "ar" + ], + [ + "Ġmor", + "al" + ], + [ + "Ġsupp", + "ort" + ], + [ + "i", + "pped" + ], + [ + "Ġdis", + "app" + ], + [ + "Ġp", + "ort" + ], + [ + "Ġd", + "ance" + ], + [ + "Ġre", + "ach" + ], + [ + "Ġar", + "m" + ], + [ + "Ġen", + "g" + ], + [ + "ian", + "s" + ], + [ + "Ġstr", + "ange" + ], + [ + "Ġdad", + "dy" + ], + [ + "a", + "h" + ], + [ + "ak", + "en" + ], + [ + "Ġwa", + "ited" + ], + [ + "ĠJu", + "ly" + ], + [ + "ĠM", + "r" + ], + [ + "if", + "t" + ], + [ + "is", + "on" + ], + [ + "at", + "or" + ], + [ + "Ġp", + "ast" + ], + [ + "Ġm", + "ark" + ], + [ + "Ġclos", + "ed" + ], + [ + "ĠF", + "e" + ], + [ + "up", + "er" + ], + [ + "Ġl", + "ake" + ], + [ + "Ġpul", + "led" + ], + [ + "Ġm", + "outh" + ], + [ + "Ġv", + "al" + ], + [ + "ut", + "ion" + ], + [ + "ir", + "rel" + ], + [ + "Ġb", + "ased" + ], + [ + "g", + "on" + ], + [ + "i", + "ant" + ], + [ + "ac", + "ked" + ], + [ + "Ġde", + "ath" + ], + [ + "Ġ.", + ".." + ], + [ + "el", + "c" + ], + [ + "ens", + "ive" + ], + [ + "Ġh", + "ide" + ], + [ + "Ġc", + "ream" + ], + [ + "Ġword", + "s" + ], + [ + "Ġs", + "illy" + ], + [ + "i", + "od" + ], + [ + "Ġinter", + "est" + ], + [ + "ĠW", + "ill" + ], + [ + "Ġcour", + "se" + ], + [ + "ĠW", + "ith" + ], + [ + "olog", + "y" + ], + [ + "s", + "et" + ], + [ + "Ġb", + "ott" + ], + [ + "Ġh", + "it" + ], + [ + "en", + "se" + ], + [ + "Ġt", + "eddy" + ], + [ + "Ġc", + "e" + ], + [ + "ount", + "ain" + ], + [ + "Ġme", + "et" + ], + [ + "Ġprom", + "ised" + ], + [ + "Ġan", + "sw" + ], + [ + "Ġsh", + "ared" + ], + [ + "Ġretur", + "ned" + ], + [ + "t", + "ain" + ], + [ + "ĠY", + "ork" + ], + [ + "ĠM", + "ary" + ], + [ + "Ġsqu", + "irrel" + ], + [ + "Ġcomp", + "et" + ], + [ + "Ġt", + "aking" + ], + [ + "os", + "p" + ], + [ + "Ġwood", + "s" + ], + [ + "ag", + "er" + ], + [ + "aug", + "h" + ], + [ + "Ġamaz", + "ed" + ], + [ + "Ġ2", + "5" + ], + [ + "ĠJan", + "uary" + ], + [ + "Ġm", + "atch" + ], + [ + "Ġse", + "a" + ], + [ + "May", + "be" + ], + [ + "il", + "ar" + ], + [ + "Ġcl", + "ub" + ], + [ + "Ġfr", + "ont" + ], + [ + "Ġown", + "er" + ], + [ + "Ġtow", + "er" + ], + [ + "y", + "ing" + ], + [ + "Ġwith", + "in" + ], + [ + "Ġsp", + "ark" + ], + [ + "Ġk", + "ing" + ], + [ + "Ġlong", + "er" + ], + [ + "Ġbow", + "l" + ], + [ + "Ġs", + "ent" + ], + [ + "ar", + "s" + ], + [ + "Ġbr", + "ing" + ], + [ + "Ġslow", + "ly" + ], + [ + "Ġc", + "ard" + ], + [ + "ent", + "ion" + ], + [ + "Ġcon", + "struc" + ], + [ + "f", + "ort" + ], + [ + "Ġch", + "ang" + ], + [ + "Ġpro", + "ble" + ], + [ + "Ġbro", + "ke" + ], + [ + "c", + "hes" + ], + [ + "ir", + "ty" + ], + [ + "O", + "h" + ], + [ + "ect", + "ion" + ], + [ + "Ġr", + "a" + ], + [ + "Ġj", + "oy" + ], + [ + "Ġmon", + "th" + ], + [ + "Ġd", + "em" + ], + [ + "ress", + "ed" + ], + [ + "p", + "ar" + ], + [ + "igh", + "b" + ], + [ + "anc", + "es" + ], + [ + "re", + "ad" + ], + [ + "Ġth", + "ird" + ], + [ + "Ġex", + "per" + ], + [ + "Ġpain", + "t" + ], + [ + "e", + "al" + ], + [ + "Ġc", + "up" + ], + [ + "Ġbo", + "dy" + ], + [ + "Ġ3", + "0" + ], + [ + "Ġl", + "ow" + ], + [ + "Ġthr", + "ow" + ], + [ + "ĠTom", + "my" + ], + [ + "Ġhig", + "her" + ], + [ + "ic", + "es" + ], + [ + "Ġne", + "ighb" + ], + [ + "Ġqu", + "est" + ], + [ + "on", + "es" + ], + [ + "ĠDe", + "ce" + ], + [ + "Ġto", + "day" + ], + [ + "ĠA", + "my" + ], + [ + "Ġj", + "u" + ], + [ + "ĠN", + "ove" + ], + [ + "ivers", + "ity" + ], + [ + "ĠNove", + "mber" + ], + [ + "Ġh", + "alf" + ], + [ + "Ġ", + "er" + ], + [ + "Ġappear", + "ed" + ], + [ + "ĠDece", + "mber" + ], + [ + "Ġspec", + "ies" + ], + [ + "ĠMar", + "ch" + ], + [ + "M", + "ax" + ], + [ + "Ġt", + "yp" + ], + [ + "it", + "ions" + ], + [ + "Ġpre", + "vious" + ], + [ + "Ġhelp", + "ing" + ], + [ + "Ġper", + "iod" + ], + [ + "Ġest", + "ab" + ], + [ + "Ġor", + "d" + ], + [ + "Ġv", + "ideo" + ], + [ + "Ġpr", + "act" + ], + [ + "Ġthin", + "ks" + ], + [ + "Ġbig", + "ger" + ], + [ + "Ġmag", + "ical" + ], + [ + "it", + "ch" + ], + [ + "Ġfr", + "uit" + ], + [ + "Ġre", + "view" + ], + [ + "r", + "it" + ], + [ + "iss", + "ion" + ], + [ + "o", + "k" + ], + [ + "Ġc", + "ross" + ], + [ + "Ġf", + "ather" + ], + [ + "ol", + "f" + ], + [ + "Ġdoll", + "s" + ], + [ + "Ġc", + "al" + ], + [ + "Ġc", + "orn" + ], + [ + "ir", + "th" + ], + [ + "Ġfar", + "mer" + ], + [ + "Ġevent", + "ually" + ], + [ + "Ġgovern", + "ment" + ], + [ + "m", + "ost" + ], + [ + "ul", + "ation" + ], + [ + "Ġanim", + "al" + ], + [ + "ion", + "al" + ], + [ + "Ġbr", + "own" + ], + [ + "s", + "c" + ], + [ + "er", + "ing" + ], + [ + "or", + "se" + ], + [ + "Ġke", + "y" + ], + [ + "m", + "ing" + ], + [ + "Ġc", + "andy" + ], + [ + "itt", + "ing" + ], + [ + "Ġor", + "der" + ], + [ + "Ġt", + "imes" + ], + [ + "Ġball", + "oon" + ], + [ + "Ġfur", + "ther" + ], + [ + "Ġto", + "ur" + ], + [ + "og", + "ra" + ], + [ + "um", + "b" + ], + [ + "Ġmo", + "d" + ], + [ + "Ġbelie", + "ve" + ], + [ + "Ġo", + "pp" + ], + [ + "Ġal", + "though" + ], + [ + "Ġresp", + "ect" + ], + [ + "augh", + "ter" + ], + [ + "Ġr", + "ad" + ], + [ + "Ġevery", + "where" + ], + [ + "enc", + "es" + ], + [ + "Ġdisc", + "over" + ], + [ + "Ġ1", + "00" + ], + [ + "uz", + "z" + ], + [ + "p", + "ed" + ], + [ + "ask", + "et" + ], + [ + "f", + "ic" + ], + [ + "Ġso", + "l" + ], + [ + "Ġwor", + "ried" + ], + [ + "Ġrel", + "ie" + ], + [ + "Ġb", + "ike" + ], + [ + "Ġst", + "ories" + ], + [ + "Ġ19", + "2" + ], + [ + "Ġ", + "Â" + ], + [ + "oc", + "ked" + ], + [ + "Ġdanger", + "ous" + ], + [ + "ĠEur", + "ope" + ], + [ + "g", + "g" + ], + [ + "Ġpoin", + "t" + ], + [ + "Ġp", + "ull" + ], + [ + "Ġf", + "aster" + ], + [ + "ĠN", + "ational" + ], + [ + "ate", + "ful" + ], + [ + "o", + "v" + ], + [ + "Ġm", + "ot" + ], + [ + "Ġw", + "elc" + ], + [ + "a", + "ff" + ], + [ + "Ġd", + "uck" + ], + [ + "l", + "er" + ], + [ + "al", + "d" + ], + [ + "Ġdo", + "ctor" + ], + [ + "rop", + "ical" + ], + [ + "i", + "ation" + ], + [ + "Ġh", + "on" + ], + [ + "Ġsec", + "ret" + ], + [ + "ĠS", + "e" + ], + [ + "ĠB", + "y" + ], + [ + "Ġgr", + "ateful" + ], + [ + "Ġexpl", + "ained" + ], + [ + "a", + "e" + ], + [ + "ĠP", + "h" + ], + [ + "O", + "K" + ], + [ + "in", + "ess" + ], + [ + "Ġprin", + "cess" + ], + [ + "O", + "kay" + ], + [ + "ĠR", + "o" + ], + [ + "Ġbl", + "ank" + ], + [ + "r", + "ing" + ], + [ + "Ġnear", + "by" + ], + [ + "ĠEng", + "land" + ], + [ + "Ġe", + "ight" + ], + [ + "an", + "a" + ], + [ + "Ġro", + "le" + ], + [ + "Ġa", + "uth" + ], + [ + "Ġk", + "iss" + ], + [ + "Ġmo", + "der" + ], + [ + "Ġp", + "en" + ], + [ + "s", + "p" + ], + [ + "ĠR", + "iver" + ], + [ + "alth", + "y" + ], + [ + "Ġw", + "ag" + ], + [ + "it", + "ary" + ], + [ + "Ġcar", + "ry" + ], + [ + "d", + "om" + ], + [ + "Ġis", + "land" + ], + [ + "Ġqu", + "iet" + ], + [ + "in", + "t" + ], + [ + "ĠC", + "oun" + ], + [ + "Ġteac", + "her" + ], + [ + "ro", + "duc" + ], + [ + "Ġloc", + "al" + ], + [ + "u", + "se" + ], + [ + "Ġt", + "akes" + ], + [ + "uc", + "ks" + ], + [ + "Ġste", + "pped" + ], + [ + "Ġpo", + "st" + ], + [ + "Ġhop", + "ed" + ], + [ + "i", + "or" + ], + [ + "Ġis", + "s" + ], + [ + "or", + "row" + ], + [ + "ĠM", + "an" + ], + [ + "ro", + "y" + ], + [ + "ĠO", + "r" + ], + [ + "it", + "her" + ], + [ + "Ġ201", + "0" + ], + [ + "ain", + "ing" + ], + [ + "Ġf", + "arm" + ], + [ + "Ġwr", + "itten" + ], + [ + "Ġdra", + "gon" + ], + [ + "Ġch", + "air" + ], + [ + "Ġst", + "at" + ], + [ + "ĠE", + "d" + ], + [ + "Ġcry", + "ing" + ], + [ + "im", + "ed" + ], + [ + "ĠC", + "ity" + ], + [ + "ub", + "b" + ], + [ + "Ġus", + "ing" + ], + [ + "in", + "ing" + ], + [ + "Ġhe", + "art" + ], + [ + "Ġplay", + "er" + ], + [ + "lev", + "ision" + ], + [ + "pp", + "ing" + ], + [ + "Ġdro", + "pped" + ], + [ + "Ġsim", + "ilar" + ], + [ + "ĠGe", + "or" + ], + [ + "Ġd", + "aughter" + ], + [ + "Ġl", + "aw" + ], + [ + "Ġtr", + "ad" + ], + [ + "Ġtr", + "ack" + ], + [ + "Ġwe", + "ek" + ], + [ + "iv", + "es" + ], + [ + "n", + "am" + ], + [ + "is", + "ing" + ], + [ + "Ġmon", + "key" + ], + [ + "Ġcar", + "r" + ], + [ + "Ġpop", + "ular" + ], + [ + "Ġb", + "asket" + ], + [ + "m", + "p" + ], + [ + "ou", + "ble" + ], + [ + "ĠJ", + "ill" + ], + [ + "Ġcomm", + "on" + ], + [ + "a", + "ul" + ], + [ + "Ġcolor", + "ful" + ], + [ + "ĠS", + "ome" + ], + [ + "Ġtw", + "ins" + ], + [ + "Ġcomp", + "any" + ], + [ + "Ġb", + "irth" + ], + [ + "Ġpie", + "ce" + ], + [ + "Ġbel", + "ong" + ], + [ + "S", + "ure" + ], + [ + "as", + "ing" + ], + [ + "Ġhow", + "ever" + ], + [ + "ed", + "er" + ], + [ + "Ġth", + "rew" + ], + [ + "ĠW", + "est" + ], + [ + "Ġf", + "ig" + ], + [ + "Ġsm", + "art" + ], + [ + "Ġcom", + "b" + ], + [ + "Ġob", + "s" + ], + [ + "Ġgiv", + "en" + ], + [ + "Ġpro", + "p" + ], + [ + "Ġpus", + "hed" + ], + [ + "av", + "ing" + ], + [ + "Ġrecord", + "ed" + ], + [ + "Ġadd", + "ition" + ], + [ + "H", + "i" + ], + [ + "ĠD", + "uring" + ], + [ + "Ġ200", + "8" + ], + [ + "Ġeat", + "ing" + ], + [ + "om", + "in" + ], + [ + "ĠM", + "olly" + ], + [ + "a", + "f" + ], + [ + "ud", + "e" + ], + [ + "W", + "hy" + ], + [ + "Ġar", + "ch" + ], + [ + "Ġd", + "irty" + ], + [ + "Ġm", + "ach" + ], + [ + "b", + "ow" + ], + [ + "o", + "le" + ], + [ + "Ġb", + "uck" + ], + [ + "Ġcount", + "ry" + ], + [ + "al", + "y" + ], + [ + "we", + "et" + ], + [ + "l", + "u" + ], + [ + "pp", + "er" + ], + [ + "Ġconsid", + "ered" + ], + [ + "Ġpartic", + "ular" + ], + [ + "Ġt", + "aken" + ], + [ + "Ġcomm", + "and" + ], + [ + "Ġsing", + "ing" + ], + [ + "Ġpol", + "it" + ], + [ + "ĠE", + "l" + ], + [ + "Ġd", + "ry" + ], + [ + "ĠM", + "ich" + ], + [ + "Ġw", + "ide" + ], + [ + "ren", + "ch" + ], + [ + "y", + "ard" + ], + [ + "Ġ200", + "9" + ], + [ + "Ġg", + "ent" + ], + [ + "Ġsh", + "op" + ], + [ + "Ġad", + "ded" + ], + [ + "Ġam", + "ong" + ], + [ + "Ġsp", + "ent" + ], + [ + "pl", + "ay" + ], + [ + "Ġtur", + "ns" + ], + [ + "Ġsh", + "ap" + ], + [ + "Ġen", + "c" + ], + [ + "ĠS", + "m" + ], + [ + "Ġfor", + "mer" + ], + [ + "Ġsuccess", + "ful" + ], + [ + "Ġw", + "oman" + ], + [ + "Ġ2", + "1" + ], + [ + "Ġs", + "our" + ], + [ + "Ġp", + "ig" + ], + [ + "Ġin", + "it" + ], + [ + "Ġn", + "et" + ], + [ + "Ġfeel", + "s" + ], + [ + "Ġhist", + "ory" + ], + [ + "y", + "le" + ], + [ + "Ġfl", + "ag" + ], + [ + "it", + "ive" + ], + [ + "gr", + "ound" + ], + [ + "es", + "tern" + ], + [ + "ĠA", + "b" + ], + [ + "Ġal", + "most" + ], + [ + "Ġt", + "en" + ], + [ + "Ġar", + "ms" + ], + [ + "Ġbr", + "anch" + ], + [ + "c", + "ial" + ], + [ + "Ġn", + "est" + ], + [ + "Ġb", + "ath" + ], + [ + "Ġst", + "uck" + ], + [ + "Ġacc", + "ident" + ], + [ + "Ġmag", + "ic" + ], + [ + "Ġup", + "set" + ], + [ + "Ġon", + "ce" + ], + [ + "ĠB", + "att" + ], + [ + "Ġle", + "vel" + ], + [ + "Ġnec", + "k" + ], + [ + "Ġgent", + "le" + ], + [ + "Ġs", + "on" + ], + [ + "Ġw", + "est" + ], + [ + "Ġr", + "u" + ], + [ + "ĠFl", + "uffy" + ], + [ + "Ġf", + "act" + ], + [ + "Ġd", + "eter" + ], + [ + "Ġe", + "ast" + ], + [ + "Ġcr", + "ay" + ], + [ + "Ġcir", + "c" + ], + [ + "u", + "ce" + ], + [ + "Ġc", + "ou" + ], + [ + "ri", + "but" + ], + [ + "Ġdire", + "ct" + ], + [ + "t", + "le" + ], + [ + "Ġvers", + "ion" + ], + [ + "Ġn", + "ap" + ], + [ + "Ġc", + "aught" + ], + [ + "Ġp", + "ath" + ], + [ + "ĠCh", + "ar" + ], + [ + "ĠEng", + "lish" + ], + [ + "p", + "ite" + ], + [ + "Ġser", + "v" + ], + [ + "Ġst", + "ri" + ], + [ + "Ġwould", + "n" + ], + [ + "Ġvill", + "age" + ], + [ + "Ġmon", + "ster" + ], + [ + "Ġs", + "ang" + ], + [ + "Ġgo", + "ld" + ], + [ + "Ġdif", + "fic" + ], + [ + "Ġcom", + "es" + ], + [ + "Ġpubl", + "ished" + ], + [ + "Ġseem", + "ed" + ], + [ + "Ġl", + "on" + ], + [ + "Ġli", + "ve" + ], + [ + "Ġtre", + "asure" + ], + [ + "Ġcomp", + "let" + ], + [ + "Ġto", + "t" + ], + [ + "Ġm", + "ine" + ], + [ + "Ġhapp", + "en" + ], + [ + "Ġc", + "or" + ], + [ + "Ġl", + "ay" + ], + [ + "n", + "el" + ], + [ + "os", + "aur" + ], + [ + "Ġsho", + "es" + ], + [ + "Ġw", + "ings" + ], + [ + "Ġr", + "ocks" + ], + [ + "Ġe", + "qu" + ], + [ + "ep", + "end" + ], + [ + "Ġow", + "l" + ], + [ + "Ġt", + "est" + ], + [ + "Ġre", + "lease" + ], + [ + "ce", + "an" + ], + [ + "iv", + "al" + ], + [ + "idd", + "le" + ], + [ + "Ġdro", + "ve" + ], + [ + "Ġf", + "it" + ], + [ + "ĠD", + "ivision" + ], + [ + "Ġfair", + "y" + ], + [ + "ric", + "ane" + ], + [ + "a", + "i" + ], + [ + "g", + "es" + ], + [ + "Ġwho", + "le" + ], + [ + "Ġstr", + "uc" + ], + [ + "Ġcle", + "ar" + ], + [ + "Ġmoder", + "n" + ], + [ + "Ġb", + "ite" + ], + [ + "ĠF", + "rench" + ], + [ + "oun", + "ced" + ], + [ + "ĠG", + "u" + ], + [ + "Ġpe", + "ace" + ], + [ + "ra", + "ft" + ], + [ + "ĠB", + "ar" + ], + [ + "Ġadvent", + "ures" + ], + [ + "Ġpos", + "ition" + ], + [ + "Ġm", + "at" + ], + [ + "Ġor", + "ange" + ], + [ + "Ġlon", + "ely" + ], + [ + "Ġp", + "ock" + ], + [ + "ut", + "es" + ], + [ + "Ġno", + "vel" + ], + [ + "Ġwelc", + "ome" + ], + [ + "Ġv", + "ict" + ], + [ + "os", + "s" + ], + [ + "Ġdest", + "roy" + ], + [ + "Ġte", + "levision" + ], + [ + "Ġem", + "b" + ], + [ + "v", + "ely" + ], + [ + "Ġfor", + "get" + ], + [ + "oin", + "ted" + ], + [ + "Ġrain", + "bow" + ], + [ + "Ġblank", + "et" + ], + [ + "i", + "que" + ], + [ + "Ġs", + "uddenly" + ], + [ + "Ġl", + "unch" + ], + [ + "Ġv", + "ol" + ], + [ + "Ġatt", + "ack" + ], + [ + "Ġw", + "ish" + ], + [ + "Ġ200", + "7" + ], + [ + "ĠCan", + "ad" + ], + [ + "Ġre", + "fer" + ], + [ + "Ġsound", + "s" + ], + [ + "Ġhum", + "an" + ], + [ + "p", + "ec" + ], + [ + "res", + "ent" + ], + [ + "ĠWh", + "ile" + ], + [ + "Ġcla", + "pped" + ], + [ + "i", + "k" + ], + [ + "ĠN", + "e" + ], + [ + "Ġno", + "ises" + ], + [ + "Ġwr", + "ite" + ], + [ + "Ġh", + "ours" + ], + [ + "Ġsw", + "ings" + ], + [ + "gr", + "am" + ], + [ + "le", + "br" + ], + [ + "Ġbe", + "e" + ], + [ + "Ġauth", + "or" + ], + [ + "ĠD", + "av" + ], + [ + "Ġnot", + "hing" + ], + [ + "Ġar", + "g" + ], + [ + "Ġear", + "l" + ], + [ + "S", + "t" + ], + [ + "Ġp", + "ress" + ], + [ + "od", + "y" + ], + [ + "Ġproduc", + "ed" + ], + [ + "Ġtra", + "vel" + ], + [ + "e", + "en" + ], + [ + "er", + "n" + ], + [ + "Ġm", + "ist" + ], + [ + "Ġe", + "gg" + ], + [ + "Ġinclud", + "e" + ], + [ + "br", + "uary" + ], + [ + "ĠFe", + "bruary" + ], + [ + "s", + "el" + ], + [ + "M", + "ia" + ], + [ + "re", + "amed" + ], + [ + "is", + "hing" + ], + [ + "Ġfor", + "ward" + ], + [ + "ear", + "s" + ], + [ + "ĠE", + "ar" + ], + [ + "Ġimp", + "ro" + ], + [ + "Ġpass", + "ed" + ], + [ + "ogra", + "ph" + ], + [ + "Ġcomm", + "un" + ], + [ + "Ġcontr", + "ol" + ], + [ + "Ġ2", + "3" + ], + [ + "Ġele", + "ph" + ], + [ + "uit", + "ar" + ], + [ + "Ġce", + "lebr" + ], + [ + "Ġdeter", + "m" + ], + [ + "ĠC", + "r" + ], + [ + "Ġcare", + "er" + ], + [ + "Ġwr", + "iting" + ], + [ + "l", + "ine" + ], + [ + "Ġs", + "um" + ], + [ + "ab", + "ly" + ], + [ + "ĠSt", + "ate" + ], + [ + "Ġche", + "ered" + ], + [ + "ĠCom", + "p" + ], + [ + "Ġs", + "uff" + ], + [ + "Ġp", + "ra" + ], + [ + "Ġwor", + "king" + ], + [ + "Ġocc", + "ur" + ], + [ + "Ġl", + "im" + ], + [ + "cc", + "ording" + ], + [ + "Ġpro", + "f" + ], + [ + "Ġinv", + "ol" + ], + [ + "Ġ2", + "2" + ], + [ + "Ġch", + "urch" + ], + [ + "im", + "ent" + ], + [ + "oo", + "se" + ], + [ + "ĠP", + "ark" + ], + [ + "Ġretur", + "n" + ], + [ + "ĠEm", + "ma" + ], + [ + "Ġsear", + "ch" + ], + [ + "F", + "inally" + ], + [ + "W", + "h" + ], + [ + "er", + "ry" + ], + [ + "Ġa", + "p" + ], + [ + "Ġim", + "ag" + ], + [ + "iet", + "y" + ], + [ + "n", + "al" + ], + [ + "Ġd", + "et" + ], + [ + "ĠThe", + "se" + ], + [ + "Ġon", + "to" + ], + [ + "Ġl", + "a" + ], + [ + "ĠSt", + "e" + ], + [ + "Ġdri", + "ver" + ], + [ + "w", + "ork" + ], + [ + "Ġa", + "ff" + ], + [ + "Ġf", + "ence" + ], + [ + "Ġmem", + "bers" + ], + [ + "Ġr", + "out" + ], + [ + "Ġco", + "st" + ], + [ + "og", + "n" + ], + [ + "Ġhold", + "ing" + ], + [ + "Ġshe", + "l" + ], + [ + "Ġes", + "c" + ], + [ + "L", + "ila" + ], + [ + "Ġa", + "f" + ], + [ + "n", + "ings" + ], + [ + "Ġexpl", + "oring" + ], + [ + "Ġg", + "en" + ], + [ + "Ġw", + "ave" + ], + [ + "ree", + "k" + ], + [ + "Ġ", + "X" + ], + [ + "ĠT", + "V" + ], + [ + "ĠR", + "ed" + ], + [ + "Ġlar", + "g" + ], + [ + "as", + "ted" + ], + [ + "ĠM", + "y" + ], + [ + "Ġde", + "fe" + ], + [ + "Ġestab", + "l" + ], + [ + "Ġw", + "ise" + ], + [ + "Ġpo", + "or" + ], + [ + "Ġgiv", + "es" + ], + [ + "Ġ2", + "4" + ], + [ + "Ġmil", + "itary" + ], + [ + "ĠDad", + "dy" + ], + [ + "Ġto", + "m" + ], + [ + "at", + "ic" + ], + [ + "ĠD", + "on" + ], + [ + "ĠWill", + "iam" + ], + [ + "se", + "qu" + ], + [ + "is", + "c" + ], + [ + "Ġm", + "ad" + ], + [ + "Ġno", + "se" + ], + [ + "Ġcar", + "ried" + ], + [ + "Ġproduc", + "tion" + ], + [ + "id", + "er" + ], + [ + "el", + "ly" + ], + [ + "Ġhug", + "s" + ], + [ + "Ġg", + "ift" + ], + [ + "amp", + "ions" + ], + [ + "Ġc", + "oll" + ], + [ + "Ġp", + "uzz" + ], + [ + "Ġd", + "iv" + ], + [ + "ad", + "ow" + ], + [ + "ic", + "tion" + ], + [ + "Ġc", + "ave" + ], + [ + "ĠM", + "in" + ], + [ + "Ġback", + "yard" + ], + [ + "ust", + "r" + ], + [ + "Ġ201", + "1" + ], + [ + "Ġinf", + "lu" + ], + [ + "Ġjour", + "ney" + ], + [ + "Ġs", + "oup" + ], + [ + "Ġst", + "reet" + ], + [ + "st", + "it" + ], + [ + "Ġ19", + "0" + ], + [ + "ĠMc", + "C" + ], + [ + "Ġpock", + "et" + ], + [ + "Ġs", + "il" + ], + [ + "Ġb", + "ought" + ], + [ + "Ġc", + "ell" + ], + [ + "om", + "en" + ], + [ + "Ġ2", + "6" + ], + [ + "Ġ200", + "6" + ], + [ + "Ġrec", + "ogn" + ], + [ + "Ġs", + "al" + ], + [ + "ad", + "es" + ], + [ + "if", + "f" + ], + [ + "ec", + "hn" + ], + [ + "Ġ201", + "2" + ], + [ + "Ġf", + "ail" + ], + [ + "ick", + "et" + ], + [ + "Ġsw", + "am" + ], + [ + "Ġtot", + "al" + ], + [ + "Ġs", + "ick" + ], + [ + "itt", + "ens" + ], + [ + "Ġco", + "in" + ], + [ + "end", + "ing" + ], + [ + "Ġres", + "ult" + ], + [ + "Ġcrit", + "ic" + ], + [ + "Ġes", + "pec" + ], + [ + "Ġespec", + "ially" + ], + [ + "on", + "om" + ], + [ + "Ġn", + "aught" + ], + [ + "itt", + "y" + ], + [ + "ra", + "id" + ], + [ + "or", + "thern" + ], + [ + "Ġst", + "ated" + ], + [ + "ĠC", + "ent" + ], + [ + "Ġcre", + "ated" + ], + [ + "Ġfight", + "ing" + ], + [ + "Ġh", + "orse" + ], + [ + "as", + "es" + ], + [ + "ĠT", + "w" + ], + [ + "Ġcan", + "n" + ], + [ + "Ġ", + "&" + ], + [ + "Ġsay", + "ing" + ], + [ + "Ġtit", + "le" + ], + [ + "Ġb", + "le" + ], + [ + "ou", + "thern" + ], + [ + "am", + "b" + ], + [ + "Ġwe", + "e" + ], + [ + "Ġb", + "en" + ], + [ + "Ġsh", + "ook" + ], + [ + "Ġrep", + "orted" + ], + [ + "Ġnaught", + "y" + ], + [ + "m", + "en" + ], + [ + "Ġs", + "elf" + ], + [ + "Ġw", + "ild" + ], + [ + "Ġ2", + "8" + ], + [ + "ĠG", + "ener" + ], + [ + "Ġch", + "ange" + ], + [ + "Ġst", + "yle" + ], + [ + "ap", + "an" + ], + [ + "c", + "l" + ], + [ + "Ġt", + "iny" + ], + [ + "it", + "es" + ], + [ + "ĠC", + "ome" + ], + [ + "Ġapp", + "le" + ], + [ + "Ġb", + "an" + ], + [ + "ĠS", + "ong" + ], + [ + "Ġwh", + "ist" + ], + [ + "um", + "e" + ], + [ + "Ġres", + "ul" + ], + [ + "Ġd", + "ied" + ], + [ + "Ġm", + "ail" + ], + [ + "Ġme", + "ant" + ], + [ + "i", + "ers" + ], + [ + "Ġpl", + "aces" + ], + [ + "Ġk", + "ite" + ], + [ + "Ġint", + "roduc" + ], + [ + "Ġr", + "ub" + ], + [ + "Ġw", + "oke" + ], + [ + "Ġp", + "ay" + ], + [ + "ĠBr", + "own" + ], + [ + "osp", + "ital" + ], + [ + "he", + "ad" + ], + [ + "ĠJ", + "apan" + ], + [ + "Ġbus", + "y" + ], + [ + "Ġstruc", + "ture" + ], + [ + "ie", + "f" + ], + [ + "Ġpoin", + "ted" + ], + [ + "Ġwatch", + "ing" + ], + [ + "Ġs", + "uper" + ], + [ + "ĠA", + "f" + ], + [ + "ill", + "a" + ], + [ + "ĠUn", + "iversity" + ], + [ + "Ġdiffic", + "ult" + ], + [ + "Ġw", + "ife" + ], + [ + "Ġhug", + "e" + ], + [ + "ĠP", + "ol" + ], + [ + "Ġro", + "b" + ], + [ + "Ġ201", + "3" + ], + [ + "ĠLe", + "ague" + ], + [ + "v", + "al" + ], + [ + "Ġrep", + "resent" + ], + [ + "Ġaf", + "raid" + ], + [ + "Ġc", + "op" + ], + [ + "ĠM", + "e" + ], + [ + "Ġex", + "am" + ], + [ + "Ġs", + "itting" + ], + [ + "ĠThe", + "ir" + ], + [ + "ĠA", + "m" + ], + [ + "ĠAt", + "l" + ], + [ + "Ġj", + "ar" + ], + [ + "air", + "s" + ], + [ + "Ġreg", + "ular" + ], + [ + "Ġmin", + "utes" + ], + [ + "Ġship", + "s" + ], + [ + "ĠGrand", + "ma" + ], + [ + "L", + "ater" + ], + [ + "em", + "pt" + ], + [ + "Ġhist", + "or" + ], + [ + "sel", + "ves" + ], + [ + "ĠJ", + "ames" + ], + [ + "Ġab", + "ove" + ], + [ + "ir", + "on" + ], + [ + "ld", + "er" + ], + [ + "ĠJ", + "ust" + ], + [ + "Ġben", + "ch" + ], + [ + "Ġju", + "ice" + ], + [ + "A", + "nd" + ], + [ + "Ġe", + "ither" + ], + [ + "Ġsign", + "ific" + ], + [ + "ĠR", + "oman" + ], + [ + "Ġ5", + "0" + ], + [ + "ar", + "n" + ], + [ + "Ġg", + "ather" + ], + [ + "Ġsh", + "r" + ], + [ + "Ġrem", + "ained" + ], + [ + "Ġbe", + "gin" + ], + [ + "Ġse", + "par" + ], + [ + "B", + "ob" + ], + [ + "D", + "o" + ], + [ + "Ġto", + "uc" + ], + [ + "ress", + "ion" + ], + [ + "ren", + "t" + ], + [ + "ĠSo", + "on" + ], + [ + "Ġmil", + "es" + ], + [ + "Ġl", + "ab" + ], + [ + "Ġgo", + "al" + ], + [ + "Ġ2", + "7" + ], + [ + "Ġshow", + "s" + ], + [ + "Ġact", + "iv" + ], + [ + "c", + "om" + ], + [ + "Ġh", + "ope" + ], + [ + "ĠP", + "ort" + ], + [ + "ĠP", + "eter" + ], + [ + "Ġjoin", + "ed" + ], + [ + "Ġshar", + "p" + ], + [ + "O", + "f" + ], + [ + "Ġs", + "ite" + ], + [ + "Ġse", + "ven" + ], + [ + "Ġexc", + "iting" + ], + [ + "Ġthrough", + "out" + ], + [ + "ĠL", + "ond" + ], + [ + "ce", + "ed" + ], + [ + "Ġlaug", + "hing" + ], + [ + "Ġpat", + "ient" + ], + [ + "Ġallow", + "ed" + ], + [ + "Ġrelie", + "ved" + ], + [ + "ic", + "ked" + ], + [ + "Ġst", + "ep" + ], + [ + "um", + "ent" + ], + [ + "Ġwe", + "ak" + ], + [ + "ang", + "u" + ], + [ + "Ġn", + "ational" + ], + [ + "Ġst", + "one" + ], + [ + "ĠE", + "x" + ], + [ + "Ġpl", + "aced" + ], + [ + "ĠIn", + "side" + ], + [ + "ĠTh", + "ank" + ], + [ + "Ġshap", + "es" + ], + [ + "Ġw", + "and" + ], + [ + "is", + "a" + ], + [ + "Ġr", + "ul" + ], + [ + "Ġpro", + "gram" + ], + [ + "ĠAl", + "though" + ], + [ + "ĠLond", + "on" + ], + [ + "ĠB", + "ill" + ], + [ + "Ġbuck", + "et" + ], + [ + "Ġf", + "ing" + ], + [ + "Ġnot", + "ed" + ], + [ + "Ġpop", + "ulation" + ], + [ + "Ġf", + "t" + ], + [ + "Ġm", + "atter" + ], + [ + "ĠF", + "inally" + ], + [ + "Ġany", + "one" + ], + [ + "ĠCh", + "urch" + ], + [ + "Ġpoin", + "ts" + ], + [ + "o", + "ot" + ], + [ + "Ġw", + "ra" + ], + [ + "Ġm", + "ind" + ], + [ + "ĠAmeric", + "a" + ], + [ + "n", + "es" + ], + [ + "id", + "ence" + ], + [ + "ĠF", + "in" + ], + [ + "ĠR", + "oy" + ], + [ + "Ġdri", + "ve" + ], + [ + "Ã", + "¡" + ], + [ + "Ġc", + "ute" + ], + [ + "al", + "ion" + ], + [ + "Ġmo", + "ving" + ], + [ + "Ġwond", + "ered" + ], + [ + "Ġinterest", + "ing" + ], + [ + "g", + "el" + ], + [ + "ĠT", + "weet" + ], + [ + "Ġbo", + "ard" + ], + [ + "anc", + "y" + ], + [ + "Ġproble", + "m" + ], + [ + "Ġmach", + "ine" + ], + [ + "Ġm", + "ass" + ], + [ + "Ġpl", + "ane" + ], + [ + "Ġshe", + "ll" + ], + [ + "ĠG", + "l" + ], + [ + "ĠAr", + "my" + ], + [ + "Ġsho", + "ot" + ], + [ + "Ġcann", + "ot" + ], + [ + "Ġbec", + "om" + ], + [ + "Ġpo", + "em" + ], + [ + "Ġmil", + "k" + ], + [ + "Ġdevelop", + "ed" + ], + [ + "Ġsugg", + "ested" + ], + [ + "Ġto", + "r" + ], + [ + "Ġst", + "age" + ], + [ + "Ġsp", + "o" + ], + [ + "Ġdiscover", + "ed" + ], + [ + "Ġestabl", + "ished" + ], + [ + "Ġt", + "un" + ], + [ + "re", + "ady" + ], + [ + "Ġm", + "m" + ], + [ + "oo", + "f" + ], + [ + "Ġwor", + "ks" + ], + [ + "Ġstud", + "y" + ], + [ + "Ġfor", + "ces" + ], + [ + "ĠM", + "iss" + ], + [ + "Ġaccident", + "ally" + ], + [ + "ĠI", + "f" + ], + [ + "Ġf", + "em" + ], + [ + "Ġr", + "are" + ], + [ + "ĠM", + "ed" + ], + [ + "Ġsun", + "ny" + ], + [ + "Ġbirth", + "day" + ], + [ + "Ġeleph", + "ant" + ], + [ + "Ġb", + "as" + ], + [ + "Ġg", + "rew" + ], + [ + "ri", + "e" + ], + [ + "ĠP", + "ro" + ], + [ + "sh", + "ine" + ], + [ + "ĠJim", + "my" + ], + [ + "Ġt", + "ropical" + ], + [ + "Ġp", + "udd" + ], + [ + "Ġperform", + "ed" + ], + [ + "Ġl", + "angu" + ], + [ + "ĠM", + "us" + ], + [ + "ĠC", + "or" + ], + [ + "Ġeff", + "ect" + ], + [ + "Ġa", + "ward" + ], + [ + "Ġb", + "i" + ], + [ + "ell", + "ing" + ], + [ + "ĠGeor", + "ge" + ], + [ + "Ġtouc", + "hed" + ], + [ + "Ġb", + "reat" + ], + [ + "Ġent", + "ire" + ], + [ + "f", + "ord" + ], + [ + "l", + "ight" + ], + [ + "p", + "a" + ], + [ + "Ġ", + "ign" + ], + [ + "Ġb", + "ase" + ], + [ + "ĠC", + "al" + ], + [ + "Ġare", + "as" + ], + [ + "ĠG", + "od" + ], + [ + "Ġcol", + "our" + ], + [ + "Ġswim", + "ming" + ], + [ + "Ġcra", + "w" + ], + [ + "Ġcamp", + "a" + ], + [ + "Ġca", + "used" + ], + [ + "Ġal", + "ready" + ], + [ + "ĠP", + "e" + ], + [ + "Ġoff", + "ice" + ], + [ + "Ġmy", + "ster" + ], + [ + "Ġpur", + "ple" + ], + [ + "c", + "raft" + ], + [ + "Ġst", + "ra" + ], + [ + "Ġst", + "ation" + ], + [ + "ill", + "s" + ], + [ + "Ġv", + "i" + ], + [ + "Ġmix", + "ed" + ], + [ + "Ġdanc", + "ed" + ], + [ + "Ġ", + "!" + ], + [ + "ĠE", + "n" + ], + [ + "ap", + "s" + ], + [ + "Ġtri", + "p" + ], + [ + "Ġpower", + "ful" + ], + [ + "ĠAtl", + "ant" + ], + [ + "Ġsa", + "f" + ], + [ + "Ġfore", + "ver" + ], + [ + "Ġdr", + "ink" + ], + [ + "Ġind", + "epend" + ], + [ + "a", + "el" + ], + [ + "he", + "t" + ], + [ + "at", + "o" + ], + [ + "Ġan", + "c" + ], + [ + "Ġgo", + "es" + ], + [ + "Ġsun", + "shine" + ], + [ + "ĠGener", + "al" + ], + [ + "A", + "l" + ], + [ + "il", + "le" + ], + [ + "Ġpl", + "ant" + ], + [ + "Ġcomple", + "ted" + ], + [ + "Ġfe", + "ather" + ], + [ + "Ġpr", + "im" + ], + [ + "Ġsur", + "f" + ], + [ + "Ġprot", + "ect" + ], + [ + "fort", + "able" + ], + [ + "ĠAf", + "ric" + ], + [ + "Ġg", + "igg" + ], + [ + "Ġfin", + "ish" + ], + [ + "Ġ18", + "9" + ], + [ + "Ġacc", + "om" + ], + [ + "Ġfoot", + "ball" + ], + [ + "Ã", + "Ń" + ], + [ + "Ġd", + "i" + ], + [ + "pt", + "ion" + ], + [ + "Ġvar", + "ious" + ], + [ + "ampions", + "hip" + ], + [ + "im", + "ately" + ], + [ + "ĠR", + "ober" + ], + [ + "Ġt", + "echn" + ], + [ + "ĠS", + "im" + ], + [ + "ĠM", + "ad" + ], + [ + "Ġprom", + "ise" + ], + [ + "Ġperform", + "ance" + ], + [ + "c", + "ast" + ], + [ + "Ġc", + "oo" + ], + [ + "Ġr", + "ing" + ], + [ + "Ġsp", + "read" + ], + [ + "Ġpol", + "ice" + ], + [ + "Ġsignific", + "ant" + ], + [ + "Ġg", + "iant" + ], + [ + "ĠD", + "es" + ], + [ + "Ġsp", + "in" + ], + [ + "Ġsnow", + "man" + ], + [ + "ĠCoun", + "ty" + ], + [ + "Ġc", + "y" + ], + [ + "ĠM", + "ag" + ], + [ + "Ġag", + "e" + ], + [ + "Ġqu", + "ar" + ], + [ + "y", + "al" + ], + [ + "Ġche", + "ese" + ], + [ + "Ġoffic", + "ial" + ], + [ + "Ġh", + "ar" + ], + [ + "ĠS", + "omet" + ], + [ + "g", + "ing" + ], + [ + "Ġb", + "al" + ], + [ + "Ġdevelop", + "ment" + ], + [ + "Ġwear", + "ing" + ], + [ + "r", + "or" + ], + [ + "he", + "st" + ], + [ + "Ġre", + "ve" + ], + [ + "ĠA", + "ccording" + ], + [ + "Ġdec", + "l" + ], + [ + "iv", + "il" + ], + [ + "Ġlet", + "ter" + ], + [ + "Ġter", + "m" + ], + [ + "Ġo", + "cean" + ], + [ + "ĠI", + "r" + ], + [ + "Ġhel", + "lo" + ], + [ + "Ġfe", + "ed" + ], + [ + "Ġre", + "se" + ], + [ + "Ġev", + "ents" + ], + [ + "Ġgun", + "s" + ], + [ + "Ġl", + "ucky" + ], + [ + "Ġconstruc", + "tion" + ], + [ + "Ġh", + "ous" + ], + [ + "Ġmonth", + "s" + ], + [ + "Ġm", + "id" + ], + [ + "ig", + "ade" + ], + [ + "ch", + "ie" + ], + [ + "Ġa", + "ud" + ], + [ + "Ġf", + "aces" + ], + [ + "Ġc", + "and" + ], + [ + "as", + "er" + ], + [ + "Ġbus", + "h" + ], + [ + "ĠM", + "ama" + ], + [ + "Ġsm", + "o" + ], + [ + "Ġser", + "ved" + ], + [ + "He", + "y" + ], + [ + "Ġdr", + "um" + ], + [ + "le", + "ct" + ], + [ + "Ġsa", + "ve" + ], + [ + "Ġav", + "ail" + ], + [ + "Ġneighb", + "or" + ], + [ + "Ġpolit", + "ical" + ], + [ + "d", + "e" + ], + [ + "Ġm", + "ountain" + ], + [ + "Ġfor", + "t" + ], + [ + "ĠM", + "ark" + ], + [ + "ĠP", + "er" + ], + [ + "Ġco", + "zy" + ], + [ + "ubl", + "ic" + ], + [ + "Ġas", + "h" + ], + [ + "ĠD", + "an" + ], + [ + "Ġbatt", + "le" + ], + [ + "k", + "y" + ], + [ + "Ġp", + "an" + ], + [ + "Ġk", + "illed" + ], + [ + "Ġsmil", + "ing" + ], + [ + "Ġbr", + "idge" + ], + [ + "ĠO", + "ld" + ], + [ + "Ġcharac", + "ters" + ], + [ + "Ġbelie", + "ved" + ], + [ + "z", + "a" + ], + [ + "Ġw", + "olf" + ], + [ + "ĠR", + "ich" + ], + [ + "Ġey", + "e" + ], + [ + "Ġbre", + "ad" + ], + [ + "Ġform", + "ed" + ], + [ + "yl", + "an" + ], + [ + "k", + "in" + ], + [ + "Ġst", + "ret" + ], + [ + "Ġeng", + "ine" + ], + [ + "ĠH", + "igh" + ], + [ + "ĠG", + "o" + ], + [ + "Ġsand", + "w" + ], + [ + "Ġsear", + "ched" + ], + [ + "Ġcorn", + "er" + ], + [ + "h", + "an" + ], + [ + "Ġsp", + "oon" + ], + [ + "ĠR", + "ep" + ], + [ + "Ġsmall", + "er" + ], + [ + "Ġwee", + "ks" + ], + [ + "olog", + "ical" + ], + [ + "u", + "el" + ], + [ + "Ġhe", + "althy" + ], + [ + "Ġrel", + "ations" + ], + [ + "Ġele", + "ct" + ], + [ + "Ġtal", + "ked" + ], + [ + "Ġtal", + "king" + ], + [ + "enc", + "ed" + ], + [ + "ert", + "ain" + ], + [ + "Ġfor", + "ce" + ], + [ + "ro", + "ph" + ], + [ + "Ġtell", + "s" + ], + [ + "Ġf", + "ac" + ], + [ + "Ġplay", + "ers" + ], + [ + "Ġsc", + "ar" + ], + [ + "Ġtr", + "ue" + ], + [ + "Ġpro", + "ject" + ], + [ + "Ġcover", + "ed" + ], + [ + "Ġcampa", + "ign" + ], + [ + "ĠH", + "ar" + ], + [ + "ĠP", + "aul" + ], + [ + "Ġcon", + "n" + ], + [ + "Ġmark", + "et" + ], + [ + "use", + "um" + ], + [ + "Ġb", + "orn" + ], + [ + "Ġp", + "ill" + ], + [ + "Ġg", + "as" + ], + [ + "un", + "t" + ], + [ + "Ġearl", + "ier" + ], + [ + "Ġm", + "iddle" + ], + [ + "Ġre", + "v" + ], + [ + "Ġpr", + "ed" + ], + [ + "Ġve", + "get" + ], + [ + "Ġcloud", + "s" + ], + [ + "L", + "ucy" + ], + [ + "az", + "ine" + ], + [ + "Ġtri", + "es" + ], + [ + "Ġbott", + "le" + ], + [ + "i", + "ated" + ], + [ + "ĠM", + "ittens" + ], + [ + "Ġstand", + "ing" + ], + [ + "idd", + "en" + ], + [ + "Ġtast", + "y" + ], + [ + "ĠC", + "o" + ], + [ + "Ġbut", + "ton" + ], + [ + "ĠP", + "et" + ], + [ + "Ġtr", + "ust" + ], + [ + "Ġtrad", + "ition" + ], + [ + "Ġh", + "ospital" + ], + [ + "ver", + "t" + ], + [ + "am", + "er" + ], + [ + "Ġlo", + "g" + ], + [ + "ell", + "a" + ], + [ + "ab", + "les" + ], + [ + "ĠRo", + "ad" + ], + [ + "i", + "est" + ], + [ + "est", + "s" + ], + [ + "Ġkn", + "ee" + ], + [ + "med", + "i" + ], + [ + "Ġquest", + "ion" + ], + [ + "ou", + "b" + ], + [ + "Ġth", + "ick" + ], + [ + "ic", + "ated" + ], + [ + "ec", + "ut" + ], + [ + "ĠP", + "en" + ], + [ + "Ġ2", + "9" + ], + [ + "Ġput", + "s" + ], + [ + "Ġdisapp", + "ear" + ], + [ + "Ġobs", + "er" + ], + [ + "Ġc", + "ow" + ], + [ + "ĠP", + "al" + ], + [ + "Ġc", + "ase" + ], + [ + "Ġr", + "ange" + ], + [ + "ĠM", + "or" + ], + [ + "Ġlo", + "ves" + ], + [ + "Ġdec", + "or" + ], + [ + "Ġem", + "p" + ], + [ + "Ġconf", + "used" + ], + [ + "G", + "ood" + ], + [ + "i", + "ber" + ], + [ + "Ġ200", + "5" + ], + [ + "Ġatt", + "r" + ], + [ + "enc", + "y" + ], + [ + "Ġz", + "oom" + ], + [ + "r", + "ound" + ], + [ + "in", + "c" + ], + [ + "ar", + "ch" + ], + [ + "Ġthem", + "selves" + ], + [ + "iv", + "id" + ], + [ + "Ġte", + "eth" + ], + [ + "ĠSam", + "my" + ], + [ + "Ġcolle", + "ct" + ], + [ + "Ġroll", + "ed" + ], + [ + "Ġa", + "ver" + ], + [ + "Ġp", + "ool" + ], + [ + "ĠF", + "red" + ], + [ + "ĠInd", + "ian" + ], + [ + "Ġavail", + "able" + ], + [ + "re", + "g" + ], + [ + "re", + "land" + ], + [ + "Ġle", + "ast" + ], + [ + "Ġle", + "aving" + ], + [ + "iz", + "ation" + ], + [ + "Ġh", + "oney" + ], + [ + "ĠS", + "w" + ], + [ + "ol", + "es" + ], + [ + "Ġits", + "elf" + ], + [ + "ĠRe", + "g" + ], + [ + "ĠIs", + "land" + ], + [ + "Ġvi", + "ol" + ], + [ + "Ġf", + "ear" + ], + [ + "as", + "hed" + ], + [ + "Ġd", + "rew" + ], + [ + "Ġmo", + "v" + ], + [ + "Ġde", + "ad" + ], + [ + "Ġz", + "oo" + ], + [ + "re", + "st" + ], + [ + "Ġp", + "ack" + ], + [ + "Ġm", + "ater" + ], + [ + "ĠS", + "ec" + ], + [ + "The", + "re" + ], + [ + "ĠD", + "ylan" + ], + [ + "Ġtr", + "ouble" + ], + [ + "Ġatt", + "empt" + ], + [ + "hy", + "s" + ], + [ + "ĠM", + "o" + ], + [ + "ol", + "s" + ], + [ + "Ġgr", + "ay" + ], + [ + "Ġwa", + "iting" + ], + [ + "Ġann", + "ounced" + ], + [ + "Ġcray", + "ons" + ], + [ + "a", + "ked" + ], + [ + "f", + "ield" + ], + [ + "Ġb", + "at" + ], + [ + "ou", + "ra" + ], + [ + "Ġrel", + "ig" + ], + [ + "Ġspot", + "ted" + ], + [ + "om", + "b" + ], + [ + "ĠR", + "ec" + ], + [ + "Ġsur", + "v" + ], + [ + "Ġsmell", + "ed" + ], + [ + "it", + "ted" + ], + [ + "is", + "er" + ], + [ + "Ġn", + "ames" + ], + [ + "Ġbe", + "g" + ], + [ + "Ġst", + "ren" + ], + [ + "Ġsc", + "reen" + ], + [ + "ff", + "ic" + ], + [ + "ĠTh", + "om" + ], + [ + "Ġloc", + "ated" + ], + [ + "ĠA", + "ir" + ], + [ + "Ġme", + "asure" + ], + [ + "Ġpro", + "cess" + ], + [ + "Ġdist", + "ance" + ], + [ + "ĠJen", + "ny" + ], + [ + "ĠAustral", + "ia" + ], + [ + "al", + "ed" + ], + [ + "Ġnum", + "bers" + ], + [ + "Ġgiv", + "ing" + ], + [ + "m", + "ar" + ], + [ + "Ġ", + "ident" + ], + [ + "ic", + "o" + ], + [ + "ĠI", + "reland" + ], + [ + "p", + "ted" + ], + [ + "Ġs", + "ize" + ], + [ + "Ġoff", + "ered" + ], + [ + "ĠâĢ", + "Ļ" + ], + [ + "Ġfix", + "ed" + ], + [ + "Ġins", + "p" + ], + [ + "Ġd", + "ucks" + ], + [ + "Ġlo", + "vely" + ], + [ + "Ġd", + "ig" + ], + [ + "Ġr", + "ope" + ], + [ + "Ġgo", + "d" + ], + [ + "ĠE", + "ven" + ], + [ + "Ġcom", + "ment" + ], + [ + "Ġpus", + "h" + ], + [ + "Ġf", + "if" + ], + [ + "ĠE", + "ll" + ], + [ + "Ġco", + "ast" + ], + [ + "Ġ18", + "8" + ], + [ + "Ġhur", + "ricane" + ], + [ + "Ġdisc", + "uss" + ], + [ + "f", + "all" + ], + [ + "ĠH", + "a" + ], + [ + "Ġsc", + "ored" + ], + [ + "Ġ200", + "4" + ], + [ + "C", + "ome" + ], + [ + "Ġp", + "ile" + ], + [ + "Ġli", + "f" + ], + [ + "Ġhelp", + "ful" + ], + [ + "Ġsn", + "ake" + ], + [ + "Ġcou", + "ch" + ], + [ + "Ġstren", + "g" + ], + [ + "al", + "ity" + ], + [ + "Ġbro", + "ad" + ], + [ + "Ġa", + "chie" + ], + [ + "Ġu", + "r" + ], + [ + "Ġj", + "og" + ], + [ + "h", + "a" + ], + [ + "n", + "ow" + ], + [ + "le", + "x" + ], + [ + "Ġte", + "ach" + ], + [ + "Ġfeat", + "ures" + ], + [ + "ĠS", + "y" + ], + [ + "ĠH", + "en" + ], + [ + "Ġchang", + "ed" + ], + [ + "Ġdeterm", + "ined" + ], + [ + "Ġp", + "il" + ], + [ + "Ġse", + "at" + ], + [ + "Ġmo", + "le" + ], + [ + "ĠK", + "e" + ], + [ + "ass", + "ed" + ], + [ + "Ġresp", + "ons" + ], + [ + "ar", + "ian" + ], + [ + "Ġco", + "at" + ], + [ + "ĠDav", + "id" + ], + [ + "c", + "y" + ], + [ + "c", + "ent" + ], + [ + "Ġb", + "ell" + ], + [ + "Ġl", + "ad" + ], + [ + "ad", + "o" + ], + [ + "Ġsp", + "ace" + ], + [ + "Ġho", + "st" + ], + [ + "Tom", + "my" + ], + [ + "Ġcap", + "t" + ], + [ + "Ġph", + "one" + ], + [ + "ĠBl", + "ack" + ], + [ + "Ġr", + "ough" + ], + [ + "Ġ3", + "1" + ], + [ + "amp", + "le" + ], + [ + "Ġass", + "oc" + ], + [ + "Ġg", + "ently" + ], + [ + "Ġn", + "on" + ], + [ + "Ġsh", + "ining" + ], + [ + "Ġdis", + "play" + ], + [ + "Ġ4", + "0" + ], + [ + "Ġcle", + "ver" + ], + [ + "j", + "ects" + ], + [ + "Ġn", + "ut" + ], + [ + "Ġn", + "ature" + ], + [ + "Ġex", + "ample" + ], + [ + "Ġcl", + "oth" + ], + [ + "Ġpra", + "ised" + ], + [ + "Ġw", + "omen" + ], + [ + "Ġsa", + "ck" + ], + [ + "ĠA", + "ss" + ], + [ + "Ġcall", + "ing" + ], + [ + "Ġn", + "orm" + ], + [ + "ĠB", + "o" + ], + [ + "Ġlo", + "ss" + ], + [ + "oc", + "ol" + ], + [ + "Ġme", + "ans" + ], + [ + "ĠO", + "l" + ], + [ + "Ġpre", + "vent" + ], + [ + "od", + "ay" + ], + [ + "Ġend", + "ing" + ], + [ + "Ġsmo", + "oth" + ], + [ + "Ġst", + "ir" + ], + [ + "Ġbl", + "ock" + ], + [ + "ĠAn", + "n" + ], + [ + "Ġcrit", + "ics" + ], + [ + "Ġ18", + "6" + ], + [ + "Ġatt", + "emp" + ], + [ + "ustr", + "ated" + ], + [ + "Ġf", + "re" + ], + [ + "Ġf", + "oc" + ], + [ + "ĠR", + "ose" + ], + [ + "Ġair", + "craft" + ], + [ + "Ġph", + "ot" + ], + [ + "Ġrob", + "ot" + ], + [ + "Ġact", + "ion" + ], + [ + "Ġmot", + "or" + ], + [ + "Ġp", + "in" + ], + [ + "Ġas", + "leep" + ], + [ + "ast", + "ic" + ], + [ + "Ġsee", + "k" + ], + [ + "Ġreg", + "ion" + ], + [ + "Ġind", + "ivid" + ], + [ + "f", + "orm" + ], + [ + "an", + "o" + ], + [ + "Ġst", + "ood" + ], + [ + "ul", + "ly" + ], + [ + "Ġcont", + "ent" + ], + [ + "Ġlead", + "ing" + ], + [ + "ad", + "ed" + ], + [ + "Ġrem", + "ind" + ], + [ + "Ġear", + "th" + ], + [ + "Ġob", + "ject" + ], + [ + "emp", + "or" + ], + [ + "Ġpuzz", + "le" + ], + [ + "ĠRoy", + "al" + ], + [ + "Ġo", + "ven" + ], + [ + "Ġcom", + "pl" + ], + [ + "Ġdam", + "age" + ], + [ + "Ġposs", + "ible" + ], + [ + "Ġtast", + "e" + ], + [ + "Ġr", + "ather" + ], + [ + "ĠW", + "al" + ], + [ + "Ġman", + "aged" + ], + [ + "Ġmo", + "on" + ], + [ + "Ġde", + "but" + ], + [ + "Ġcomplet", + "e" + ], + [ + "ĠT", + "own" + ], + [ + "il", + "ed" + ], + [ + "Ġy", + "et" + ], + [ + "ak", + "er" + ], + [ + "Ġ18", + "5" + ], + [ + "Ġinv", + "est" + ], + [ + "Ġmiss", + "ed" + ], + [ + "Ġfig", + "ure" + ], + [ + "Ġemb", + "arr" + ], + [ + "Ġt", + "aught" + ], + [ + "Ġt", + "asted" + ], + [ + "in", + "o" + ], + [ + "ar", + "i" + ], + [ + "Ġm", + "ud" + ], + [ + "Ġplan", + "ts" + ], + [ + "Ġext", + "ra" + ], + [ + "Ġansw", + "er" + ], + [ + "u", + "nder" + ], + [ + "Ġs", + "uit" + ], + [ + "Ġp", + "ir" + ], + [ + "ra", + "b" + ], + [ + "op", + "h" + ], + [ + "ĠP", + "at" + ], + [ + "Ġch", + "ocol" + ], + [ + "Ġpro", + "per" + ], + [ + "Ġpret", + "ended" + ], + [ + "Ġbuild", + "ings" + ], + [ + "Ġcre", + "ate" + ], + [ + "eng", + "th" + ], + [ + "Ġm", + "ic" + ], + [ + "ot", + "ed" + ], + [ + "av", + "en" + ], + [ + "Ġspe", + "ed" + ], + [ + "ĠT", + "ur" + ], + [ + "Ġwhen", + "ever" + ], + [ + "Ġmag", + "n" + ], + [ + "Ġorigin", + "ally" + ], + [ + "E", + "very" + ], + [ + "Ġs", + "outhern" + ], + [ + "Ġd", + "irt" + ], + [ + "Ġ200", + "3" + ], + [ + "Ġland", + "ed" + ], + [ + "Ġprov", + "ided" + ], + [ + "ĠKing", + "dom" + ], + [ + "ĠSomet", + "imes" + ], + [ + "uc", + "le" + ], + [ + "Ġsc", + "reamed" + ], + [ + "ant", + "ry" + ], + [ + "Ġfour", + "th" + ], + [ + "Ġfur", + "ry" + ], + [ + "Ġrout", + "e" + ], + [ + "Ġrelations", + "hip" + ], + [ + "Ġher", + "o" + ], + [ + "Ġr", + "at" + ], + [ + "Ġend", + "ed" + ], + [ + "Ġorgan", + "ized" + ], + [ + "ĠComp", + "any" + ], + [ + "id", + "a" + ], + [ + "ri", + "b" + ], + [ + "Ġfam", + "ous" + ], + [ + "Ġprof", + "ess" + ], + [ + "Ġmater", + "ial" + ], + [ + "Ġw", + "ore" + ], + [ + "Ġsc", + "ore" + ], + [ + "Ġde", + "v" + ], + [ + "Ġsur", + "round" + ], + [ + "ĠChrist", + "ian" + ], + [ + "as", + "hing" + ], + [ + "Ġk", + "ick" + ], + [ + "Ġch", + "ick" + ], + [ + "Ġgl", + "ass" + ], + [ + "Ġrock", + "et" + ], + [ + "Ġforg", + "ive" + ], + [ + "Ġserv", + "ice" + ], + [ + "J", + "ust" + ], + [ + "Ġc", + "rew" + ], + [ + "Ġg", + "ar" + ], + [ + "ĠE", + "nd" + ], + [ + "Ġcal", + "m" + ], + [ + "Ġe", + "c" + ], + [ + "Ġcom", + "mer" + ], + [ + "Ġcreat", + "ive" + ], + [ + "ĠL", + "a" + ], + [ + "Ġsh", + "ot" + ], + [ + "Ġest", + "im" + ], + [ + "Ġlangu", + "age" + ], + [ + "r", + "ang" + ], + [ + "Ġf", + "a" + ], + [ + "ĠS", + "us" + ], + [ + "Ġnot", + "e" + ], + [ + "Ġpr", + "ay" + ], + [ + "Ġgener", + "ally" + ], + [ + "ĠAustral", + "ian" + ], + [ + "Ġh", + "om" + ], + [ + "ĠM", + "ill" + ], + [ + "Ġgener", + "al" + ], + [ + "Ġb", + "low" + ], + [ + "el", + "p" + ], + [ + "ĠD", + "ay" + ], + [ + "Ġleg", + "s" + ], + [ + "Ġparticular", + "ly" + ], + [ + "Ġanc", + "ient" + ], + [ + "ĠRober", + "t" + ], + [ + "Ġchocol", + "ate" + ], + [ + "Ġ", + "ill" + ], + [ + "Ġh", + "iding" + ], + [ + "Ġh", + "idden" + ], + [ + "ent", + "ial" + ], + [ + "Ġrad", + "io" + ], + [ + "ol", + "ution" + ], + [ + "Ġsh", + "ore" + ], + [ + "Ġsc", + "r" + ], + [ + "Ġfl", + "ood" + ], + [ + "Ġdes", + "igned" + ], + [ + "J", + "im" + ], + [ + "in", + "ary" + ], + [ + "Ġp", + "our" + ], + [ + "st", + "on" + ], + [ + "ist", + "ic" + ], + [ + "ĠIn", + "tern" + ], + [ + "Ġcarr", + "ot" + ], + [ + "Ġvict", + "ory" + ], + [ + "Ġtom", + "orrow" + ], + [ + "at", + "ors" + ], + [ + "ac", + "y" + ], + [ + "Ġun", + "ique" + ], + [ + "n", + "own" + ], + [ + "le", + "g" + ], + [ + "ig", + "hed" + ], + [ + "Ġsh", + "irt" + ], + [ + "Ġstr", + "ing" + ], + [ + "Ġ201", + "4" + ], + [ + "Ġ201", + "5" + ], + [ + "Åĵ", + "I" + ], + [ + "M", + "olly" + ], + [ + "Ġa", + "ut" + ], + [ + "Ġcon", + "v" + ], + [ + "Ġpar", + "ts" + ], + [ + "ip", + "e" + ], + [ + "Ġser", + "ious" + ], + [ + "Ġeas", + "tern" + ], + [ + "Ġble", + "w" + ], + [ + "l", + "ies" + ], + [ + "Ġf", + "und" + ], + [ + "ig", + "er" + ], + [ + "re", + "y" + ], + [ + "ĠT", + "e" + ], + [ + "Ġe", + "ager" + ], + [ + "h", + "od" + ], + [ + "s", + "y" + ], + [ + "Ġd", + "iam" + ], + [ + "ic", + "a" + ], + [ + "Ġsh", + "y" + ], + [ + "Ġsp", + "ir" + ], + [ + "ight", + "s" + ], + [ + "Ġsum", + "mer" + ], + [ + "h", + "ood" + ], + [ + "Ġm", + "er" + ], + [ + "ĠA", + "ct" + ], + [ + "ur", + "g" + ], + [ + "Ġappear", + "ance" + ], + [ + "Ġw", + "id" + ], + [ + "Ġm", + "ember" + ], + [ + "ĠS", + "om" + ], + [ + "Ġse", + "x" + ], + [ + "ĠV", + "al" + ], + [ + "Ġsqu", + "are" + ], + [ + "c", + "il" + ], + [ + "Ġre", + "ac" + ], + [ + "ĠA", + "re" + ], + [ + "ĠP", + "res" + ], + [ + "Ġpract", + "ice" + ], + [ + "ĠSm", + "ith" + ], + [ + "ĠH", + "ouse" + ], + [ + "Ġun", + "l" + ], + [ + "Ġte", + "a" + ], + [ + "ĠAl", + "ice" + ], + [ + "Ġopen", + "ing" + ], + [ + "ĠFl", + "or" + ], + [ + "bo", + "x" + ], + [ + "Ġpudd", + "le" + ], + [ + "ĠL", + "ittle" + ], + [ + "Ġsp", + "icy" + ], + [ + "Ġcar", + "t" + ], + [ + "Ġapp", + "les" + ], + [ + "ĠL", + "isa" + ], + [ + "Ġse", + "ed" + ], + [ + "ĠJen", + "nings" + ], + [ + "Ġl", + "ength" + ], + [ + "Ġwas", + "h" + ], + [ + "Ġg", + "uitar" + ], + [ + "ĠD", + "r" + ], + [ + "ĠK", + "itty" + ], + [ + "ollow", + "ing" + ], + [ + "ĠJ", + "ew" + ], + [ + "Ġex", + "ist" + ], + [ + "Ġpeace", + "ful" + ], + [ + "N", + "ow" + ], + [ + "r", + "ation" + ], + [ + "Ġch", + "art" + ], + [ + "Ġkn", + "ocked" + ], + [ + "Ġed", + "ge" + ], + [ + "Ġl", + "it" + ], + [ + "Ġre", + "b" + ], + [ + "oo", + "ps" + ], + [ + "ĠE", + "v" + ], + [ + "Ġche", + "er" + ], + [ + "Ġreg", + "ard" + ], + [ + "Ġcook", + "ie" + ], + [ + "Ġdire", + "cted" + ], + [ + "n", + "t" + ], + [ + "Ġt", + "em" + ], + [ + "Ġf", + "ut" + ], + [ + "Ġc", + "ere" + ], + [ + "Ġun", + "us" + ], + [ + "Ġim", + "medi" + ], + [ + "Ġwall", + "s" + ], + [ + "ĠMich", + "ael" + ], + [ + "ĠTw", + "o" + ], + [ + "Ġt", + "ent" + ], + [ + "Ġh", + "ang" + ], + [ + "ĠM", + "ex" + ], + [ + "Ġne", + "g" + ], + [ + "pl", + "oy" + ], + [ + "low", + "er" + ], + [ + "Ġinter", + "n" + ], + [ + "Ġele", + "ments" + ], + [ + "Ġsub", + "sequ" + ], + [ + "Ġsy", + "mb" + ], + [ + "Ġdep", + "end" + ], + [ + "Ġref", + "used" + ], + [ + "Ġeas", + "y" + ], + [ + "S", + "oon" + ], + [ + "r", + "u" + ], + [ + "ra", + "g" + ], + [ + "Ġstr", + "ugg" + ], + [ + "Ġrepl", + "aced" + ], + [ + "Ġbug", + "s" + ], + [ + "Ġfeat", + "ured" + ], + [ + "ĠÂ", + "°" + ], + [ + "Ġhous", + "es" + ], + [ + "M", + "y" + ], + [ + "Ġm", + "el" + ], + [ + "Ġn", + "ucle" + ], + [ + "ac", + "ing" + ], + [ + "Ġso", + "c" + ], + [ + "ol", + "ves" + ], + [ + "Ġsn", + "ack" + ], + [ + "Ġcla", + "im" + ], + [ + "ĠThom", + "as" + ], + [ + "M", + "um" + ], + [ + "ĠF", + "eder" + ], + [ + "Ġpre", + "p" + ], + [ + "Ġpic", + "n" + ], + [ + "Ġhigh", + "way" + ], + [ + "Ġmay", + "be" + ], + [ + "ung", + "le" + ], + [ + "Ġmyster", + "ious" + ], + [ + "Ġh", + "id" + ], + [ + "ag", + "o" + ], + [ + "ĠEm", + "ily" + ], + [ + "at", + "ural" + ], + [ + "Ġm", + "ention" + ], + [ + "ĠS", + "qu" + ], + [ + "ac", + "hel" + ], + [ + "Ġv", + "oc" + ], + [ + "act", + "ion" + ], + [ + "Ġbus", + "iness" + ], + [ + "Ġter", + "rit" + ], + [ + "Ġtight", + "ly" + ], + [ + "Ġlad", + "der" + ], + [ + "h", + "i" + ], + [ + "om", + "m" + ], + [ + "ĠB", + "ur" + ], + [ + "Ġus", + "ually" + ], + [ + "ĠFr", + "ance" + ], + [ + "ĠPh", + "il" + ], + [ + "Ġb", + "oun" + ], + [ + "Ġp", + "ow" + ], + [ + "Ġst", + "icks" + ], + [ + "Ġpro", + "b" + ], + [ + "ian", + "o" + ], + [ + "Ġexp", + "ensive" + ], + [ + "Ġintroduc", + "ed" + ], + [ + "ĠHen", + "ry" + ], + [ + "ĠH", + "all" + ], + [ + "Ġpl", + "ate" + ], + [ + "Ġj", + "ungle" + ], + [ + "ub", + "e" + ], + [ + "Ġjump", + "ing" + ], + [ + "Ġmet", + "al" + ], + [ + "Ġdraw", + "ing" + ], + [ + "Ġinf", + "orm" + ], + [ + "Ġsit", + "u" + ], + [ + "Ġcur", + "rent" + ], + [ + "Ġneck", + "l" + ], + [ + "st", + "ant" + ], + [ + "B", + "e" + ], + [ + "g", + "o" + ], + [ + "ĠJ", + "ake" + ], + [ + "res", + "h" + ], + [ + "Ġshel", + "f" + ], + [ + "Ġwhist", + "le" + ], + [ + "ĠS", + "an" + ], + [ + "ic", + "le" + ], + [ + "ĠL", + "ove" + ], + [ + "ol", + "a" + ], + [ + "ĠE", + "ast" + ], + [ + "ĠSt", + "reet" + ], + [ + "Ġhig", + "hest" + ], + [ + "i", + "res" + ], + [ + "Ġsa", + "ved" + ], + [ + "Ġdire", + "ctor" + ], + [ + "ĠTo", + "gether" + ], + [ + "c", + "o" + ], + [ + "Ġb", + "atter" + ], + [ + "is", + "k" + ], + [ + "ot", + "a" + ], + [ + "ĠC", + "up" + ], + [ + "ro", + "c" + ], + [ + "ord", + "s" + ], + [ + "ĠJohn", + "ny" + ], + [ + "w", + "est" + ], + [ + "Ġh", + "arm" + ], + [ + "Ġ18", + "7" + ], + [ + "Ġcent", + "ral" + ], + [ + "Ġind", + "ust" + ], + [ + "Ġdisapp", + "ointed" + ], + [ + "Ġembarr", + "assed" + ], + [ + "l", + "iam" + ], + [ + "t", + "i" + ], + [ + "is", + "hes" + ], + [ + "Ġres", + "c" + ], + [ + "ĠBl", + "ue" + ], + [ + "g", + "ly" + ], + [ + "o", + "ff" + ], + [ + "w", + "ood" + ], + [ + "he", + "m" + ], + [ + "Ġh", + "y" + ], + [ + "ĠS", + "er" + ], + [ + "Ġche", + "st" + ], + [ + "ric", + "t" + ], + [ + "Ġdin", + "osaur" + ], + [ + "ĠPl", + "ay" + ], + [ + "m", + "et" + ], + [ + "Ġt", + "id" + ], + [ + "Ġs", + "igned" + ], + [ + "Ġf", + "ill" + ], + [ + "en", + "n" + ], + [ + "ĠS", + "un" + ], + [ + "ĠH", + "am" + ], + [ + "ĠA", + "lex" + ], + [ + "ib", + "ility" + ], + [ + "Ġmar", + "ried" + ], + [ + "Ġcreat", + "ure" + ], + [ + "Ġshe", + "ep" + ], + [ + "ĠR", + "ob" + ], + [ + "art", + "ment" + ], + [ + "Ġ5", + "00" + ], + [ + "ĠBatt", + "alion" + ], + [ + "Ġegg", + "s" + ], + [ + "a", + "ks" + ], + [ + "Ġm", + "i" + ], + [ + "Ġon", + "es" + ], + [ + "Ġu", + "gly" + ], + [ + "Ġsh", + "ape" + ], + [ + "ĠWh", + "ite" + ], + [ + "Ġl", + "ower" + ], + [ + "Ġin", + "j" + ], + [ + "Ġn", + "erv" + ], + [ + "ac", + "ter" + ], + [ + "ug", + "ar" + ], + [ + "ĠSt", + "ar" + ], + [ + "Ġunderst", + "ood" + ], + [ + "Ġcoun", + "ter" + ], + [ + "ĠQ", + "u" + ], + [ + "Ġsil", + "ver" + ], + [ + "Ġpicn", + "ic" + ], + [ + "Ġnerv", + "ous" + ], + [ + "ĠB", + "ra" + ], + [ + "Ġwr", + "iter" + ], + [ + "Ġset", + "t" + ], + [ + "B", + "C" + ], + [ + "Ġn", + "orthern" + ], + [ + "le", + "cted" + ], + [ + "ĠC", + "ong" + ] + ] + } +} \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index 366cb8d..9d6c40d 100644 --- a/docs/README.md +++ b/docs/README.md @@ -19,6 +19,7 @@ See root README.md, COGNITIVE_PHYSICS_ROADMAP.md (progress), ARCHITECTURE.md, CH - [ARCHITECTURE](../ARCHITECTURE.md) - [CHANGELOG](../CHANGELOG.md) - [MANIFESTO.md](MANIFESTO.md) (ideology) +- [constraint-fields.md](constraint-fields.md) — deterministic TS-AI constraint-field reasoning substrate - [truth-graph.md](truth-graph.md) - [directory-structure.md](directory-structure.md) - [configuration.md](configuration.md) diff --git a/docs/constraint-fields.md b/docs/constraint-fields.md new file mode 100644 index 0000000..62c9812 --- /dev/null +++ b/docs/constraint-fields.md @@ -0,0 +1,135 @@ +# TS-AI Constraint-Field Reasoning + +This module is the first deterministic substrate for representing concepts as +structured constraint fields. It lives in `reasoner/ts_reasoner/constraint_fields` +and is intentionally verifier-first: no embedding lookup, random sampling, or +external LLM call is required for the core tests. + +## Core Thesis + +Concepts should be mapped to physical and mathematical constraint fields before +they are compared. Similarity is overlap in constraint topology, not token +closeness. An analogy is only accepted when the shared mechanisms, limits, +prediction surface, and counterexamples are explicit. + +This is not a metaphor generator. A comparison can say that two systems overlap +through `accumulation`, `threshold`, or `feedback`, but it must also say where +that mapping breaks. + +## Data Model + +A `ConceptField` contains: + +- `concept_id`, `name`, `description` +- `entities`, `forces`, `constraints`, `flows` +- `thresholds`, `attractors`, `failure_modes` +- `similar_systems`, `breakpoints`, `testable_predictions` +- `confidence`, `receipts` + +Each internal item is a `FieldItem` with: + +- `id`, `label`, `description` +- `polarity`, `strength`, `confidence` +- `evidence`, `notes`, `primitives` + +Fields are normalized and validated. Underspecified input is marked +`underspecified` and capped at low confidence instead of being inflated into a +strong claim. + +## Primitive Vocabulary + +The first vocabulary is fixed and deterministic: + +`gradient`, `threshold`, `feedback`, `oscillation`, `decay`, `growth`, +`compression`, `symmetry`, `phase_transition`, `local_minimum`, `attractor`, +`resonance`, `interference`, `constraint_satisfaction`, `accumulation`, `flow`, +`lock`, `collapse`, `propagation`, `resistance`. + +These primitives are used as the auditable comparison surface. Labels are still +considered, but structural primitive overlap carries the main weight. + +## Comparison + +`compare_concept_fields(a, b)` normalizes both fields, builds deterministic +field signatures, and computes a weighted Jaccard overlap over category-aware +features: + +- labels inside each category +- primitives inside each category +- global primitive tags +- category weights for forces, constraints, thresholds, failure modes, and flows + +The result includes shared entities, forces, constraints, flows, thresholds, +attractors, and failure modes, plus similarity score, divergence score, overlap +explanation, breakpoint warnings, rejected matches, and a receipt. + +## Analogy Verification + +`verify_analogy(source, target)` wraps comparison with verifier gates. An +accepted analogy needs: + +- explicit overlap mechanisms +- places where the analogy works +- places where it breaks +- a prediction or consequence surface +- a counterexample or breakpoint + +Missing breakpoints prevent unbounded acceptance. Strong breakpoints reduce +confidence even when the surface overlap is real. + +## Receipts + +`export_receipt(result)` returns an audit payload with: + +- `inputs` +- `normalized_fields` +- `matching_logic` +- `score_calculation` +- `rejected_matches` +- `final_decision` + +This is the minimum receipt trail needed to check whether the system accepted an +analogy for explicit structural reasons. + +## Examples + +Built-in examples include `gravity`, `social_influence`, `debt`, +`technical_debt`, `learning`, and `operating_system`. + +### Debt vs Technical Debt + +`debt` and `technical_debt` score high because both expose accumulation, +compounding pressure, maintenance or servicing cost, repayment/refactor effort, +collapse thresholds, lock-in, and trust degradation. The analogy is bounded: +financial debt has formal legal/accounting enforcement, while technical debt is +enforced through engineering friction and delivery risk. + +### Gravity vs Social Influence + +`gravity` and `social_influence` share attraction, center/periphery structure, +distance decay, orbiting behavior, and central body influence. The verifier +flags major breakpoints: gravity is impersonal and mathematically invariant, +while social influence depends on agency, interpretation, culture, incentives, +and context. + +### Operating System as Programmable Physical State Transition + +An operating system is represented as a programmable state-transition manager +over physical compute resources. Its field includes process and kernel +entities, scheduling pressure, protection locks, permission thresholds, IO +flows, deadlock thresholds, and resource starvation collapse. The breakpoint is +that OS transitions are designed and discrete rather than continuous natural +fields. + +## CLI + +Run from the repository root: + +```bash +python3 -m reasoner.ts_reasoner.field_reasoning_cli compare debt technical_debt +python3 -m reasoner.ts_reasoner.field_reasoning_cli compare gravity social_influence +python3 -m reasoner.ts_reasoner.field_reasoning_cli verify-analogy gravity social_influence +python3 -m reasoner.ts_reasoner.field_reasoning_cli verify-analogy debt technical_debt --receipt +``` + +The CLI prints JSON so the score and receipt trail can be inspected directly. diff --git a/docs/native_cortex/NATIVE_CORTEX_CONTRACT.md b/docs/native_cortex/NATIVE_CORTEX_CONTRACT.md new file mode 100644 index 0000000..6ecf402 --- /dev/null +++ b/docs/native_cortex/NATIVE_CORTEX_CONTRACT.md @@ -0,0 +1,187 @@ +# Mega PRIME — Native Cortex + +Status: + + EXPERIMENTAL NATIVE LANGUAGE CORTEX + +Purpose: + + Give PRIME learned, distributed, recurrent linguistic competence while + preserving verifier sovereignty, provenance, observability and + interpretability. + +--- + +# Fundamental separation + +The cortex may: + + predict; + associate; + remember volatile context; + generate language; + route computation; + form distributed features; + propose semantic interpretations; + predict verifier outcomes. + +The cortex may NOT: + + mutate canonical PRIME knowledge; + authorize a proposition; + rewrite provenance; + delete receipts; + declare its own output true. + +Therefore: + + neural proposal != epistemic authority + +--- + +# Computational thesis + +The cortex is not a conventional Transformer. + +Its initial architecture combines: + + byte-level language modelling; + + recurrent matrix-valued delta memory; + + ternary learned projections; + + sparse mixture-of-experts computation; + + residual computation; + + streaming constant-size recurrent state. + +The purpose is to investigate language capability per unit compute rather than +maximum parameter count. + +--- + +# Memory hierarchy + +Level 1: + + volatile recurrent cortex state + +Level 2: + + future plastic / fast neural memory + +Level 3: + + PRIME canonical memory + +Important durable information should migrate upward rather than requiring +unbounded neural context. + +--- + +# Observability + +Observability is native to the forward architecture. + +Each observable cognitive step may emit TSObs data containing: + + token identity; + + model identity; + + recurrent-state norm; + + erase strength; + + write strength; + + selected experts; + + expert routing confidence; + + verifier-head prediction; + + output alternatives. + +Observability levels: + + O0 + hashes and health metrics + + O1 + routes, reads, writes and proposals + + O2 + compressed latent summaries + + O3 + selected forensic activation capture + +Normal execution targets O1. + +--- + +# Interpretability + +A neural feature may occupy one of three semantic states: + + UNKNOWN + + CHARACTERISED + + CRYSTALLISED + +UNKNOWN features are explicitly allowed. + +The system must never fabricate a semantic explanation merely because a +feature is useful. + +A feature may become CHARACTERISED through repeated activation analysis and +causal intervention. + +A sufficiently stable useful feature may produce a PRIME construction +proposal. + +Only verifier-backed constructions may become CRYSTALLISED canonical concepts. + +--- + +# Attribution + +Every consequential state mutation must identify its actor. + +Examples: + + optimizer update; + human modification; + cortex proposal; + verifier commit; + memory repair; + representation retirement. + +No component may rewrite its own historical telemetry. + +--- + +# Language + +The cortex's language model is competence, not canonical knowledge. + +Its outputs may be fluent and wrong. + +The PRIME verifier / memory architecture remains responsible for epistemic +status. + +--- + +# Initial scientific boundary + +The initial Native Cortex prototype is architecture development. + +Language fluency from a tiny training corpus is not a scientific capability +claim. + +The immediate target is a functional low-compute trainable language kernel +with native observability and streaming recurrent state. diff --git a/docs/native_cortex/NATIVE_CORTEX_CONTRACT.sha256 b/docs/native_cortex/NATIVE_CORTEX_CONTRACT.sha256 new file mode 100644 index 0000000..6219f88 --- /dev/null +++ b/docs/native_cortex/NATIVE_CORTEX_CONTRACT.sha256 @@ -0,0 +1 @@ +ce5a468d7e2f1c1537b2052ab5ce55167c7805bb8a829df5cc0e7d63c0a08d14 docs/native_cortex/NATIVE_CORTEX_CONTRACT.md diff --git a/docs/native_cortex/phase2/CORPUS_MANIFEST.json b/docs/native_cortex/phase2/CORPUS_MANIFEST.json new file mode 100644 index 0000000..c6250e3 --- /dev/null +++ b/docs/native_cortex/phase2/CORPUS_MANIFEST.json @@ -0,0 +1,44 @@ +{ + "characters": { + "development": 363245, + "heldout": 374209, + "train": 35167718 + }, + "counts": { + "development": 465, + "heldout": 462, + "train": 44073 + }, + "files": { + "development": { + "bytes": 456976, + "path": "data/native_cortex/splits/development.jsonl", + "sha256": "77f403f210f97c0e754ec7fecbde36738e5e0729e30f4725f8882acc1f79e41f" + }, + "heldout": { + "bytes": 467121, + "path": "data/native_cortex/splits/heldout.jsonl", + "sha256": "509907b29546ecee73f464f44dd53a6a809b3b80a5e1d3f27c25846ac083ae8c" + }, + "train": { + "bytes": 44061361, + "path": "data/native_cortex/splits/train.jsonl", + "sha256": "f69c1b1849b06324e6983d121a8dc7f007fb449adfcba432952f0a9acc3e795c" + } + }, + "format": "mega-prime-native-cortex-corpus-v1", + "sources": [ + { + "maximum_records_examined": 25000, + "source": "roneneldan/TinyStories", + "source_split": "train" + }, + { + "configuration": "wikitext-103-v1", + "maximum_accepted_records": 20000, + "source": "Salesforce/wikitext", + "source_split": "train" + } + ], + "split_policy": "sha256(document) mod 10000: 0..99 heldout, 100..199 development, 200..9999 train" +} \ No newline at end of file diff --git a/docs/native_cortex/phase2/CORPUS_MANIFEST.sha256 b/docs/native_cortex/phase2/CORPUS_MANIFEST.sha256 new file mode 100644 index 0000000..58719ed --- /dev/null +++ b/docs/native_cortex/phase2/CORPUS_MANIFEST.sha256 @@ -0,0 +1 @@ +4f08e29670b56a1ec4bdf38c374d07065b2d2e4261c05bff6130820a11781994 CORPUS_MANIFEST.json diff --git a/docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.md b/docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.md new file mode 100644 index 0000000..69d4534 --- /dev/null +++ b/docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.md @@ -0,0 +1,89 @@ +# Mega PRIME Native Cortex — Phase II + +## Purpose + +Test whether the Native Cortex can acquire reusable natural-language +competence efficiently from heterogeneous real prose. + +This phase evaluates: + +- unseen-language generalisation; +- token efficiency; +- recurrent-memory utility; +- expert-routing health; +- recurrent-state health; +- parameter efficiency; +- training throughput. + +## Dataset isolation + +Documents are assigned by SHA-256 content hash. + +TRAIN: + may be used for model fitting and tokenizer training. + +DEVELOPMENT: + may be evaluated during architecture development. + +HELDOUT: + must not be inspected, decoded, sampled, trained upon, or used for + architecture selection before the final evaluator and architecture are + separately frozen. + +Metadata such as document count, byte count and cryptographic hashes may be +recorded without revealing held-out content. + +## Primary development measurements + +- training cross entropy; +- development cross entropy; +- development perplexity; +- bits per UTF-8 byte; +- training tokens per second; +- parameter count. + +## Recurrent-memory diagnostic + +Compare: + + NORMAL + recurrent state persists between tokens; + + RESET + recurrent state is reset every token. + +Retained recurrence only earns architectural credit when it improves unseen +development prediction. + +## Sparse-expert diagnostic + +Measure: + +- utilization by expert; +- routing entropy; +- maximum expert share; +- routing confidence. + +A falling loss alone does not establish healthy expert specialization. + +## Recurrent-state diagnostic + +Measure: + +- state norms; +- read norms; +- erase strength; +- write strength; +- state growth over sequence length. + +## Authority + +Native Cortex authority is always: + + NONE + +Generated language and neural proposals are not canonical PRIME knowledge. + +## Heldout + +This document does not authorize held-out evaluation. diff --git a/docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.sha256 b/docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.sha256 new file mode 100644 index 0000000..6472d46 --- /dev/null +++ b/docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.sha256 @@ -0,0 +1 @@ +6c7079aa64e18e407de9fe8518d1e28608d0c495ab42c5f5aa8dc809d6286595 docs/native_cortex/phase2/DEVELOPMENT_PROTOCOL.md diff --git a/docs/native_cortex/phase2/DEVELOPMENT_RESULT.md b/docs/native_cortex/phase2/DEVELOPMENT_RESULT.md new file mode 100644 index 0000000..5929149 --- /dev/null +++ b/docs/native_cortex/phase2/DEVELOPMENT_RESULT.md @@ -0,0 +1,119 @@ +# Native Cortex Phase II — Development Result + +Status: + + DEVELOPMENT ONLY + +Architecture: + + BPE + ternary-effective projections + delta recurrent matrix memory + four top-1 sparse experts + 954,281 total parameters + +Training: + + 9,756,028-token training stream + 2,000 optimizer steps + batch size 8 + sequence length 128 + approximately 2.048 million token presentations + +Tokenizer: + + 4,096 vocabulary + development sequence reduction versus byte tokenization: + 3.609427x + + BPE round-trip failures: + 0 + +Development evaluation: + +NORMAL + + CE: + 5.9496 + + PPL: + 383.59 + + BPB: + 2.3732 + +RESET RECURRENT STATE EVERY TOKEN + + CE: + 6.2391 + + PPL: + 512.38 + + BPB: + 2.4886 + +RECURRENT BPB GAIN + + +0.1155 bits/byte + +Interpretation: + + Retained recurrent state materially improves prediction on unseen + development prose relative to the identical model with recurrent memory + reset every token. + +Routing: + +Layer 0 + + expert shares: + 0.242 + 0.301 + 0.260 + 0.197 + + maximum share: + 0.301 + + normalized entropy: + 0.992 + +Layer 1 + + expert shares: + 0.149 + 0.001 + 0.002 + 0.848 + + maximum share: + 0.848 + + normalized entropy: + 0.320 + +Layer 2 + + expert shares: + 0.000 + 0.000 + 1.000 + 0.000 + + maximum share: + 1.000 + + normalized entropy: + 0.001 + +Diagnosis: + + Deep sparse routing has collapsed. + + The recurrent memory has earned continued architectural use. + +Claim boundary: + + No held-out evaluation was performed. + No language-capability or general-intelligence claim is authorized. diff --git a/docs/native_cortex/prime_bridge/CONTRACT.md b/docs/native_cortex/prime_bridge/CONTRACT.md new file mode 100644 index 0000000..74bcb94 --- /dev/null +++ b/docs/native_cortex/prime_bridge/CONTRACT.md @@ -0,0 +1,96 @@ +# Mega PRIME — Cortex ↔ PRIME Bridge Contract + +## Purpose + +Connect the learned Native Cortex to the canonical verifier-first PRIME +substrate without transferring epistemic authority to the neural model. + +## Direction A — Language to PRIME + +raw text + -> cortex representation + -> semantic proposal + -> proposed TS structure + -> PRIME verifier + -> verdict / repair / abstention + -> receipt + +Cortex proposals use: + + provenance = model_proposer + status = proposed + +A neural proposal is never canonical by construction. + +## Direction B — PRIME to Cortex + +verifier outcome + -> labelled neural experience + -> verifier-prediction learning + -> representation repair learning + +The cortex may learn to predict PRIME's future decision. + +Prediction of authority is not authority. + +## Bootstrap semantics + +During initial bridge development the existing deterministic TSLC compiler +acts as a semantic teacher. + +The cortex learns: + + text -> TSLC-style semantic proposal + +This is distillation of representation, not epistemic truth. + +The compiled proposal is independently passed to PRIME verification. + +## Verifier labels + +UNKNOWN +ACCEPT +REJECT +REPAIR +ABSTAIN + +## Provenance + +Every bridge training record contains: + + source hash + semantic proposal hash + verifier result + verifier-result hash + parent experience hash + deterministic experience hash + +The experience ledger is append-only and hash chained. + +## Failure policy + +Invalid neural semantic output: + + does not reach canonical mutation + is recorded as failed proposal + authority remains NONE + +Verifier exception: + + produces UNKNOWN + does not become ACCEPT + +## Dataset isolation + +TRAIN may produce bridge training records. + +DEVELOPMENT may produce evaluation records. + +HELDOUT remains forbidden. + +## Canonical rule + + suggestion != authority + +The component that learns from verifier decisions is not the component that +makes those decisions. diff --git a/docs/native_cortex/prime_bridge/CONTRACT.sha256 b/docs/native_cortex/prime_bridge/CONTRACT.sha256 new file mode 100644 index 0000000..f3f461d --- /dev/null +++ b/docs/native_cortex/prime_bridge/CONTRACT.sha256 @@ -0,0 +1 @@ +4ea25d9dbc0cd6333df325a46d64b09fe9fe167fbf8ff1c28991b1d9535d5ede docs/native_cortex/prime_bridge/CONTRACT.md diff --git a/docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.md b/docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.md new file mode 100644 index 0000000..c3a24d4 --- /dev/null +++ b/docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.md @@ -0,0 +1,322 @@ +# Mega PRIME Cortex-PRIME Bridge Development Result + +State date: 2026-08-25 + +## Status + +This document freezes the observed development result of the first Cortex-PRIME mixed-learning bridge experiment. + +The full preregistered verifier gate FAILED. + +This result must not later be rewritten as a successful five-way verifier result. + +## Core invariant + +Neural prediction is not epistemic authority. + +The Native Cortex may propose and predict. + +Canonical PRIME verifiers remain authoritative. + +## Base Native Cortex checkpoint + +Path: +artifacts/native_cortex/v1/cortex-v1-final.pt + +SHA256: +abf0d27a0fb29cb1d91853f4ff83c77720fbe3abb60477000448663553253cdd + +## Bridge checkpoints + +Step-2000 path: +artifacts/native_cortex/prime-bridge-v1/cortex-prime-step-002000.pt + +Step-2000 SHA256: +e3c7790e988cf64612ef37ca302374cae6467885206a1128683f95a6b90a1b98 + +Final path: +artifacts/native_cortex/prime-bridge-v1/cortex-prime-final.pt + +Final SHA256: +aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1 + +## Training programme + +Total optimizer steps: +2000 + +Learning rate: +8e-5 + +Task mixture: +50 percent language modelling +30 percent semantic proposal learning +20 percent verifier prediction + +Semantic records: +6000 + +Verifier records: +2500 + +Verifier curriculum: +UNKNOWN 500 +ACCEPT 500 +REJECT 500 +REPAIR 500 +ABSTAIN 500 + +Authority: +NONE + +## Exposure limitation + +Approximate verifier updates: +400 + +Expected unique verifier examples seen under random sampling with replacement: +approximately 370 of 2500 + +Approximate semantic updates: +600 + +Expected unique semantic examples seen: +approximately 571 of 6000 + +Therefore this experiment was an initial-exposure bridge experiment, not curriculum saturation. + +## Language retention + +Pre-bridge Native Cortex V1 development BPB: +2.0788 + +Post-bridge development BPB: +2.0821 + +Difference: ++0.0033 BPB + +Approximate relative degradation: +0.16 percent + +Frozen language-retention ceiling: +2.1788 BPB + +Language-retention gate: +PASS + +## Post-bridge ablations + +NORMAL: +CE 5.2200 +PPL 184.93 +BPB 2.0821 + +RESET recurrence: +CE 5.4734 +PPL 238.26 +BPB 2.1832 + +NO local attention: +CE 5.4408 +PPL 230.63 +BPB 2.1702 + +Recurrent contribution: ++0.1011 BPB + +Local-attention contribution: ++0.0881 BPB + +Both architectural mechanisms retained measurable utility after bridge training. + +## Routing health + +Layer 0: +0.178 0.179 0.117 0.176 0.205 0.146 + +Layer 1: +0.186 0.158 0.178 0.183 0.147 0.148 + +Layer 2: +0.211 0.162 0.202 0.126 0.157 0.142 + +Layer 3: +0.177 0.107 0.161 0.188 0.181 0.187 + +Approximate normalized routing entropy: +L0 0.992 +L1 0.997 +L2 0.991 +L3 0.991 + +There was no recurrence of the earlier catastrophic deep-expert collapse. + +Balanced routing is not evidence of semantic expert specialization. + +## Verifier development evaluation + +Development examples: +500 + +Examples per class: +100 + +Overall accuracy: +0.7960 + +Macro class accuracy: +0.7960 + +Minimum class accuracy: +0.0000 + +Per-class accuracy: +UNKNOWN 1.0000 +ACCEPT 0.0000 +REJECT 1.0000 +REPAIR 0.9800 +ABSTAIN 1.0000 + +Prediction distribution: +UNKNOWN 100 +ACCEPT 0 +REJECT 202 +REPAIR 98 +ABSTAIN 100 + +Confusion matrix: + +true/pred UNKNOWN ACCEPT REJECT REPAIR ABSTAIN +UNKNOWN 100 0 0 0 0 +ACCEPT 0 0 100 0 0 +REJECT 0 0 100 0 0 +REPAIR 0 0 2 98 0 +ABSTAIN 0 0 0 0 100 + +Balanced chance: +0.20 + +## Frozen verifier gates + +Required: +overall accuracy greater than 0.60 +macro class accuracy greater than 0.60 +minimum per-class accuracy greater than 0.35 + +Observed: +overall gate PASS +macro gate PASS +minimum-class gate FAIL + +FULL FROZEN VERIFIER GATE: +FAIL + +The criterion must not be moved after observing the result. + +## Interpretation + +The approximately 79.6 percent aggregate result does not establish full verifier semantics. + +The learned behaviour was approximately: + +UNKNOWN -> UNKNOWN +ACCEPT -> REJECT +REJECT -> REJECT +REPAIR -> REPAIR +ABSTAIN -> ABSTAIN + +On five equally balanced classes this shortcut produces approximately 80 percent accuracy. + +The most defensible conclusion is: + +The cortex learned broad PRIME operational outcome topology but did not learn the internal pass/fail semantics of typed verification. + +## Prompt-collision diagnostic + +Development prompts: +500 + +Unique prompts: +500 + +Exact cross-label prompt collisions: +0 + +The ACCEPT failure therefore cannot be explained by ACCEPT and REJECT being serialized into identical neural inputs. + +The verifier-relevant distinction was present. + +## Current obstruction + +Current behaviour: + +typed obligation +-> broad outcome-family recognition + +Target behaviour: + +typed obligation +-> verifier-relevant relational or computational distinction +-> correct ACCEPT or REJECT prediction + +Three hypotheses remain distinct: + +1. insufficient verifier exposure +2. shortcut-friendly curriculum structure +3. insufficient learned relational or computational semantics + +These hypotheses must not be conflated. + +## Next development programme + +Verifier Semantics / Counterfactual Bridge Development + +The next curriculum should contain paired ACCEPT and REJECT examples where surface form is held as constant as practical and only the verifier-relevant fact changes. + +Example: + +37 + 18 = 55 -> ACCEPT +37 + 18 = 56 -> REJECT + +The evaluator must be built before training. + +It must include: + +paired ACCEPT/REJECT joint correctness +within-channel ACCEPT/REJECT accuracy +ACCEPT-minus-REJECT score margins +paired margin reversal +five-way class metrics +language-retention evaluation + +A control must compare: + +existing curriculum plus substantially greater verifier exposure + +against: + +paired counterfactual curriculum with comparable exposure + +This is required to distinguish underexposure from curriculum shortcutting. + +## Held-out discipline + +Native Cortex held-out SHA256: +509907b29546ecee73f464f44dd53a6a809b3b80a5e1d3f27c25846ac083ae8c + +The held-out split remains untouched. + +M26 held-out seeds also remain untouched. + +## Canonical conclusion + +The first Cortex-PRIME bridge experiment demonstrated that PRIME-shaped continual neural training can occur while preserving essentially all previously measured language competence and maintaining healthy recurrent, local-attention and sparse-MoE behaviour. + +It also demonstrated substantial learning of PRIME operational outcome families. + +However, the experiment FAILED its full preregistered verifier gate because ACCEPT accuracy was 0 percent. + +The cortex therefore did not demonstrate genuine five-way typed verifier semantics. + +This failure is preserved as a canonical research result. diff --git a/docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.sha256 b/docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.sha256 new file mode 100644 index 0000000..2f557d6 --- /dev/null +++ b/docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.sha256 @@ -0,0 +1 @@ +d3519434481796791c1868796bb15eb67629c221edbbf749a38db174b69126e2 docs/native_cortex/prime_bridge/DEVELOPMENT_RESULT.md diff --git a/docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.json b/docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.json new file mode 100644 index 0000000..eefc015 --- /dev/null +++ b/docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.json @@ -0,0 +1,37 @@ +{ + "authority": "NONE", + "format": "mega-prime-typed-verifier-curriculum-v1", + "mapping": { + "error": "UNKNOWN", + "fail": "REJECT", + "open_repair": "REPAIR", + "pass": "ACCEPT", + "unsupported": "ABSTAIN" + }, + "splits": { + "development": { + "final_experience_hash": "67badef46960dfc7d9577db235703dceeff3705151fdf4f2b715893dca3a0b66", + "labels": { + "ABSTAIN": 100, + "ACCEPT": 100, + "REJECT": 100, + "REPAIR": 100, + "UNKNOWN": 100 + }, + "records": 500, + "sha256": "071305f8af9974b9014a297dbcf2058aa768ccb80224ef962b184447c61c2f57" + }, + "train": { + "final_experience_hash": "df94328268e5026a6a2568e96754f78816736e315d4e2cf3e08216d6db1d2f7d", + "labels": { + "ABSTAIN": 500, + "ACCEPT": 500, + "REJECT": 500, + "REPAIR": 500, + "UNKNOWN": 500 + }, + "records": 2500, + "sha256": "09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516" + } + } +} \ No newline at end of file diff --git a/docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.sha256 b/docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.sha256 new file mode 100644 index 0000000..3a5d516 --- /dev/null +++ b/docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.sha256 @@ -0,0 +1 @@ +5331486efcdff7b2620892eebc7dab7b40f62467a45f1df7d1906800b5b80e9b docs/native_cortex/prime_bridge/TYPED_CURRICULUM_MANIFEST.json diff --git a/docs/native_cortex/v1/ARCHITECTURE.md b/docs/native_cortex/v1/ARCHITECTURE.md new file mode 100644 index 0000000..82a13a4 --- /dev/null +++ b/docs/native_cortex/v1/ARCHITECTURE.md @@ -0,0 +1,195 @@ +# Mega PRIME — Native Cortex V1 + +Status: + + FROZEN DEVELOPMENT ARCHITECTURE + +Purpose: + + Build the first serious PRIME-native low-compute language cortex. + +The design combines: + + efficient learned tokenization; + multi-timescale recurrent fast memory; + exact bounded local attention; + sparse expert computation; + low-bit effective projections; + predictive latent learning; + native observability. + +The cortex remains epistemically non-authoritative. + +--- + +# Model + +Vocabulary: + + 4096 BPE tokens + +Model width: + + 192 + +Layers: + + 4 + +Recurrent memory heads: + + 6 + +Approximate recurrent half-life priors: + + 4 tokens + 12 tokens + 32 tokens + 96 tokens + 256 tokens + 768 tokens + +Sparse experts per layer: + + 6 + +Expert hidden dimension: + + 384 + +Training routing: + + top-2 + +Inference routing: + + top-1 + +Local attention: + + every second layer + +Local attention window: + + 64 tokens + +Attention heads: + + 6 + +Vocabulary decoder: + + factorized + + 192 + -> 64 + -> 4096 + +This avoids a dense 192 x 4096 output projection. + +--- + +# Learning objectives + +Primary: + + causal next-token prediction + +Auxiliary: + + future latent-state prediction + +Router objectives: + + load balancing; + router logit regularization; + entropy encouragement. + +Router regularization is stronger early in training and anneals as the cortex +develops. + +--- + +# Memory + +Each recurrent head has a different prior retention timescale. + +Dynamic erase and write gates modulate those priors. + +The architecture is intended to support simultaneous: + + short linguistic state; + clause-scale state; + discourse-scale state; + long-lived contextual state. + +--- + +# Observability + +Development evaluation records: + + expert usage; + routing entropy; + routing confidence; + recurrent-state norm; + erase strength; + write strength; + retention strength; + local-attention entropy. + +--- + +# Mandatory ablations + +NORMAL + + full architecture + +RESET_RECURRENCE + + recurrent matrix state is erased each token; + local attention remains available + +NO_LOCAL_ATTENTION + + recurrent state remains; + exact local-attention workspace is disabled + +These distinguish the utility of the two memory mechanisms. + +--- + +# Authority + +The Native Cortex may propose. + +It may not: + + authorize knowledge; + write canonical PRIME state; + mutate receipts; + declare generated language true. + +Cortex authority is always: + + NONE + +--- + +# Dataset boundary + +TRAIN: + + permitted for fitting + +DEVELOPMENT: + + permitted for architecture analysis + +HELDOUT: + + forbidden during V1 development + +Held-out evaluation requires a separately frozen evaluator after V1 +architecture development is complete. diff --git a/docs/native_cortex/v1/ARCHITECTURE.sha256 b/docs/native_cortex/v1/ARCHITECTURE.sha256 new file mode 100644 index 0000000..a146b77 --- /dev/null +++ b/docs/native_cortex/v1/ARCHITECTURE.sha256 @@ -0,0 +1 @@ +c148722ab84aa9d7b6ef4058d59fe1dc45c583d82d9f0e6753804951426b3876 docs/native_cortex/v1/ARCHITECTURE.md diff --git a/docs/native_cortex/v1/DEVELOPMENT_RESULT.md b/docs/native_cortex/v1/DEVELOPMENT_RESULT.md new file mode 100644 index 0000000..bdbca06 --- /dev/null +++ b/docs/native_cortex/v1/DEVELOPMENT_RESULT.md @@ -0,0 +1,54 @@ +# Mega PRIME Native Cortex V1 — Development Result + +Status: DEVELOPMENT ONLY + +Parameters: + 5,552,205 + +Training: + 2,000 optimizer steps + batch size 4 + sequence length 128 + BPE vocabulary 4096 + +Development language: + +NORMAL + CE = 5.2115 + PPL = 183.38 + BPB = 2.0788 + +RESET_RECURRENCE + CE = 5.4520 + PPL = 233.22 + BPB = 2.1747 + +NO_LOCAL_ATTENTION + CE = 5.4470 + PPL = 232.07 + BPB = 2.1727 + +Recurrent contribution: + +0.0959 BPB + +Local-attention contribution: + +0.0939 BPB + +Routing: + +L0 H=0.991 max expert share=0.205 +L1 H=0.999 max expert share=0.178 +L2 H=0.992 max expert share=0.201 +L3 H=0.994 max expert share=0.195 + +Diagnosis: + + Multi-timescale recurrence contributes on unseen prose. + Local exact attention independently contributes on unseen prose. + The previous deep MoE collapse has been eliminated. + Balanced utilization does not yet establish semantic specialization. + +Authority: + NONE + +No held-out evaluation was performed. diff --git a/docs/native_cortex/v1/DEVELOPMENT_RESULT.sha256 b/docs/native_cortex/v1/DEVELOPMENT_RESULT.sha256 new file mode 100644 index 0000000..7ad9270 --- /dev/null +++ b/docs/native_cortex/v1/DEVELOPMENT_RESULT.sha256 @@ -0,0 +1 @@ +54367b5bd3018e7c3ee0336d5c8dbd4f05c6599af578eb39909d62e61139cf51 docs/native_cortex/v1/DEVELOPMENT_RESULT.md diff --git a/docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.md b/docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.md new file mode 100644 index 0000000..bc20814 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.md @@ -0,0 +1,177 @@ +# PRIME Native Cortex Verifier Semantics A/B Development Result + +State date: 2026-08-27 + +## Status + +The frozen A/B development experiment is complete. + +Neither condition passes the full verifier-semantics gate. + +Condition B nevertheless produces a substantial and strongly channel-specific counterfactual learning effect relative to Condition A. + +Authority remains NONE. + +## Common starting checkpoint + +SHA256: + +aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1 + +Both conditions independently started from this checkpoint. + +## Condition A + +Name: +exposure_control + +Final checkpoint SHA256: +73d40bb229a1ac738e5148e67b171f7f8f8f4c6338b2454bcc0186e2a41c4df0 + +Unique verifier records presented: +2500 / 2500 + +## Condition B + +Name: +counterfactual_paired + +Final checkpoint SHA256: +440b668de1c310e6a7eded47a68da7b8f6977f4b0f36abc1fc22e205d3939e74 + +Unique verifier records presented: +2500 / 2500 + +## Aggregate comparison + +Condition A accuracy: +0.7660 + +Condition B accuracy: +0.8400 + +Delta: ++0.0740 + +Condition A macro accuracy: +0.7660 + +Condition B macro accuracy: +0.8400 + +Delta: ++0.0740 + +## ACCEPT / REJECT + +Condition A ACCEPT: +0.3400 + +Condition B ACCEPT: +1.0000 + +Condition A REJECT: +0.6600 + +Condition B REJECT: +0.3500 + +## Paired semantics + +Condition A pair accuracy: +0.0000 + +Condition B pair accuracy: +0.3500 + +Condition A margin reversal: +0.0000 + +Condition B margin reversal: +0.3500 + +Condition A mean margin flip: ++0.019857 + +Condition B mean margin flip: ++0.635267 + +## Within-channel ACCEPT / REJECT + +Arithmetic: +A = 0.5000 +B = 0.5294 + +Structural: +A = 0.5000 +B = 1.0000 + +Code property: +A = 0.5000 +B = 0.5000 + +## Pair correctness by channel + +Arithmetic: +A = 0.0000 +B = 0.0588 + +Structural: +A = 0.0000 +B = 1.0000 + +Code property: +A = 0.0000 +B = 0.0000 + +## Main scientific result + +Complete exposure to the original curriculum was not sufficient to produce counterfactual verifier semantics. + +Condition A saw all 2500 verifier records exactly once but retained: + +pair accuracy = 0.0000 + +margin reversal = 0.0000 + +and chance-level within-channel ACCEPT/REJECT discrimination. + +Matched counterfactual training changed this substantially. + +Condition B reached: + +pair accuracy = 0.3500 + +margin reversal = 0.3500 + +and a strongly positive mean pair margin flip. + +The effect was highly channel-specific. + +Structural verification reached: + +within-channel accuracy = 1.0000 + +pair accuracy = 1.0000 + +Arithmetic remained near chance. + +Code-property verification remained at chance. + +## Interpretation + +The experiment provides development evidence that counterfactual training geometry matters beyond verifier exposure alone. + +It does not establish general typed verifier semantics. + +The strongest supported interpretation is: + +The Native Cortex can learn an explicit relational verifier distinction when the verifier-relevant feature is directly represented in the observation, but the current training objective and architecture do not yet reliably learn computational verifier semantics requiring arithmetic evaluation or bounded program execution. + +Both conditions FAIL the frozen full verifier-semantics gate. + +Do not run held-out. + +Do not weaken the verifier. + +Do not reinterpret Condition B as full verifier-semantics success. diff --git a/docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.sha256 b/docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.sha256 new file mode 100644 index 0000000..b9800e6 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.sha256 @@ -0,0 +1 @@ +1a92e3d69d872c5f8df49dd3f456f95ecc994e987d00ff1e1bb554b197754f81 docs/native_cortex/verifier_semantics/AB_DEVELOPMENT_RESULT.md diff --git a/docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.md b/docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.md new file mode 100644 index 0000000..365583d --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.md @@ -0,0 +1,252 @@ +# PRIME Native Cortex Verifier Semantics A/B Experiment + +State date: 2026-08-25 + +## Purpose + +Separate two explanations for the first Cortex-PRIME verifier failure: + +H1: +insufficient verifier exposure + +H2: +shortcut-friendly verifier curriculum geometry + +## Starting checkpoint + +Both conditions start independently from the same frozen first-bridge checkpoint. + +SHA256: + +aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1 + +Neither condition continues from the other. + +## Condition A + +Name: + +exposure_control + +Verifier curriculum: + +the original frozen five-way typed verifier curriculum + +Train SHA256: + +09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516 + +Purpose: + +Test whether complete verifier-curriculum exposure alone eliminates the ACCEPT obstruction. + +## Condition B + +Name: + +counterfactual_paired + +Verifier curriculum: + +the matched counterfactual five-way curriculum + +Train SHA256: + +b7ebab7b3b8bcee3a476a7a13cc41e356b2e25ba8c6f2c15b2c83e7994252025 + +Purpose: + +Test whether changing training geometry so that ACCEPT and REJECT differ only in verifier-relevant facts improves genuine pass/fail discrimination. + +## Controlled variables + +Both conditions use: + +the same starting checkpoint + +the same optimizer state from that checkpoint + +the same learning rate + +the same model architecture + +the same semantic replay stream + +the same LM replay stream + +the same total optimizer-step count + +the same LM optimizer-step count + +the same semantic optimizer-step count + +the same verifier optimizer-step count + +the same verifier presentation count + +the same verifier class balance + +the same max sequence length + +the same seed policy + +the same development evaluator + +the same frozen counterfactual development set + +the same language-retention evaluator + +The treatment variable is verifier curriculum only. + +## Stage-1 training schedule + +Total optimizer steps: + +1000 + +For every ten optimizer steps: + +3 LM steps + +2 semantic steps + +5 verifier steps + +Therefore: + +LM optimizer steps: +300 + +semantic optimizer steps: +200 + +verifier optimizer steps: +500 + +## Verifier microbatch + +Each verifier optimizer step accumulates gradients from: + +5 verifier examples + +before one optimizer update. + +Therefore total verifier presentations are: + +500 * 5 = 2500 + +Both verifier curricula contain exactly: + +2500 records. + +## Coverage rule + +Verifier examples are shuffled deterministically without replacement. + +Stage 1 presents every verifier curriculum record exactly once. + +Required: + +verifier presentations = 2500 + +unique verifier records seen = 2500 + +No verifier record may be omitted. + +No verifier record may be repeated during Stage 1. + +This removes the approximately 15-percent unique-exposure limitation of the first bridge experiment. + +## Neural update rule + +The complete Native Cortex remains trainable. + +The verifier objective remains ordinary five-way cross entropy. + +The router regularizer remains active. + +Gradient norm remains clipped to: + +1.0 + +No contrastive pair-specific loss is introduced in Stage 1. + +This is deliberate. + +Condition B tests whether counterfactual curriculum geometry alone improves semantics before introducing a specialized paired loss. + +## Optimizer + +Continue the AdamW optimizer state stored in the frozen bridge checkpoint. + +Learning rate: + +8e-5 + +Both conditions use the same optimizer continuation procedure. + +## Seed + +26082511 + +LM/semantic sampling and verifier ordering use separated deterministic random streams so changing verifier curriculum contents cannot alter LM or semantic sampling choices. + +## Development evaluator + +Both trained conditions are evaluated against the same frozen counterfactual development curriculum. + +Development SHA256: + +39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587 + +The previously frozen verifier-semantics gates remain unchanged. + +## Language retention + +Both conditions must rerun the existing Native Cortex V1 development language evaluator. + +Reference: + +pre-bridge V1 = 2.0788 BPB + +first bridge = 2.0821 BPB + +Frozen retention ceiling: + +2.1788 BPB + +## Interpretation matrix + +If Condition A passes and Condition B passes: + +underexposure was likely a substantial contributor; paired geometry may or may not provide additional benefit. + +If Condition A passes and Condition B fails: + +paired construction harmed learning under the tested protocol. + +If Condition A fails and Condition B passes: + +curriculum shortcut geometry was the stronger demonstrated obstruction. + +If both fail: + +one complete verifier epoch with ordinary five-way cross entropy was insufficient under both curricula. + +A both-fail result does not prove architecture incapacity. + +A later second-epoch or paired-loss experiment would require a separately frozen extension protocol. + +## Authority + +The neural verifier head has authority NONE. + +Canonical PRIME verifiers remain authoritative. + +## Held-out discipline + +No held-out corpus data is accessed. + +M26 held-out seeds remain untouched. + +This experiment is development-only. diff --git a/docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.sha256 b/docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.sha256 new file mode 100644 index 0000000..9abe60d --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.sha256 @@ -0,0 +1 @@ +5453cfbf7f3ce0fd87b28ca5aef70089ffdd1df82308f01e8a3bda76ff36b6f7 docs/native_cortex/verifier_semantics/AB_EXPERIMENT_PROTOCOL.md diff --git a/docs/native_cortex/verifier_semantics/AB_INPUTS.json b/docs/native_cortex/verifier_semantics/AB_INPUTS.json new file mode 100644 index 0000000..79adf15 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_INPUTS.json @@ -0,0 +1,18 @@ +{ + "authority": "NONE", + "base_checkpoint_sha256": "aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1", + "counterfactual_development_sha256": "39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587", + "counterfactual_train_sha256": "b7ebab7b3b8bcee3a476a7a13cc41e356b2e25ba8c6f2c15b2c83e7994252025", + "exposure_control_train_sha256": "09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516", + "format": "mega-prime-verifier-semantics-ab-input-lock-v1", + "lm_stream_sha256": "92e4b2f50aed7dd95a94fc964affcda019253c8edd86580e2e3d0033c4a04963", + "paths": { + "base_checkpoint": "artifacts/native_cortex/prime-bridge-v1/cortex-prime-final.pt", + "counterfactual_development": "data/native_cortex/verifier_semantics/counterfactual_v1/development.jsonl", + "counterfactual_train": "data/native_cortex/verifier_semantics/counterfactual_v1/train.jsonl", + "exposure_control_train": "data/native_cortex/prime_bridge/curriculum/train.jsonl", + "lm_stream": "data/native_cortex/tokens/train.bin", + "semantic_train": "data/native_cortex/prime_bridge/train/semantic.jsonl" + }, + "semantic_train_sha256": "4f0bd8a514a6160a466c52ab719f9035d29777558faecbcc7feb161c36336d4b" +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/AB_INPUTS.sha256 b/docs/native_cortex/verifier_semantics/AB_INPUTS.sha256 new file mode 100644 index 0000000..a79cca7 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_INPUTS.sha256 @@ -0,0 +1 @@ +14ba1864bb5b340b14767347a13dfd697f2a3a93170b6f014accfc0666944261 docs/native_cortex/verifier_semantics/AB_INPUTS.json diff --git a/docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.md b/docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.md new file mode 100644 index 0000000..4f2ae2e --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.md @@ -0,0 +1,127 @@ +# PRIME Native Cortex Verifier Semantics A/B Language Retention + +State date: 2026-08-27 + +## Retention criterion + +Frozen NORMAL development retention ceiling: + +2.1788 BPB + +The RESET_RECURRENCE and NO_LOCAL_ATTENTION measurements are diagnostic ablations, not retention gates. + +## Reference measurements + +Native Cortex V1 before bridge training: + +NORMAL BPB = 2.0788 + +First Cortex-PRIME bridge: + +NORMAL BPB = 2.0821 + +## Condition A: exposure control + +Final checkpoint SHA256: + +73d40bb229a1ac738e5148e67b171f7f8f8f4c6338b2454bcc0186e2a41c4df0 + +NORMAL: + +CE = 5.2159 +PPL = 184.17 +BPB = 2.0805 + +RESET_RECURRENCE: + +BPB = 2.1850 + +NO_LOCAL_ATTENTION: + +BPB = 2.1704 + +Recurrent BPB contribution: + ++0.1045 + +Local-attention BPB contribution: + ++0.0899 + +Retention result: + +PASS + +## Condition B: counterfactual paired + +Final checkpoint SHA256: + +440b668de1c310e6a7eded47a68da7b8f6977f4b0f36abc1fc22e205d3939e74 + +NORMAL: + +CE = 5.2068 +PPL = 182.52 +BPB = 2.0769 + +RESET_RECURRENCE: + +BPB = 2.1757 + +NO_LOCAL_ATTENTION: + +BPB = 2.1695 + +Recurrent BPB contribution: + ++0.0988 + +Local-attention BPB contribution: + ++0.0926 + +Retention result: + +PASS + +## Comparison + +Condition A NORMAL BPB: + +2.0805 + +Condition B NORMAL BPB: + +2.0769 + +B minus A: + +-0.0036 BPB + +The difference is too small to interpret as evidence of meaningful language improvement. + +The important result is that both conditions remain below the frozen language-retention ceiling. + +## Combined interpretation + +The counterfactual-paired condition changed verifier behaviour without catastrophic degradation of the Native Cortex language model. + +Condition B nevertheless remains a partial verifier-semantics result. + +It achieved: + +35 percent matched-pair accuracy + +35 percent margin reversal + +100 percent structural matched-pair accuracy + +while arithmetic remained near chance and code-property matched-pair accuracy remained zero. + +Therefore the supported development result is that matched counterfactual supervision can teach an explicit relational verifier distinction while preserving language capability, but general computational verifier semantics have not yet been demonstrated. + +The full frozen verifier-semantics gate remains failed. + +Authority remains NONE. + +No held-out data was accessed. diff --git a/docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.sha256 b/docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.sha256 new file mode 100644 index 0000000..cfee971 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.sha256 @@ -0,0 +1 @@ +51f7cdce0d844349bc23005092b70e2236d59383c880794f7b96c191dbd68a25 docs/native_cortex/verifier_semantics/AB_LANGUAGE_RETENTION.md diff --git a/docs/native_cortex/verifier_semantics/CONTRACT.md b/docs/native_cortex/verifier_semantics/CONTRACT.md new file mode 100644 index 0000000..710e44c --- /dev/null +++ b/docs/native_cortex/verifier_semantics/CONTRACT.md @@ -0,0 +1,208 @@ +# PRIME Native Cortex Verifier Semantics / Counterfactual Bridge Contract + +State date: 2026-08-25 + +## Purpose + +Directly attack the demonstrated Cortex-PRIME verifier obstruction: + +ACCEPT accuracy = 0 + +without weakening canonical PRIME verifiers, moving development gates, accessing held-out data, or transferring authority to the neural cortex. + +## Core invariant + +prediction != authority + +The neural verifier head remains a predictor. + +Canonical PRIME verifier output remains authoritative. + +## Hypothesis H1: underexposure + +The first bridge may have failed ACCEPT because only approximately 400 verifier optimizer updates occurred against a 2500-record curriculum. + +## Hypothesis H2: shortcut curriculum + +The first five-way curriculum may have allowed the cortex to identify broad outcome families without learning the actual ACCEPT versus REJECT distinction. + +These hypotheses must be separated experimentally. + +## Condition A: exposure control + +Reuse the existing frozen verifier curriculum. + +Provide substantially greater verifier exposure. + +Do not alter its canonical labels or underlying verifier semantics. + +Purpose: + +Test whether additional exposure alone produces genuine ACCEPT/REJECT discrimination. + +## Condition B: paired counterfactual semantics + +Construct matched ACCEPT/REJECT pairs. + +Within each pair keep channel, wording, entities, formatting and irrelevant information as constant as practical. + +Change only the verifier-relevant fact. + +Arithmetic example: + +37 + 18 = 55 -> ACCEPT +37 + 18 = 56 -> REJECT + +Structural example: + +object_declared=True -> ACCEPT +object_declared=False -> REJECT + +Code-property example: + +same program +same invocation +expected=13 -> ACCEPT +expected=14 -> REJECT + +Canonical typed verifiers must generate the labels. + +## Development-only rule + +TRAIN and DEVELOPMENT may be used. + +HELDOUT remains forbidden. + +M26 held-out seeds also remain untouched. + +## Evaluator-before-training rule + +The paired development evaluator must be implemented and frozen before running paired training. + +It must measure: + +1. overall five-way accuracy +2. macro class accuracy +3. minimum class accuracy +4. ACCEPT accuracy +5. REJECT accuracy +6. within-channel ACCEPT/REJECT accuracy +7. matched-pair joint correctness +8. ACCEPT-minus-REJECT margin on positive examples +9. ACCEPT-minus-REJECT margin on negative examples +10. paired margin reversal +11. prediction distribution +12. confusion matrix +13. language retention + +## Matched-pair correctness + +For every pair consisting of an ACCEPT member and its matched REJECT counterfactual: + +pair_correct = 1 only when both predictions are correct. + +Predicting REJECT for both receives zero pair credit. + +Primary paired score: + +PAIR_ACC = mean(pair_correct) + +## Margin metric + +Define: + +m(x) = p(ACCEPT | x) - p(REJECT | x) + +For a correct matched pair we want: + +m(positive) > 0 +m(negative) < 0 + +Define: + +margin_flip = m(positive) - m(negative) + +A larger positive margin_flip indicates stronger counterfactual sensitivity. + +## Required channels + +At minimum: + +arithmetic +structural +code_property + +Channel identity must not determine the label. + +## Language retention + +Every verifier-semantics condition must rerun the existing Native Cortex V1 development language evaluator. + +Reference BPB values: + +pre-bridge V1: +2.0788 + +first bridge: +2.0821 + +Existing retention ceiling: +2.1788 + +Do not alter the threshold after observing a new result. + +## Verifier integrity + +Do not alter canonical verifier behaviour to improve neural accuracy. + +Do not manually relabel failed examples. + +Do not manufacture ACCEPT or REJECT labels without executing the corresponding typed canonical verifier. + +## Provenance + +Each paired record should contain: + +pair_id +pair_member +channel +premises +obligation +canonical verifier result +canonical label +counterfactual field +counterfactual value +construction metadata +record hash +pair hash +authority = NONE + +## Scientific interpretation + +Success establishes only development-set learning of typed pass/fail distinctions under the tested channels and curriculum. + +It does not establish general reasoning, general verification, theorem proving, or epistemic authority. + +Failure remains a valid result. + +Do not move gates after observing results. + +## Next programme after genuine verifier semantics + +Only after actual ACCEPT/REJECT discrimination is demonstrated should the programme advance toward: + +proposal +-> verifier result +-> obstruction +-> minimal repair +-> neural repair learning + +and later: + +raw language +-> typed semantic proposal +-> obligation discovery +-> verifier routing +-> verification +-> repair +-> learning diff --git a/docs/native_cortex/verifier_semantics/CONTRACT.sha256 b/docs/native_cortex/verifier_semantics/CONTRACT.sha256 new file mode 100644 index 0000000..0046a97 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/CONTRACT.sha256 @@ -0,0 +1 @@ +3bb8cbdbb80da3614b9b7eb3c5a7d79ca915f902faf8b44ad4b9801ecc40c778 docs/native_cortex/verifier_semantics/CONTRACT.md diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.json b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.json new file mode 100644 index 0000000..68bc5fc --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.json @@ -0,0 +1,49 @@ +{ + "authority": "NONE", + "builder_sha256": "67375d2cf227de6019642d5464d20855ca00e73d9e6292aef42e62c7f7a97590", + "construction": "matched ACCEPT/REJECT canonical typed verifier pairs plus frozen v1 UNKNOWN/REPAIR/ABSTAIN controls", + "format": "mega-prime-counterfactual-verifier-curriculum-v1", + "seed": 26082501, + "source_development_sha256": "071305f8af9974b9014a297dbcf2058aa768ccb80224ef962b184447c61c2f57", + "source_train_sha256": "09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516", + "splits": { + "development": { + "labels": { + "ABSTAIN": 100, + "ACCEPT": 100, + "REJECT": 100, + "REPAIR": 100, + "UNKNOWN": 100 + }, + "pair_set_sha256": "ec63b62a53424b6c806ffda8de04d29606e0da6f450e7b10bb518bf7e60cf2c2", + "paired_channels": { + "arithmetic": 68, + "code_property": 66, + "structural": 66 + }, + "pairs": 100, + "records": 500, + "sha256": "39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587", + "split": "development" + }, + "train": { + "labels": { + "ABSTAIN": 500, + "ACCEPT": 500, + "REJECT": 500, + "REPAIR": 500, + "UNKNOWN": 500 + }, + "pair_set_sha256": "676b5a5bb23a6c83f3431b8e833383bf251173d450d47e0a52f3ebff1af567b6", + "paired_channels": { + "arithmetic": 334, + "code_property": 332, + "structural": 334 + }, + "pairs": 500, + "records": 2500, + "sha256": "b7ebab7b3b8bcee3a476a7a13cc41e356b2e25ba8c6f2c15b2c83e7994252025", + "split": "train" + } + } +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.sha256 b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.sha256 new file mode 100644 index 0000000..053fc8a --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.sha256 @@ -0,0 +1 @@ +fd8cb9b71587540b3a10368c025517cfa6fd7fd8556215701a3cc32e16f18d48 docs/native_cortex/verifier_semantics/COUNTERFACTUAL_CURRICULUM_MANIFEST.json diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.sha256 b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.sha256 new file mode 100644 index 0000000..2c495bf --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.sha256 @@ -0,0 +1 @@ +c07ec5e4148b5df6343517a07906ae337aabd4270e2b648a0202eb325bdb21e6 docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.txt diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.txt b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.txt new file mode 100644 index 0000000..6643951 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_LANGUAGE_RETENTION.txt @@ -0,0 +1,27 @@ +================================================================================================ +MEGA PRIME — NATIVE CORTEX V1 DEVELOPMENT +================================================================================================ +parameters: 5,552,205 +authority: NONE + +running: NORMAL + +running: RESET_RECURRENCE + +running: NO_LOCAL_ATTENTION + +=== LANGUAGE === +NORMAL CE=5.2068 PPL=182.52 BPB=2.0769 +RESET_RECURRENCE CE=5.4544 PPL=233.79 BPB=2.1757 +NO_LOCAL_ATTENTION CE=5.4389 PPL=230.19 BPB=2.1695 + +RECURRENT BPB CONTRIBUTION: +0.0988 +LOCAL ATTENTION BPB CONTRIBUTION: +0.0926 + +=== NORMAL ROUTING / MEMORY === +L0 experts=0.177,0.177,0.114,0.178,0.207,0.147 max=0.207 H=0.991 conf=0.335 state=2.255 read=0.465 erase=0.1985 write=0.1118 retain=0.9104 attnH=0.000 +L1 experts=0.205,0.139,0.162,0.181,0.161,0.151 max=0.205 H=0.996 conf=0.362 state=2.737 read=0.553 erase=0.2338 write=0.1718 retain=0.9028 attnH=0.950 +L2 experts=0.197,0.155,0.210,0.115,0.185,0.138 max=0.210 H=0.988 conf=0.355 state=3.496 read=0.855 erase=0.2124 write=0.2160 retain=0.9084 attnH=0.000 +L3 experts=0.176,0.122,0.136,0.205,0.179,0.182 max=0.205 H=0.992 conf=0.362 state=4.728 read=1.234 erase=0.1455 write=0.2336 retain=0.9242 attnH=0.783 + +================================================================================================ diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.json b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.json new file mode 100644 index 0000000..30853b3 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.json @@ -0,0 +1,97 @@ +{ + "accuracy": 0.84, + "authority": "NONE", + "channel_accept_reject_accuracy": { + "arithmetic": 0.5294117647058824, + "code_property": 0.5, + "structural": 1.0 + }, + "checkpoint": "artifacts/native_cortex/verifier-semantics-ab-v1/counterfactual_paired/cortex-final.pt", + "checkpoint_format": "mega-prime-verifier-semantics-ab-v1", + "checkpoint_sha256": "440b668de1c310e6a7eded47a68da7b8f6977f4b0f36abc1fc22e205d3939e74", + "confusion": [ + [ + 100, + 0, + 0, + 0, + 0 + ], + [ + 0, + 100, + 0, + 0, + 0 + ], + [ + 0, + 65, + 35, + 0, + 0 + ], + [ + 0, + 10, + 5, + 85, + 0 + ], + [ + 0, + 0, + 0, + 0, + 100 + ] + ], + "development": "data/native_cortex/verifier_semantics/counterfactual_v1/development.jsonl", + "development_sha256": "39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587", + "format": "mega-prime-counterfactual-verifier-development-v1", + "full_prompt_collisions": 0, + "full_verifier_semantics_gate": false, + "gates": { + "accept_gt_0_60": true, + "all_channel_ar_gt_0_60": false, + "macro_gt_0_60": true, + "margin_reversal_gt_0_50": false, + "minimum_class_gt_0_35": false, + "no_full_prompt_collisions": true, + "no_malformed_pairs": true, + "no_truncated_token_collisions": true, + "overall_gt_0_60": true, + "pair_accuracy_gt_0_50": false, + "reject_gt_0_60": false + }, + "macro_accuracy": 0.8400000000000001, + "malformed_pairs": 0, + "margin_reversal_rate": 0.35, + "mean_accept_margin": 0.4303409127704799, + "mean_margin_flip": 0.6352673793770373, + "mean_reject_margin": -0.20492646660655736, + "minimum_class_accuracy": 0.35, + "pair_accuracy": 0.35, + "pair_channel_accuracy": { + "arithmetic": 0.058823529411764705, + "code_property": 0.0, + "structural": 1.0 + }, + "pairs": 100, + "per_class": { + "ABSTAIN": 1.0, + "ACCEPT": 1.0, + "REJECT": 0.35, + "REPAIR": 0.85, + "UNKNOWN": 1.0 + }, + "prediction_counts": { + "ABSTAIN": 100, + "ACCEPT": 175, + "REJECT": 40, + "REPAIR": 85, + "UNKNOWN": 100 + }, + "records": 500, + "truncated_token_collisions": 0 +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.sha256 b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.sha256 new file mode 100644 index 0000000..d1164a8 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.sha256 @@ -0,0 +1 @@ +6e3f7698d86dc05f744e555cd04f2a0ff031b9198314367d2aa9b211e9d49a1a docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_RESULT.json diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.json b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.json new file mode 100644 index 0000000..002620b --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.json @@ -0,0 +1,38 @@ +{ + "authority": "NONE", + "base_checkpoint": "artifacts/native_cortex/prime-bridge-v1/cortex-prime-final.pt", + "base_checkpoint_sha256": "aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1", + "condition": "counterfactual_paired", + "elapsed_seconds": 8698.674301939998, + "final_checkpoint": "artifacts/native_cortex/verifier-semantics-ab-v1/counterfactual_paired/cortex-final.pt", + "final_checkpoint_sha256": "440b668de1c310e6a7eded47a68da7b8f6977f4b0f36abc1fc22e205d3939e74", + "format": "mega-prime-verifier-semantics-ab-training-v1", + "learning_rate": 8e-05, + "lm_stream": "data/native_cortex/tokens/train.bin", + "lm_stream_sha256": "92e4b2f50aed7dd95a94fc964affcda019253c8edd86580e2e3d0033c4a04963", + "max_length": 192, + "optimizer_state_continued": true, + "optimizer_task_counts": { + "lm": 300, + "semantic": 200, + "verifier": 500 + }, + "schedule": "30% LM / 20% semantic / 50% verifier optimizer steps", + "seed": 26082511, + "semantic_path": "data/native_cortex/prime_bridge/train/semantic.jsonl", + "semantic_sha256": "4f0bd8a514a6160a466c52ab719f9035d29777558faecbcc7feb161c36336d4b", + "steps": 1000, + "unique_verifier_records_seen": 2500, + "verifier_batch_size": 5, + "verifier_curriculum": "data/native_cortex/verifier_semantics/counterfactual_v1/train.jsonl", + "verifier_curriculum_sha256": "b7ebab7b3b8bcee3a476a7a13cc41e356b2e25ba8c6f2c15b2c83e7994252025", + "verifier_label_presentations": { + "ABSTAIN": 500, + "ACCEPT": 500, + "REJECT": 500, + "REPAIR": 500, + "UNKNOWN": 500 + }, + "verifier_presentations": 2500, + "verifier_records": 2500 +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.sha256 b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.sha256 new file mode 100644 index 0000000..7a1edd7 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.sha256 @@ -0,0 +1 @@ +2b4ab899f9bd76e84a66d9adaa04b9b6e6786192bde37775c171da34b172cd5c docs/native_cortex/verifier_semantics/COUNTERFACTUAL_PAIRED_TRAINING_MANIFEST.json diff --git a/docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.md b/docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.md new file mode 100644 index 0000000..da3d773 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.md @@ -0,0 +1,193 @@ +# PRIME Native Cortex Counterfactual Verifier Semantics Evaluation Protocol + +State date: 2026-08-25 + +## Purpose + +Measure whether the Native Cortex learns actual typed ACCEPT versus REJECT distinctions rather than broad verifier outcome-family shortcuts. + +This protocol is frozen before counterfactual training. + +## Authority + +The Native Cortex has authority NONE. + +Canonical PRIME verifier outputs determine curriculum labels. + +Neural verifier predictions never authorize canonical mutation. + +## Curriculum design + +Training remains five-way balanced: + +UNKNOWN 500 +ACCEPT 500 +REJECT 500 +REPAIR 500 +ABSTAIN 500 + +Total: +2500 records + +Development remains five-way balanced: + +UNKNOWN 100 +ACCEPT 100 +REJECT 100 +REPAIR 100 +ABSTAIN 100 + +Total: +500 records + +UNKNOWN, REPAIR and ABSTAIN controls are inherited from the frozen v1 canonical verifier curriculum. + +ACCEPT and REJECT are replaced by exactly matched counterfactual pairs generated using canonical typed verifiers. + +The total dataset size and five-way label balance therefore remain identical to the original bridge curriculum. + +## Paired channels + +Counterfactual ACCEPT/REJECT pairs are distributed across: + +arithmetic +structural +code_property + +The pair members use the same verifier channel. + +Only the verifier-relevant fact is changed. + +## Primary paired metric + +For pair i: + +PAIR_CORRECT_i = 1 only when: + +positive member is predicted ACCEPT + +and + +negative member is predicted REJECT. + +PAIR_ACC is the mean over all matched pairs. + +A model predicting REJECT for both pair members receives zero paired credit. + +## Margin metric + +Define: + +m(x) = p(ACCEPT | x) - p(REJECT | x) + +For a correctly oriented pair: + +m(positive) > 0 + +and + +m(negative) < 0 + +The pair margin flip is: + +m(positive) - m(negative) + +The evaluator reports both mean margin flip and the proportion of pairs with correct sign reversal. + +## Tokenization collision guard + +The evaluator must compare paired prompts after the exact tokenizer and max-length truncation used for evaluation. + +If ACCEPT and REJECT pair members become identical after truncation, the protocol is invalid for that pair. + +The frozen gate requires: + +full prompt collisions = 0 + +truncated token collisions = 0 + +malformed pairs = 0 + +## Five-way gates retained from the first bridge + +overall accuracy > 0.60 + +macro class accuracy > 0.60 + +minimum class accuracy > 0.35 + +## New verifier-semantics gates + +ACCEPT accuracy > 0.60 + +REJECT accuracy > 0.60 + +PAIR_ACC > 0.50 + +margin reversal rate > 0.50 + +Within-channel ACCEPT/REJECT accuracy must exceed 0.60 separately for: + +arithmetic +structural +code_property + +## Full verifier-semantics gate + +The verifier-semantics gate passes only if every frozen verifier gate and every collision/integrity gate passes simultaneously. + +The threshold must not be altered after observing development results. + +## Language retention + +Verifier-semantics success does not supersede language retention. + +Every trained condition must also be evaluated using the existing Native Cortex V1 development language evaluator. + +Reference: + +pre-bridge V1 BPB = 2.0788 + +first bridge BPB = 2.0821 + +Frozen language-retention ceiling: + +BPB <= 2.1788 + +A model that passes verifier semantics while exceeding the language-retention ceiling does not pass the complete programme. + +## Experimental comparison + +Condition A: + +existing frozen verifier curriculum with substantially increased verifier exposure + +Condition B: + +counterfactual paired curriculum with comparable verifier exposure + +The purpose is to distinguish: + +underexposure + +from + +shortcut-friendly curriculum structure. + +## Held-out discipline + +The Native Cortex held-out split remains forbidden. + +Frozen held-out SHA256: + +509907b29546ecee73f464f44dd53a6a809b3b80a5e1d3f27c25846ac083ae8c + +M26 held-out seeds also remain forbidden. + +No held-out result is permitted while curriculum, training schedule, evaluator or architecture is under development. + +## Scientific interpretation + +Passing this development protocol establishes only that the tested Native Cortex learned development-set typed pass/fail distinctions under the tested channels. + +It does not establish general verification, theorem proving, general reasoning or epistemic authority. diff --git a/docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.sha256 b/docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.sha256 new file mode 100644 index 0000000..09d07ec --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.sha256 @@ -0,0 +1 @@ +fe99cd1da9a1715d5970248f963f0de2e11c12954d90ff8bd10d44c35b54b04b docs/native_cortex/verifier_semantics/EVALUATION_PROTOCOL.md diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.sha256 b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.sha256 new file mode 100644 index 0000000..835d77a --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.sha256 @@ -0,0 +1 @@ +69a62242caccdf72fd07651e3aaab16d0bf6a30cf420aba0d70a9d4b9a01346e docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.txt diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.txt b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.txt new file mode 100644 index 0000000..27fbf29 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_LANGUAGE_RETENTION.txt @@ -0,0 +1,27 @@ +================================================================================================ +MEGA PRIME — NATIVE CORTEX V1 DEVELOPMENT +================================================================================================ +parameters: 5,552,205 +authority: NONE + +running: NORMAL + +running: RESET_RECURRENCE + +running: NO_LOCAL_ATTENTION + +=== LANGUAGE === +NORMAL CE=5.2159 PPL=184.17 BPB=2.0805 +RESET_RECURRENCE CE=5.4778 PPL=239.32 BPB=2.1850 +NO_LOCAL_ATTENTION CE=5.4411 PPL=230.71 BPB=2.1704 + +RECURRENT BPB CONTRIBUTION: +0.1045 +LOCAL ATTENTION BPB CONTRIBUTION: +0.0899 + +=== NORMAL ROUTING / MEMORY === +L0 experts=0.175,0.178,0.114,0.178,0.210,0.146 max=0.210 H=0.991 conf=0.334 state=2.260 read=0.465 erase=0.1984 write=0.1119 retain=0.9105 attnH=0.000 +L1 experts=0.199,0.142,0.158,0.185,0.163,0.153 max=0.199 H=0.996 conf=0.360 state=2.737 read=0.553 erase=0.2344 write=0.1721 retain=0.9027 attnH=0.950 +L2 experts=0.206,0.159,0.192,0.113,0.200,0.131 max=0.206 H=0.987 conf=0.351 state=3.526 read=0.860 erase=0.2119 write=0.2180 retain=0.9085 attnH=0.000 +L3 experts=0.161,0.123,0.156,0.203,0.181,0.176 max=0.203 H=0.994 conf=0.358 state=4.756 read=1.237 erase=0.1445 write=0.2343 retain=0.9245 attnH=0.789 + +================================================================================================ diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.json b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.json new file mode 100644 index 0000000..a219bd6 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.json @@ -0,0 +1,97 @@ +{ + "accuracy": 0.766, + "authority": "NONE", + "channel_accept_reject_accuracy": { + "arithmetic": 0.5, + "code_property": 0.5, + "structural": 0.5 + }, + "checkpoint": "artifacts/native_cortex/verifier-semantics-ab-v1/exposure_control/cortex-final.pt", + "checkpoint_format": "mega-prime-verifier-semantics-ab-v1", + "checkpoint_sha256": "73d40bb229a1ac738e5148e67b171f7f8f8f4c6338b2454bcc0186e2a41c4df0", + "confusion": [ + [ + 100, + 0, + 0, + 0, + 0 + ], + [ + 0, + 34, + 66, + 0, + 0 + ], + [ + 0, + 34, + 66, + 0, + 0 + ], + [ + 0, + 17, + 0, + 83, + 0 + ], + [ + 0, + 0, + 0, + 0, + 100 + ] + ], + "development": "data/native_cortex/verifier_semantics/counterfactual_v1/development.jsonl", + "development_sha256": "39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587", + "format": "mega-prime-counterfactual-verifier-development-v1", + "full_prompt_collisions": 0, + "full_verifier_semantics_gate": false, + "gates": { + "accept_gt_0_60": false, + "all_channel_ar_gt_0_60": false, + "macro_gt_0_60": true, + "margin_reversal_gt_0_50": false, + "minimum_class_gt_0_35": false, + "no_full_prompt_collisions": true, + "no_malformed_pairs": true, + "no_truncated_token_collisions": true, + "overall_gt_0_60": true, + "pair_accuracy_gt_0_50": false, + "reject_gt_0_60": true + }, + "macro_accuracy": 0.766, + "malformed_pairs": 0, + "margin_reversal_rate": 0.0, + "mean_accept_margin": -0.4363270746171474, + "mean_margin_flip": 0.019857420409098266, + "mean_reject_margin": -0.4561844950262457, + "minimum_class_accuracy": 0.34, + "pair_accuracy": 0.0, + "pair_channel_accuracy": { + "arithmetic": 0.0, + "code_property": 0.0, + "structural": 0.0 + }, + "pairs": 100, + "per_class": { + "ABSTAIN": 1.0, + "ACCEPT": 0.34, + "REJECT": 0.66, + "REPAIR": 0.83, + "UNKNOWN": 1.0 + }, + "prediction_counts": { + "ABSTAIN": 100, + "ACCEPT": 85, + "REJECT": 132, + "REPAIR": 83, + "UNKNOWN": 100 + }, + "records": 500, + "truncated_token_collisions": 0 +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md new file mode 100644 index 0000000..a906f85 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md @@ -0,0 +1,111 @@ +# Verifier Semantics A/B — Condition A Exposure Control + +State date: 2026-08-26 + +Condition: +exposure_control + +Purpose: +Test whether complete exposure to the original verifier curriculum is sufficient to eliminate the ACCEPT/REJECT obstruction. + +Starting checkpoint SHA256: +aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1 + +Final checkpoint SHA256: +73d40bb229a1ac738e5148e67b171f7f8f8f4c6338b2454bcc0186e2a41c4df0 + +Verifier curriculum SHA256: +09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516 + +Verifier presentations: +2500 + +Unique verifier records seen: +2500 + +Class presentations: +UNKNOWN 500 +ACCEPT 500 +REJECT 500 +REPAIR 500 +ABSTAIN 500 + +Optimizer task counts: +LM 300 +semantic 200 +verifier 500 + +Development curriculum SHA256: +39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587 + +Overall accuracy: +0.7660 + +Macro accuracy: +0.7660 + +Minimum class accuracy: +0.3400 + +Per-class accuracy: +UNKNOWN 1.0000 +ACCEPT 0.3400 +REJECT 0.6600 +REPAIR 0.8300 +ABSTAIN 1.0000 + +Within-channel ACCEPT/REJECT accuracy: +arithmetic 0.5000 +structural 0.5000 +code_property 0.5000 + +Pair accuracy: +0.0000 + +Margin reversal rate: +0.0000 + +Mean ACCEPT margin: +-0.436327 + +Mean REJECT margin: +-0.456184 + +Mean margin flip: ++0.019857 + +Pair accuracy by channel: +arithmetic 0.0000 +structural 0.0000 +code_property 0.0000 + +Full prompt collisions: +0 + +Truncated token collisions: +0 + +Malformed pairs: +0 + +FULL VERIFIER SEMANTICS GATE: +FAIL + +Interpretation: + +Complete exposure to the original verifier curriculum materially changed the neural classifier and caused it to emit ACCEPT predictions, increasing ACCEPT development accuracy from 0.0000 to 0.3400. + +However, it did not produce counterfactual verifier semantics. + +The ACCEPT and REJECT confusion rows were identical: + +ACCEPT -> 34 ACCEPT, 66 REJECT +REJECT -> 34 ACCEPT, 66 REJECT + +Matched pair accuracy remained zero and margin reversal remained zero across arithmetic, structural and code-property channels. + +Therefore the first bridge failure cannot now be attributed solely to the earlier approximately 15 percent unique verifier exposure. + +Underexposure contributed to classifier behaviour, but one complete epoch of the original shortcut-friendly curriculum was insufficient to teach the verifier-relevant ACCEPT/REJECT distinction. + +Condition B tests whether matched counterfactual curriculum geometry changes this result. diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md.sha256 b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md.sha256 new file mode 100644 index 0000000..5fedad0 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md.sha256 @@ -0,0 +1 @@ +e8548f2246feb03077c2f029408870672a89545e2641977edad6dfb5d17a0709 docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.md diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.sha256 b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.sha256 new file mode 100644 index 0000000..5fb03ae --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.sha256 @@ -0,0 +1 @@ +97b9ac073cf0354f2922d5ab0eef6506c4eae5336f4aced0c00162f340945db6 docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_RESULT.json diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.json b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.json new file mode 100644 index 0000000..372e725 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.json @@ -0,0 +1,38 @@ +{ + "authority": "NONE", + "base_checkpoint": "artifacts/native_cortex/prime-bridge-v1/cortex-prime-final.pt", + "base_checkpoint_sha256": "aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1", + "condition": "exposure_control", + "elapsed_seconds": 8927.053175387, + "final_checkpoint": "artifacts/native_cortex/verifier-semantics-ab-v1/exposure_control/cortex-final.pt", + "final_checkpoint_sha256": "73d40bb229a1ac738e5148e67b171f7f8f8f4c6338b2454bcc0186e2a41c4df0", + "format": "mega-prime-verifier-semantics-ab-training-v1", + "learning_rate": 8e-05, + "lm_stream": "data/native_cortex/tokens/train.bin", + "lm_stream_sha256": "92e4b2f50aed7dd95a94fc964affcda019253c8edd86580e2e3d0033c4a04963", + "max_length": 192, + "optimizer_state_continued": true, + "optimizer_task_counts": { + "lm": 300, + "semantic": 200, + "verifier": 500 + }, + "schedule": "30% LM / 20% semantic / 50% verifier optimizer steps", + "seed": 26082511, + "semantic_path": "data/native_cortex/prime_bridge/train/semantic.jsonl", + "semantic_sha256": "4f0bd8a514a6160a466c52ab719f9035d29777558faecbcc7feb161c36336d4b", + "steps": 1000, + "unique_verifier_records_seen": 2500, + "verifier_batch_size": 5, + "verifier_curriculum": "data/native_cortex/prime_bridge/curriculum/train.jsonl", + "verifier_curriculum_sha256": "09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516", + "verifier_label_presentations": { + "ABSTAIN": 500, + "ACCEPT": 500, + "REJECT": 500, + "REPAIR": 500, + "UNKNOWN": 500 + }, + "verifier_presentations": 2500, + "verifier_records": 2500 +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.sha256 b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.sha256 new file mode 100644 index 0000000..e3d628b --- /dev/null +++ b/docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.sha256 @@ -0,0 +1 @@ +e248c623f9402e2cd00fb4f8b9101a2796c013359b0fc1e566d29d1474bc7751 docs/native_cortex/verifier_semantics/EXPOSURE_CONTROL_TRAINING_MANIFEST.json diff --git a/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.json b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.json new file mode 100644 index 0000000..8fce505 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.json @@ -0,0 +1,97 @@ +{ + "accuracy": 0.796, + "authority": "NONE", + "channel_accept_reject_accuracy": { + "arithmetic": 0.5, + "code_property": 0.5, + "structural": 0.5 + }, + "checkpoint": "artifacts/native_cortex/prime-bridge-v1/cortex-prime-final.pt", + "checkpoint_format": "mega-prime-cortex-bridge-v1", + "checkpoint_sha256": "aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1", + "confusion": [ + [ + 100, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 100, + 0, + 0 + ], + [ + 0, + 0, + 100, + 0, + 0 + ], + [ + 0, + 0, + 2, + 98, + 0 + ], + [ + 0, + 0, + 0, + 0, + 100 + ] + ], + "development": "data/native_cortex/verifier_semantics/counterfactual_v1/development.jsonl", + "development_sha256": "39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587", + "format": "mega-prime-counterfactual-verifier-development-v1", + "full_prompt_collisions": 0, + "full_verifier_semantics_gate": false, + "gates": { + "accept_gt_0_60": false, + "all_channel_ar_gt_0_60": false, + "macro_gt_0_60": true, + "margin_reversal_gt_0_50": false, + "minimum_class_gt_0_35": false, + "no_full_prompt_collisions": true, + "no_malformed_pairs": true, + "no_truncated_token_collisions": true, + "overall_gt_0_60": true, + "pair_accuracy_gt_0_50": false, + "reject_gt_0_60": true + }, + "macro_accuracy": 0.796, + "malformed_pairs": 0, + "margin_reversal_rate": 0.0, + "mean_accept_margin": -0.773903574347496, + "mean_margin_flip": -0.0077698913775384425, + "mean_reject_margin": -0.7661336829699575, + "minimum_class_accuracy": 0.0, + "pair_accuracy": 0.0, + "pair_channel_accuracy": { + "arithmetic": 0.0, + "code_property": 0.0, + "structural": 0.0 + }, + "pairs": 100, + "per_class": { + "ABSTAIN": 1.0, + "ACCEPT": 0.0, + "REJECT": 1.0, + "REPAIR": 0.98, + "UNKNOWN": 1.0 + }, + "prediction_counts": { + "ABSTAIN": 100, + "ACCEPT": 0, + "REJECT": 202, + "REPAIR": 98, + "UNKNOWN": 100 + }, + "records": 500, + "truncated_token_collisions": 0 +} \ No newline at end of file diff --git a/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md new file mode 100644 index 0000000..3733f9b --- /dev/null +++ b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md @@ -0,0 +1,169 @@ +# PRIME Native Cortex Counterfactual Verifier Pre-Training Baseline + +State date: 2026-08-25 + +## Purpose + +Freeze the counterfactual verifier-semantics performance of the existing first Cortex-PRIME bridge checkpoint before any verifier-semantics retraining. + +Authority remains NONE. + +## Checkpoint + +Path: +artifacts/native_cortex/prime-bridge-v1/cortex-prime-final.pt + +SHA256: +aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1 + +## Development curriculum + +Path: +data/native_cortex/verifier_semantics/counterfactual_v1/development.jsonl + +SHA256: +39e869122c1086ffcdc72d06e3dba74f4f0e228cef143c9d9bd8cb0c3cd91587 + +Records: +500 + +Matched ACCEPT/REJECT pairs: +100 + +## Aggregate result + +Accuracy: +0.7960 + +Macro accuracy: +0.7960 + +Minimum class accuracy: +0.0000 + +## Per-class accuracy + +UNKNOWN: +1.0000 + +ACCEPT: +0.0000 + +REJECT: +1.0000 + +REPAIR: +0.9800 + +ABSTAIN: +1.0000 + +## Within-channel ACCEPT/REJECT accuracy + +Arithmetic: +0.5000 + +Structural: +0.5000 + +Code property: +0.5000 + +## Counterfactual pair result + +Pair accuracy: +0.0000 + +Margin reversal rate: +0.0000 + +Mean ACCEPT margin: +-0.773904 + +Mean REJECT margin: +-0.766134 + +Mean margin flip: +-0.007770 + +## Pair accuracy by channel + +Arithmetic: +0.0000 + +Structural: +0.0000 + +Code property: +0.0000 + +## Integrity diagnostics + +Full prompt collisions: +0 + +Truncated token collisions: +0 + +Malformed pairs: +0 + +## Frozen gate status + +Overall accuracy gate: +True + +Macro accuracy gate: +True + +Minimum-class gate: +False + +ACCEPT gate: +False + +REJECT gate: +True + +Pair-accuracy gate: +False + +Margin-reversal gate: +False + +Within-channel gate: +False + +Prompt-collision integrity: +True + +Truncation-collision integrity: +True + +Pair-integrity gate: +True + +FULL VERIFIER SEMANTICS GATE: +False + +## Interpretation + +The existing bridge cortex exactly preserves the previously observed outcome-family shortcut under the new matched counterfactual evaluator. + +It predicts no ACCEPT examples correctly. + +It predicts all REJECT examples correctly. + +It achieves zero matched-pair correctness. + +It produces zero correct ACCEPT/REJECT margin reversals. + +Both ACCEPT and REJECT members have strongly negative mean ACCEPT-minus-REJECT margins. + +There are zero full-prompt collisions, zero post-truncation token collisions, and zero malformed pairs. + +Therefore the failure cannot be attributed to the paired distinction disappearing from the neural observation channel. + +The immediate experimental question is now cleanly separated: + +Does substantially greater exposure to the old curriculum eliminate this obstruction, or does matched counterfactual training provide an advantage that exposure alone does not? diff --git a/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md.sha256 b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md.sha256 new file mode 100644 index 0000000..b993497 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md.sha256 @@ -0,0 +1 @@ +95ed634b4b6546298281aebf1739c5baa8433223fec6a73e5588ef06a621bdc5 docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.md diff --git a/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.sha256 b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.sha256 new file mode 100644 index 0000000..f28d770 --- /dev/null +++ b/docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.sha256 @@ -0,0 +1 @@ +4aadc7ad8b123a2b5eebe96a50b5e2e399cb27e40938d8285d200ead0b731062 docs/native_cortex/verifier_semantics/PRETRAINING_BASELINE.json diff --git a/docs/prime-v19-authority.md b/docs/prime-v19-authority.md new file mode 100644 index 0000000..93ecaf3 --- /dev/null +++ b/docs/prime-v19-authority.md @@ -0,0 +1,96 @@ +# PRIME v19 authority seam + +BoggersTheAI now has an explicit authority mode at the canonical `TSKernel` +commit boundary: + +- `legacy_local` preserves the pre-PRIME transaction path during migration and + is written into every TS receipt. +- `prime_required` is the production target. A `PrimeV19AuthorityAdapter` must + be supplied, and no `commit_document()` call occurs when PRIME is absent, + raises, rejects, abstains, returns a stale receipt, fails receipt validation, + or no longer matches its live graph and ledger tip. + +There is no silent fallback. Supplying a PRIME adapter while selecting +`legacy_local` is a configuration error. + +## Bound transaction + +Immediately before Boggers applies its local graph delta, the adapter creates a +PRIME `GraphPatchProposal`. Semantic commits contain one +`boggers_document_commit` node; representation transitions contain one +`boggers_representation_commit` node in the protected `representation` +authority class and always carry `representation_economics` evidence. The +mutation intent binds: + +- the Boggers base graph hash and input hash; +- the complete TSIR document and document hash; +- the proposed commit or branch decision and claim statuses; +- the exact graph delta produced by a detached `commit_document()` preview, + its Boggers hash, and the expected full post-state hash; +- every local verifier obligation and result; +- BOGVM artifacts; and +- request and receipt-chain provenance. + +The proposal is also bound to the current PRIME lineage, graph root, authority +ledger tip, logical sequence, authenticated proposer identity, and proposer +key. Boggers accepts only a ledgered `AUTHORIZE` +receipt which passes PRIME receipt verification, matches the exact request and +intent, and still equals PRIME's live graph and ledger state. The mutation +intent schema is `boggers-document-commit-intent-v2`. + +After admission, Boggers independently checks the projection binding, applies +the same deterministic commit, and compares both the returned delta and the +complete post-state hash with the authorized values. Any mismatch restores the +captured local base snapshot, emits an abstaining Boggers receipt with an empty +committed delta, and marks the nested admission wrapper invalid. The original +immutable PRIME receipt remains visible for reconciliation. + +The adapter calls PRIME's contextual `verify_receipt()`, not the weaker +integrity-only check. A kernel restored through PRIME's authenticated checkpoint +API can be supplied to the same adapter and continues from its audited root, +ledger tip, sequence, and remaining budgets without a separate adapter path. + +Boggers floating-point fields are represented as tagged Python decimal strings +inside the PRIME payload. This preserves their exact source representation +without weakening PRIME's no-float canonicalization rule. Dictionary keys must +already be strings; the adapter rejects coercion and key-collision ambiguity. +Proposer signing keys are validated at adapter construction with PRIME's minimum +length and byte-diversity requirements, so weak deployment configuration fails +at boot. + +## Transaction isolation + +The canonical transaction boundary is serialized by in-process graph identity, +not by `TSKernel` instance. Two kernels sharing one graph therefore cannot +authorize against the same base and publish in a different order. Re-entry on +the owning thread raises immediately instead of deadlocking. For +`UniversalLivingGraph`, the boundary also holds the graph's own re-entrant lock +from the base snapshot through receipt publication, preventing wave workers and +direct graph mutators from interleaving with projection, PRIME admission, or +local application. + +The PRIME boot policy must explicitly classify `boggers_document_commit` as +`semantic` and `boggers_representation_commit` as `representation`, then +register every obligation named by the adapter. The reference integration uses +independent `safety`, `semantic`, and `representation_economics` validators. +Validators inspect and replay the bound intent; an evidence field such as +`accepted: true` is never authority. + +## Current boundary + +This is a development admission seam, not a sealed evidence release. The graph +coordinator and native graph lock are process-local; other processes and graph +implementations which bypass the same lock require external serialization or a +storage transaction. A custom graph lock must be re-entrant because +`commit_document()` calls graph methods while the boundary is held. + +PRIME's commit and Boggers' local graph application are still two state stores +without a distributed two-phase commit. A local mismatch is rolled back, but +the already-ledgered PRIME `AUTHORIZE` remains and requires reconciliation. A +process failure after PRIME commits and before Boggers finishes has the same +requirement. Snapshot rollback is durable for the current in-memory mutation +path; custom backends which persist on every `add_node()`/`add_edge()` need a +backend transaction. Detached preview also assumes deterministic graph mutation +semantics and does not reproduce custom embedders or backend-only side effects. +The production evolution should make PRIME the single canonical graph store or +add an explicit prepare/finalize recovery protocol. diff --git a/docs/prime_m20/M20_CONTRACT.md b/docs/prime_m20/M20_CONTRACT.md new file mode 100644 index 0000000..c575f95 --- /dev/null +++ b/docs/prime_m20/M20_CONTRACT.md @@ -0,0 +1,570 @@ +# PRIME M20 +## Adaptive Construction Engine + +Status: + + ARCHITECTURAL CONTRACT + +Parent canonical checkpoint: + + PRIME canonical agent benchmark v1.3 final commit: + 84fce73 + +The v1.3 benchmark remains immutable. + +M20 is not benchmark v1.4. + +M20 is a canonical PRIME architecture milestone. + +--- + +# 1. Objective + +Replace fixed-menu representation repair with verifier-governed +representation construction. + +Previous benchmark representation family: + + H0 + H1 + H2 + H4 + +M20 representation: + + R = {phi_1, phi_2, ..., phi_m} + +where each phi_i is a typed, content-addressed construction over observable +history or previously authorized constructions. + +The system must be able to discover WHAT information or relation is missing, +not merely how many raw historical observations to retain. + +--- + +# 2. Authority boundary + +M20 preserves canonical PRIME sovereignty: + + proposal != proof + score != proof + confidence != proof + learned latent state != proof + language != proof + +Only an independent verifier authorization may cause a proposed construction +to become canonical policy state. + +Canonical graph mutation remains downstream of TSKernel / TSIR authority. + +--- + +# 3. Representation algebra — M20.0 + +Primitive construction: + + LAG(k) + +meaning: + + X[t-k] + +for: + + 1 <= k <= 8 + +Initial binary relational operators: + + XOR(a,b) + EQ(a,b) + AND(a,b) + OR(a,b) + +Initial M20 grammar therefore includes examples such as: + + LAG(4) + + XOR( + LAG(1), + LAG(4) + ) + + EQ( + LAG(2), + LAG(5) + ) + +The initial implementation is intentionally bounded. + +Higher-order composition over previously verified constructions is part of +the M20 programme but is not silently enabled before explicit tests exist. + +--- + +# 4. Canonical construction identity + +Every construction has a deterministic semantic identity. + +Construction identity is derived from: + +- semantics version; +- normalized typed expression. + +Human-readable labels do not define identity. + +Proposal source does not define semantic identity. + +Equivalent normalized expressions must receive identical IDs. + +--- + +# 5. Candidate generation + +Candidate generation is proposal-only. + +Default bounded grammar: + + maximum raw lag: + 8 + + primitive lag constructions: + 8 + + pairwise operators: + XOR + EQ + AND + OR + +Candidate expressions are normalized and deduplicated. + +Default maximum simultaneous candidate streams: + + 128 + +Candidate generation cannot mutate policy state. + +--- + +# 6. Description complexity + +M20 uses structural description cost rather than induced tabular carrier size. + +For a lag reference: + + K(LAG(k)) + = + 2 + bit_length(k) + +For a binary construction: + + K(OP(a,b)) + = + 1 + K(a) + K(b) + +This is a bounded MDL-like structural price. + +It is not a claim that this is the unique correct universal coding scheme. + +It is frozen for the first M20 construction experiments. + +--- + +# 7. Prequential verification + +For each current canonical policy state maintain a deterministic binary +majority predictor. + +For each candidate construction q maintain a candidate predictor on: + + canonical_state + q(history) + +Predictions occur BEFORE target revelation. + +After target revelation: + + candidate correct, canonical wrong + -> + WIN + + canonical correct, candidate wrong + -> + LOSS + + predictions agree + -> + no paired evidence update + +Evidence accumulated by candidate predictors cannot control policy actions. + +--- + +# 8. Anytime-valid evidence + +For candidate q: + + M_q + = + (3/2)^W_q (1/2)^L_q + +Equivalent exact integer form: + + 3^W_q + >= + T * 2^(W_q + L_q) + +No floating-point evidence is authoritative. + +--- + +# 9. Multiplicity budget + +For N active candidate streams: + + T = 64 * N + +Then each candidate has threshold-crossing budget: + + <= 1 / (64 N) + +and a union bound over N streams gives run-level budget: + + <= 1/64 + +under the frozen null assumptions. + +N is fixed for a representation epoch. + +--- + +# 10. Complexity gate + +Statistical support is insufficient by itself. + +Candidate q must additionally satisfy: + + W_q - L_q > K(q) + +Thus authorization requires BOTH: + +1. anytime-valid statistical support; +2. structural complexity payment. + +--- + +# 11. Obstruction + +The initial M20 obstruction gate preserves the canonical benchmark rule. + +For current canonical state s maintain: + + N(s,0) + N(s,1) + +An obstruction exists if: + + N(s,0) >= 8 + +and: + + N(s,1) >= 8 + +Evidence may accumulate before obstruction. + +Authorization may not occur before obstruction. + +--- + +# 12. Candidate selection + +Among supported candidates select deterministically by: + +1. smallest description cost K; +2. smallest required raw-history horizon; +3. canonical construction ID. + +No reward-dependent post-hoc selection rule is permitted. + +--- + +# 13. Policy/verifier memory separation + +This is mandatory. + +The verifier may maintain private history for candidate evaluation. + +Policy state may use only authorized constructions. + +When construction q is authorized: + + verifier history MUST NOT be copied into policy memory. + +The newly authorized construction receives an EMPTY prospective policy buffer. + +Its historical inputs become available only from observations occurring after +authorization. + +Thus no construction gains retroactive policy knowledge. + +--- + +# 14. Canonical construction lifecycle + +Construction states: + + PROPOSED + AUTHORIZED + RETIRED + +Future M20 extensions may add: + + QUARANTINED + SUPERSEDED + +Only verifier receipts may transition canonical status. + +Required lifecycle operations: + + propose + authorize + retire + restore + +Retirement and restoration must remain receipt-backed. + +--- + +# 15. Canonical representation state + +Canonical policy state is: + + ( + current_observation, + phi_1(policy_history_1), + phi_2(policy_history_2), + ... + ) + +where phi_i are AUTHORIZED constructions only. + +Proposal candidates never appear in policy state. + +--- + +# 16. Receipt discipline + +Every authorization receipt must record at least: + +- construction ID; +- expression; +- evidence wins; +- evidence losses; +- statistical operands; +- threshold; +- structural cost; +- obstruction index; +- authorization index; +- parent receipt hash; +- sequence; +- resulting active construction set. + +Receipts are: + +- deterministic; +- canonical; +- hash chained; +- replayable; +- tamper detectable; +- timestamp free in scientific output. + +--- + +# 17. Active study selection + +M20 may rank unresolved candidates by expected informational usefulness. + +Study selection is proposal-only. + +It may decide: + + what evidence would be useful to seek + +It may NOT decide: + + what is true + +or: + + what becomes canonical + +Verifier sovereignty remains unchanged. + +--- + +# 18. Distributed / learned proposal field + +Later M20 phases may introduce: + +- soft structural embeddings; +- learned candidate ranking; +- recurrent proposal state; +- tension-field credit assignment; +- contextual routing. + +These systems may accelerate proposal generation. + +They may never authorize canonical construction. + +The learned substrate is therefore: + + proposer + +not: + + epistemic authority + +--- + +# 19. Higher-order relational growth + +Later M20 phases may permit expressions over verified constructions: + + XOR(phi_a, phi_b) + + relation(phi_a, phi_b) + + temporal(phi_a, lag_k) + + quotient(phi_a, phi_b) + +This is how M20 reconnects canonical agent work with PRIME higher-order +relational geometry. + +Such growth must be typed and bounded. + +--- + +# 20. Predictive quotient integration + +A set of histories may be quotiented when verifier evidence supports equal +relevant predictive behaviour under the task interface. + +This reconnects M20 with TSASA-style adaptive state abstraction. + +Construction adds distinctions. + +Quotienting removes distinctions. + +Together they form: + + representation growth + + + representation compression + +--- + +# 21. Memory classes + +M20 distinguishes: + +A. verifier-private sensory/evidence memory + +B. canonical working representation + +C. episodic evidence ledger + +D. persistent verified construction library + +No information moves from A into B without verifier authorization. + +Persistent D-memory does not automatically become authoritative in a new +environment. + +Transfer still requires applicable evidence. + +--- + +# 22. Repair / retirement / restoration + +M20 representation lifecycle is: + + obstruction + -> + proposal + -> + verification + -> + authorization + -> + use + -> + continuing audit + -> + retain / repair / retire + +A retired construction may later be restored only through a new receipt-backed +authorization. + +--- + +# 23. Initial scientific targets + +M20 must eventually handle task families including: + +- single-lag dependency; +- multiple relevant lags; +- XOR / parity dependency; +- equality relations; +- switching relevant features; +- irrelevant distractor history; +- compositional hidden state; +- partial transfer across worlds. + +A fixed H-depth menu is not sufficient for these tasks. + +--- + +# 24. Recurrent comparison + +A strong recurrent learned-memory comparator is mandatory before claims about +superiority over learned latent state. + +The recurrent comparator must not be intentionally crippled. + +Development-only architecture/hyperparameter selection must be frozen before +held-out comparison. + +--- + +# 25. Falsification + +Scientifically valid failures include: + +- construction grammar fails to find useful features; +- multiplicity burden becomes too large; +- composition causes sample inefficiency; +- MDL pricing is poorly calibrated; +- recurrent memory dominates PRIME; +- transfer constructions fail to generalize; +- active study selection provides no advantage; +- learned proposal field provides no benefit; +- representation growth explodes combinatorially. + +Such outcomes must be retained, not tuned away. + +--- + +# 26. Claim boundary + +M20 is an adaptive representation-construction architecture. + +Successful controlled benchmarks would not by themselves establish: + +- AGI; +- human-level intelligence; +- universal reasoning; +- universal POMDP superiority; +- general world modelling; +- safe autonomous self-improvement. + +Claims remain tied to frozen evidence. diff --git a/docs/prime_m20/M20_CONTRACT.sha256 b/docs/prime_m20/M20_CONTRACT.sha256 new file mode 100644 index 0000000..bf5e9da --- /dev/null +++ b/docs/prime_m20/M20_CONTRACT.sha256 @@ -0,0 +1 @@ +7057a14261d43d9503f9b2ca6dddd554da487fd173662416c3a2334022d87cf3 docs/prime_m20/M20_CONTRACT.md diff --git a/docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.md b/docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.md new file mode 100644 index 0000000..aedb633 --- /dev/null +++ b/docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.md @@ -0,0 +1,66 @@ +# PRIME M20 Global Sequential Alpha Spending + +Status: + + FROZEN ARCHITECTURE CORRECTION BEFORE HELD-OUT EVALUATION + +The original M20 construction evidence corrected multiplicity across candidate +streams inside one representation epoch. + +Adaptive compositional PRIME may open multiple representation epochs after +verifier-authorized construction changes. + +Applying the full run-level alpha budget independently to every adaptive epoch +would not provide a run-level family-wise budget across an unbounded sequence +of epochs. + +M20-F0 therefore allocates the evidence budget across epochs. + +For zero-indexed epoch e: + + alpha_e = + 1 / (64 * 2^(e + 1)) + +Hence: + + sum_e alpha_e = 1 / 64 + +For N_e simultaneous candidate evidence streams in epoch e, each stream uses +the exact threshold denominator: + + T_e = + 64 * N_e * 2^(e + 1) + +Equivalently: + + epoch 0: + 128 * N_0 + + epoch 1: + 256 * N_1 + + epoch 2: + 512 * N_2 + +and so on. + +The evidence gate remains: + + 3^W >= T_e * 2^(W + L) + +together with the existing structural-complexity gate. + +This establishes the scheduled run-level family-wise budget under the same +conditional e-process validity assumptions used by the existing verifier. + +Legacy single-epoch M20-A behaviour remains reproducible when EvidenceEpoch is +constructed without an adaptive epoch index. + +Every adaptive compositional EvidenceEpoch must supply its zero-indexed +representation epoch. + +No PRIME M20 Universal Arena held-out seeds had been executed when this +correction was introduced. + +Arena v0.1 and v0.2 development artifacts remain immutable historical evidence. +The unexecuted v0.2 held-out plan is superseded by Arena v0.3. diff --git a/docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.sha256 b/docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.sha256 new file mode 100644 index 0000000..be87ae5 --- /dev/null +++ b/docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.sha256 @@ -0,0 +1 @@ +66d00ebcc43967c08ec2bee9a15ee9319d03482c4ecd87c48efdcfb3cd00c9ca docs/prime_m20/M20_GLOBAL_ALPHA_SPENDING.md diff --git a/docs/prime_m21/M21_CONTRACT.md b/docs/prime_m21/M21_CONTRACT.md new file mode 100644 index 0000000..24fe065 --- /dev/null +++ b/docs/prime_m21/M21_CONTRACT.md @@ -0,0 +1,251 @@ +# PRIME M21 — Persistent Adaptive Cognition + +Status: + + ARCHITECTURE CONTRACT + +Parent: + + Frozen PRIME M20 Universal Adaptive-State Architecture + +M20 remains immutable. + +M21 is not a benchmark revision. + +M21 is a cognitive-system integration milestone whose purpose is to make +verified representational learning accumulate across worlds. + +--- + +# Central objective + +Build an auditable persistent adaptive cognition loop: + + experience + -> + representation obstruction + -> + proposal search + -> + verification + -> + construction + -> + persistent memory + -> + cross-world transfer + -> + active study + -> + world-model growth + -> + counterfactual planning + -> + compression / retirement + -> + improved future proposal search + +--- + +# Authority invariant + +No learned, recalled, generated, simulated, transferred, compressed, induced, +or counterfactual object is canonical knowledge merely because it was produced. + +Proposal-producing systems include: + + persistent semantic memory; + episodic recall; + distributed proposal routing; + active-study selection; + transfer recall; + schema induction; + world-model hypotheses; + counterfactual planning. + +These systems MAY alter proposal order. + +They MUST NOT independently authorize canonical state mutation. + +Verifier-backed authority remains required. + +--- + +# Memory classes + +M21 introduces distinct memory roles. + +A. Working state + + Fast prospective state used during the current interaction. + +B. Episodic memory + + Immutable hash-chained records of prior worlds, constructions, studies, + outcomes and tensions. + +C. Semantic construction memory + + Persistent reusable verifier-backed constructions grouped by predictive + quotient class. + +D. World-model memory + + Explicit verifier-authorized transition structure. + +E. Meta-memory + + Records which proposal sources, transfer strategies and studies have + historically succeeded or failed. + +--- + +# Cross-world transfer + +A construction verified in one world may become a high-priority proposal in a +later world. + +Transfer MUST NOT imply immediate authorization. + +The lifecycle is: + + verified old construction + -> + portable memory representation + -> + transfer proposal + -> + new-world prospective evidence + -> + verifier + -> + reuse OR rejection + +Transfer failures are themselves evidence for future routing. + +--- + +# Distributed proposal field + +M21 introduces a learned distributed routing layer. + +Its role is: + + rank likely-useful constructions and proposal families. + +It MAY learn from: + + verifier acceptances; + verifier rejections; + predictive gain; + contexts; + prior transfer outcomes. + +It MUST NOT: + + authorize a construction; + mutate canonical world state; + bypass explicit construction semantics. + +The intended architecture is: + + soft distributed intuition + -> + explicit candidate + -> + verifier + -> + canonical representation + +--- + +# Active study + +PRIME may rank possible actions or observations by how strongly they +discriminate among competing hypotheses. + +Study selection is epistemic proposal machinery. + +The selected study does not establish which hypothesis is true. + +--- + +# World model + +M21 introduces explicit transition hypotheses of the form: + + state + action -> next_state + +Transition rules have separate proposal and authorization states. + +Only verifier-authorized transition rules belong to the canonical planning +model. + +--- + +# Planning + +Planning operates over verifier-authorized world-model structure. + +Unverified transition hypotheses may be used for explicitly labelled +counterfactual exploration but may not be presented as canonical prediction. + +--- + +# Predictive quotient memory + +Semantically different constructions that induce the same predictive partition +may share a semantic-memory class. + +Memory reuse therefore targets useful informational structure rather than only +surface syntax. + +--- + +# Schema induction + +Repeated verified constructions may induce higher-order schema proposals. + +Example: + + XOR(LAG(1), LAG(4)) + XOR(LAG(2), LAG(5)) + XOR(LAG(3), LAG(6)) + +may suggest a translation-invariant relation family with normalized offset: + + XOR(offsets=(0,3)) + +The schema itself remains a proposal until separately validated. + +Long-term M21+ work may allow verified schemas to extend PRIME's construction +language. + +--- + +# Persistence and provenance + +Persistent memory artifacts must be deterministic and serializable. + +Episodic records must be hash chained. + +Transfer must retain source-memory identity. + +Construction authority remains traceable to the originating verifier receipt +chain. + +--- + +# Non-goals / claim boundary + +M21 does not establish: + + AGI; + human-level intelligence; + general language understanding; + universal representation learning; + universal causal discovery; + arbitrary-environment planning ability. + +M21 investigates whether verifier-governed representational learning can +accumulate into reusable, increasingly efficient cognitive structure. diff --git a/docs/prime_m21/M21_CONTRACT.sha256 b/docs/prime_m21/M21_CONTRACT.sha256 new file mode 100644 index 0000000..74310da --- /dev/null +++ b/docs/prime_m21/M21_CONTRACT.sha256 @@ -0,0 +1 @@ +309bbcd69fad0e08ecba0664189aa016a368b548cb7e02903b34bed44a995faa docs/prime_m21/M21_CONTRACT.md diff --git a/docs/prime_m22/M22_CONTRACT.md b/docs/prime_m22/M22_CONTRACT.md new file mode 100644 index 0000000..18a97fe --- /dev/null +++ b/docs/prime_m22/M22_CONTRACT.md @@ -0,0 +1,190 @@ +# PRIME M22 — Developmental Laboratory + +Status: + + ARCHITECTURE + DEVELOPMENT CONTRACT + +Parent: + + PRIME M21 Persistent Adaptive Cognition + +Purpose: + + Test whether verified experience accumulated across worlds improves the + efficiency with which PRIME learns later worlds. + +This is NOT yet a held-out scientific evaluation. + +--- + +# Core developmental hypothesis + +For a sequence of related but non-identical worlds: + + prior verified experience + -> + reusable semantic memory + -> + schema discovery + -> + higher-priority proposal search + -> + reduced future representation-discovery latency + +The central developmental quantity is: + + transfer gain = + cold discovery event + - + persistent discovery event + +Positive values mean accumulated cognition accelerated learning. + +--- + +# Comparison + +COLD PRIME + + Starts each chapter without cross-world semantic, episodic, schema or + proposal-routing memory. + +PERSISTENT PRIME + + Retains M21 semantic memory, episodic memory, proposal-field state and + schema knowledge across chapters. + +Both agents receive identical observation streams and identical action +randomness for the same chapter. + +--- + +# Authority invariant + +Persistent memory may alter candidate search. + +Memory does NOT authorize knowledge. + +Schema instantiation does NOT authorize knowledge. + +Proposal ranking does NOT authorize knowledge. + +Transferred constructions must still pass the M20 verifier in the new world. + +--- + +# Developmental curriculum + +The curriculum contains: + + first encounters; + exact recurrence; + shifted relational families; + higher-order relations; + distractor / CURRENT worlds. + +Representative families include: + + LAG + XOR + EQ + AND + OR + three-way XOR + three-way AND + three-way OR + +Shifted families allow schema formation such as: + + XOR(LAG(1), LAG(4)) + XOR(LAG(2), LAG(5)) + -> + proposed schema: + XOR(LAG(k), LAG(k+3)) + +The schema may generate future candidate constructions. + +Generated candidates remain proposals. + +--- + +# Candidate-field compression + +Cold search uses the full M20 candidate field: + + maximum candidates = 256 + +When persistent memory or verified schema knowledge provides useful prior +structure, Persistent PRIME may instantiate a smaller prioritized field: + + maximum candidates = 64 + +This is an explicit architectural mechanism: + + prior verified experience + -> + narrower hypothesis search + -> + reduced multiplicity cost + -> + potentially earlier authorization + +A wrong prior may therefore hurt performance. + +This is intentional. + +Transfer must earn its advantage. + +--- + +# Statistical boundary + +M22 initial development is architectural evidence only. + +The current M20 per-run global alpha guarantee applies within one chapter. + +It is NOT yet claimed to provide one lifetime alpha budget over an unbounded +developmental sequence. + +Before any M22 held-out scientific claim, a lifetime sequential-verification +budget must be frozen. + +No held-out developmental curriculum is defined in this contract. + +--- + +# Long-term M22 laboratory + +This same architecture line will be extended with: + + persistent objects; + space and navigation; + controllable interventions; + hidden transition laws; + resources; + causal experiments; + epistemic planning; + changing regimes; + representational retirement and restoration. + +M22 is one developmental-world programme, not a collection of unrelated +benchmarks. + +--- + +# Claim boundary + +Development results may show: + + cross-world reuse; + schema-guided proposal generation; + developmental acceleration; + failure or negative transfer. + +They do not establish: + + AGI; + universal meta-learning; + human-like development; + general causal discovery; + universal transfer. diff --git a/docs/prime_m22/M22_CONTRACT.sha256 b/docs/prime_m22/M22_CONTRACT.sha256 new file mode 100644 index 0000000..64946cf --- /dev/null +++ b/docs/prime_m22/M22_CONTRACT.sha256 @@ -0,0 +1 @@ +c43a32877fc18f303855c37e1e0a8c9d5f68c0a8ba5f208e2aef5dd864f04d22 docs/prime_m22/M22_CONTRACT.md diff --git a/docs/prime_m23/M23_CONTRACT.md b/docs/prime_m23/M23_CONTRACT.md new file mode 100644 index 0000000..de5b0de --- /dev/null +++ b/docs/prime_m23/M23_CONTRACT.md @@ -0,0 +1,188 @@ +# PRIME M23 — Causal Developmental Intelligence + +Parent architecture: + + M20 adaptive construction + + + M21 persistent cognition + + + M22 cognitive search ecology + +Purpose: + + Move PRIME from passive representation discovery toward active causal + experimentation and goal-directed use of verified knowledge. + +--- + +# Central loop + + observation + -> + competing causal hypotheses + -> + epistemic tension + -> + intervention selection + -> + action + -> + observation + -> + hypothesis elimination / verification + -> + persistent memory + -> + planning + -> + goal-directed action + +--- + +# Core authority rule + +A recalled causal law is not true. + +A high-ranked causal hypothesis is not true. + +A simulated consequence is not true. + +A planned trajectory is not true merely because it was generated. + +Canonical causal rules require verifier-backed evidence from the current world. + +--- + +# Developmental world + +The first M23 environment contains: + + a spatial laboratory; + an agent; + two controllable switches; + a causally controlled door; + a goal behind the door; + movement costs; + intervention costs; + hidden causal mechanisms. + +Candidate hidden mechanisms include: + + A + B + NOT A + NOT B + A AND B + A OR B + A XOR B + A EQ B + +The mechanism changes across developmental chapters. + +PRIME is not told which mechanism is active. + +--- + +# Active experimentation + +PRIME may deliberately choose switch configurations that maximally distinguish +currently viable causal hypotheses. + +The epistemic objective is therefore not merely: + + maximize immediate reward + +but also: + + maximize useful discrimination among hypotheses. + +--- + +# Persistent causal experience + +Verified mechanisms from earlier chapters may become priors in later chapters. + +A prior may alter experiment order. + +A prior may reduce expected identification cost. + +A wrong prior must remain falsifiable. + +Prior knowledge may bias cognition. + +Prior knowledge may not bound cognition. + +--- + +# Planning + +Once a causal mechanism is verified, PRIME must use it to determine a switch +configuration that opens the door and then reach the goal. + +Thus the architecture must connect: + + causal discovery + -> + verified world knowledge + -> + planning + -> + action. + +--- + +# Main developmental comparisons + +COLD + + no causal memory across chapters. + +PERSISTENT + + retains verified causal experience and meta-learning. + +Primary architectural measurements: + + mechanism identification success; + intervention count; + primitive action cost; + goal completion; + incorrect-prior recovery; + prior hit rate; + causal-memory growth; + improvement over developmental time. + +--- + +# Scientific boundary + +Initial M23 runs are DEVELOPMENT ONLY. + +No held-out claim is permitted until: + + environment generation is frozen; + developmental and held-out chapter sets are separated; + causal verifier semantics are frozen; + lifetime error-budget semantics are defined; + analysis protocol is frozen. + +--- + +# Long-term destination + +M23 will grow from this laboratory into worlds containing: + + multiple objects; + hidden object identity; + spatial uncertainty; + delayed effects; + resources; + stochastic mechanisms; + regime changes; + object permanence; + composition of causal mechanisms; + counterfactual planning; + causal schema induction. + +The programme target is active, persistent, verifier-governed world-model +development. diff --git a/docs/prime_m23/M23_CONTRACT.sha256 b/docs/prime_m23/M23_CONTRACT.sha256 new file mode 100644 index 0000000..6a79aca --- /dev/null +++ b/docs/prime_m23/M23_CONTRACT.sha256 @@ -0,0 +1 @@ +56ea1c15677b57261afee1260b3f57f426c6b18bf3f44a41ca5d922859365390 docs/prime_m23/M23_CONTRACT.md diff --git a/docs/prime_m25/M25_CONTRACT.md b/docs/prime_m25/M25_CONTRACT.md new file mode 100644 index 0000000..b167b87 --- /dev/null +++ b/docs/prime_m25/M25_CONTRACT.md @@ -0,0 +1,103 @@ +# PRIME M25 — Epistemic Control and Lifelong Causal Search + +Parent: + + M20 representation construction + M21 persistent cognition + M22 hypothesis ecology + M23 active intervention + M24 explicit causal-program authority + +M25 replaces sequential remembered-theory testing with universal weighted +active experiment design. + +--- + +## Universal support + +Every frozen causal program receives positive baseline hypothesis mass. + +Memory and schema experience may add proposal mass. + +Total experience-derived bonus mass may not exceed the universal baseline +mass. + +Therefore prior experience may bias but may not eliminate any causal program. + +--- + +## Authority + +Hypothesis mass is not probability of truth for authority purposes. + +Hypothesis rank is not authority. + +Experiment-selection score is not authority. + +Canonical causal knowledge still requires exact compatibility to leave one +program in the frozen causal universe and a valid CausalAuthorityLedger receipt. + +--- + +## Epistemic control + +For surviving causal programs under intervention x: + + m0(x) = + total proposal mass predicting outcome 0 + + m1(x) = + total proposal mass predicting outcome 1 + +The deterministic information-splitting objective is proportional to: + + m0(x) * m1(x) + +M25 additionally prices the primitive physical cost c(x) of executing the +intervention from the agent's current state: + + score(x) = + m0(x) * m1(x) / c(x) + +Thus PRIME jointly considers: + + epistemic discrimination + and + physical experimentation cost. + +--- + +## Development + +Initial M25 development uses a deterministic 128-chapter causal lifetime. + +The curriculum is generated algorithmically rather than hand-optimised +chapter-by-chapter. + +Cold and Persistent PRIME use the same epistemic-control algorithm. + +They differ only in accumulated causal hypothesis mass. + +Measurements include: + + causal identification interventions; + primitive physical steps; + exact-memory reuse; + schema-biased unseen mechanisms; + early/middle/late developmental gain; + authority integrity; + episodic integrity. + +--- + +## Claim boundary + +Initial results are DEVELOPMENT ONLY. + +No held-out claim is allowed without a separately frozen generator, lifetime +error semantics and held-out analysis protocol. + +M25 does not establish general causal intelligence. + +Its purpose is to test whether persistent verified causal experience can alter +global experiment design without becoming epistemic authority. diff --git a/docs/prime_m25/M25_CONTRACT.sha256 b/docs/prime_m25/M25_CONTRACT.sha256 new file mode 100644 index 0000000..4c25ce4 --- /dev/null +++ b/docs/prime_m25/M25_CONTRACT.sha256 @@ -0,0 +1 @@ +83ca430ecbd886ad14bc66f84154ffacdb17c6acf5ea1bedcbdd5fe3dfa8e64a docs/prime_m25/M25_CONTRACT.md diff --git a/docs/prime_m26/PROTOCOL_V0_1.md b/docs/prime_m26/PROTOCOL_V0_1.md new file mode 100644 index 0000000..e865860 --- /dev/null +++ b/docs/prime_m26/PROTOCOL_V0_1.md @@ -0,0 +1,223 @@ +# PRIME M26 — Comparative Cognition Arena v0.1 + +Status: + + DEVELOPMENT PROTOCOL + +Purpose: + + Compare verifier-governed adaptive explicit representation learning + against learned recurrent state. + +This is diagnostic capability cartography. + +It is not designed to declare one architecture universally superior. + +--- + +# Conditions + +REACTIVE + + Current observation only. + +H8 + + Raw trailing 8-observation history. + +H16 + + Raw trailing 16-observation history. + +GRU32 + + Learned recurrent neural state. + + Architecture: + + GRUCell + input dimension 1 + hidden dimension 32 + linear binary output + + Online optimization: + + Adam + learning rate 0.01 + deterministic CPU execution + truncated replay length 32 + gradient clipping 1.0 + +PRIME + + CompositionalAdaptiveConstructionEngine + + maximum lag: + 16 + + maximum candidate field: + 512 + + higher-order scaffolds: + enabled + + verifier authority: + unchanged + + learned neural machinery: + none + +--- + +# Development + +Development seeds: + + 26000..26005 + +Six stream seeds. + +No held-out evaluation is authorized by this protocol. + +Future evaluation seeds are reserved but blocked: + + 36000..36031 + +--- + +# Episode + +Scored events per world: + + 1536 + +Final window: + + 256 + +All conditions for one task/seed receive exactly the same observation stream. + +--- + +# Task family A — Explicit relational structure + +CURRENT + +LAG-1 + +LAG-4 + +XOR-1-4 + +EQ-1-4 + +AND-1-4 + +OR-2-7 + +XOR-1-2-3 + +These largely match PRIME's explicit construction language. + +--- + +# Task family B — Representational scaling + +LAG-8 + +LAG-16 + +XOR-1-8 + +XOR-1-16 + +MAJORITY-16 + +These test longer temporal dependencies and scaling cost. + +MAJORITY-16 is not directly represented by the current PRIME +construction grammar. + +--- + +# Task family C — Recurrent latent state + +RUNNING-PARITY + +MOD3-ONES + +TOGGLE-ON-11 + +RUN-LENGTH-PARITY + +These require persistent state summaries not naturally expressible as fixed +bounded lag expressions. + +They deliberately provide learned recurrence with genuine home-field tasks. + +--- + +# Task family D — Nonstationarity + +XOR-TO-AND + +First half: + + XOR(LAG1, LAG4) + +Second half: + + AND(LAG1, LAG4) + +No explicit regime-change signal is supplied. + +--- + +# Measurements + +For every condition/world: + + online AULC; + total accuracy; + final-window accuracy; + cumulative mistakes. + +For PRIME: + + first authorization event; + active construction count; + predictive-partition recovery where an explicit target exists; + receipt-chain integrity. + +For GRU: + + final training loss; + trainable parameter count. + +--- + +# Interpretation + +The benchmark distinguishes: + + symbolic / relational construction strength; + + raw-memory scaling; + + recurrent-state strength; + + nonstationary adaptation. + +A mixed result is desirable. + +If one architecture wins every family, benchmark bias must be considered. + +--- + +# Claim boundary + +Development results are descriptive. + +No held-out scientific claim may be made from this protocol. + +No AGI, general intelligence or universal superiority claim is permitted. diff --git a/docs/prime_m26/PROTOCOL_V0_1.sha256 b/docs/prime_m26/PROTOCOL_V0_1.sha256 new file mode 100644 index 0000000..d7bbdfb --- /dev/null +++ b/docs/prime_m26/PROTOCOL_V0_1.sha256 @@ -0,0 +1 @@ +d5547d5537f24911564e5e5951b07ea438051cf7b2c6f1b5c5f34211110d2bbb docs/prime_m26/PROTOCOL_V0_1.md diff --git a/docs/problem-analysis-workflow.md b/docs/problem-analysis-workflow.md new file mode 100644 index 0000000..c5f7775 --- /dev/null +++ b/docs/problem-analysis-workflow.md @@ -0,0 +1,87 @@ +# PRIME-governed TS problem analysis (M19.1) + +M19.1 adds one bounded path from a structured `ProblemSpec` to the canonical +PRIME v19 graph. It does not make arbitrary prose true and it does not govern +the older direct graph-writing surfaces elsewhere in BoggersTheAI. + +## Authority path + +The workflow follows this fixed wave: + +`READY -> BOUND -> FIELD_READY -> FOCUSED -> PROPOSED -> ROUTED -> REQUEST_READY -> SUBMITTED -> COMMITTED | REJECTED | ABSTAINED | FAIL_CLOSED` + +1. `ProblemSpec` bounds the question, context, constraints, desired outcomes, + failure modes, testable predictions, scope, and source provenance. +2. The existing `constraint_fields` library projects that structure into a + deterministic field. Native finite floats are converted to exact tagged + `float.hex()` values; non-finite floats, non-string keys, and source-authored + numeric tags are rejected. +3. The active frontier records primitives, tension markers, and the + `Propagate -> Relax -> Break -> Evolve` trajectory without model scores. +4. A mounted sealed-v18 proposer may provide rank-only advice through the tiny + `AdviceProtocol`. Its exact archive, manifest, sealed-release, scientific + freeze, parent field, field model, NumPy archive, tensor, worker request, and + result bindings are checked. Invalid or unavailable advice is ablated. Raw + advice remains receipt evidence only; it is never promoted into or hashed + into the canonical semantic node. +5. Three independent, fingerprinted validators recompute the workflow boundary, + field integrity, and provenance binding from untrusted evidence. + A signed shared-evidence bundle hash commits every common field across all + three obligation envelopes, preventing split-view verifier attacks. +6. Only a caller-supplied PRIME `AuthorityKernel` can publish the change. + +The only permitted canonical change is one add-only node of kind +`ts.problem_analysis`. Edges, deletion, overwrite, executable payloads, +representation transitions, unknown kinds, missing evidence, and stale parents +fail closed. The node means “deterministically validated constraint-field +analysis”; it is explicitly not a world-truth claim. + +The node id is the full normalized `ProblemSpec` SHA-256. Its payload is a pure +function of that spec, the deterministic field/focus projection, and stable +workflow semantics. Advice, mount/runtime details, parent roots, authority tips, +and sequence numbers remain signed proposal/evidence/receipt bindings only. +Consequently advice availability and problem commit order cannot change the +canonical node content, and equivalent final problem sets converge to the same +graph root. + +The v1 identity contract freezes the workflow/projection semantics carried by +`boggers-ts-problem-spec-v1`. Any future projection or canonical-semantics +change must introduce a new ProblemSpec schema and node identity namespace; +reusing the v1 schema with different canonical semantics is forbidden. + +## Boot boundary + +`build_problem_workflow_kernel` requires the caller to supply independent +authority, proposer, workflow-verifier, field-verifier, provenance-verifier, +and economics-verifier identities and keys. The proposer is semantic-only. +Policy maps only `ts.problem_analysis`; representation economics is still +registered and every representation path is denied. This package contains no +production or default key material. + +The specialized builder always starts from an empty genesis. Existing state +can enter only through an authenticated, replay-verified checkpoint whose graph +lineage matches the requested lineage. Restore additionally audits the entire +receipt ledger from a fresh empty kernel and requires the reconstructed graph, +tip, sequence, and budgets to equal the checkpoint state; an authenticated +checkpoint containing unvalidated genesis state is rejected. Supplying a separately constructed +`AuthorityKernel` to `ProblemAnalysisWorkflow` is an explicit caller-trusted +policy, registry, and genesis boundary; the workflow cannot retroactively +validate that kernel's boot state. + +## Honest limits + +- The workflow does not call the Universal Living Graph or `commit_document`. + PRIME is the sole canonical writer for this path, but other legacy Boggers + paths still require migration before repo-wide authority can be claimed. +- Sealed-v18 executes through PRIME's proposal-only subprocess mount. A + subprocess is not a full operating-system security boundary; production use + still needs a separate user, container, or service boundary. +- `AdviceProtocol` strictly validates the exact claimed v18 receipt and result + fields, but an arbitrary caller-supplied object can imitate that structural + shape. Real sealed-parent provenance requires passing the object returned by + `mount_v18_proposer`; this remains canonically inert evidence, not independent + third-party attestation. +- PRIME's present same-process HMAC design is tamper evidence, not independent + third-party attestation. Rollback/fork detection requires an external anchor. +- The structured projection validates integrity and deterministic mechanics, + not the empirical truth of user-supplied premises or predictions. diff --git a/experiments/prime_canonical_agent_benchmark_v1/DEVELOPMENT_BASELINE_SELECTION.json b/experiments/prime_canonical_agent_benchmark_v1/DEVELOPMENT_BASELINE_SELECTION.json new file mode 100644 index 0000000..c2de2bd --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/DEVELOPMENT_BASELINE_SELECTION.json @@ -0,0 +1,54 @@ +{ + "contract_sha256": "91681a38971cf85eb3315a5b56ab9fd7064c65f1a4c2575ab390eba8be372a48", + "development_seeds": [ + 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 + ], + "implementation_sha256": "4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df", + "rows": [ + { + "condition": "FIXED-H1", + "mean_primary_aulc_ppm": 723264 + }, + { + "condition": "FIXED-H2", + "mean_primary_aulc_ppm": 831342 + }, + { + "condition": "FIXED-H4", + "mean_primary_aulc_ppm": 918812 + } + ], + "selected_fixed_baseline": "FIXED-H4", + "selection_rule": "highest mean primary_aulc_ppm; ties select smaller depth" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1/DEVELOPMENT_BASELINE_SELECTION.sha256 b/experiments/prime_canonical_agent_benchmark_v1/DEVELOPMENT_BASELINE_SELECTION.sha256 new file mode 100644 index 0000000..3a765ea --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/DEVELOPMENT_BASELINE_SELECTION.sha256 @@ -0,0 +1 @@ +a3c9b203d3c9882bea6644d64a8cf509c6254576f680fe15dc0b19fe536c6f19 DEVELOPMENT_BASELINE_SELECTION.json diff --git a/experiments/prime_canonical_agent_benchmark_v1/EXPERIMENT_CONTRACT.md b/experiments/prime_canonical_agent_benchmark_v1/EXPERIMENT_CONTRACT.md new file mode 100644 index 0000000..9719865 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/EXPERIMENT_CONTRACT.md @@ -0,0 +1,416 @@ +# PRIME Canonical Agent Benchmark v1 +## Frozen Experimental Contract + +Status: FROZEN BEFORE BENCHMARK IMPLEMENTATION OR RESULT INSPECTION + +This document defines the first canonical controlled experiment for testing +whether verifier-governed adaptive representation repair provides measurable +decision-making benefit under partial observability. + +The contract must not be edited in response to benchmark outcomes. + +If the design itself later proves defective, the experiment is retired and a +new version is created with explicit lineage. Results from this version are not +silently reinterpreted under a changed contract. + +--- + +# 1. Primary research question + +Does verifier-governed adaptive representation repair improve online learning +under partial observability when the minimum useful memory representation +varies between worlds? + +The tested mechanism is not merely "more memory." + +The tested mechanism is: + + observation/history + -> detect representation obstruction + -> propose bounded representation growth + -> independently verify candidate repair + -> authorize or reject repair + -> continue learning with canonical receipt history + +Proposal is never authority. + +--- + +# 2. Primary claim + +The FULL PRIME condition will be considered supported on this benchmark only if +it achieves better frozen-evaluation learning efficiency than the fixed +representation selected using development worlds, while maintaining competitive +final task performance. + +The benchmark does not presuppose that this claim is true. + +A null or negative result is a valid result. + +--- + +# 3. Explicit non-claims + +This benchmark does NOT by itself establish: + +- general intelligence; +- AGI; +- universal superiority of TS or PRIME; +- superiority over all recurrent neural architectures; +- optimal POMDP solution; +- production security; +- external scientific replication; +- broad real-world generalisation; +- that the sealed PRIME v18 proposal model is semantic authority. + +The first benchmark is a controlled mechanistic test. + +Broader claims require stronger external environments and learned-memory +baselines. + +--- + +# 4. Controlled environment family + +Working environment name: + + MemoryAlias-POMDP + +Each world contains a latent dependency depth: + + d in {0, 1, 2, 4} + +The agent is NOT told d. + +At each decision step the environment exposes only the current binary +observation. + +The correct action depends on information whose required temporal depth is +determined by d. + +Therefore the current observation is insufficient in worlds with d > 0. + +The implementation may retain past observations/actions only through the +representation supplied to that experimental condition. + +No agent may inspect: + +- latent environment state; +- d; +- future observations; +- evaluation labels before acting; +- another condition's internal state. + +Environment randomness must be deterministic from an explicit seed. + +The exact environment transition/reward implementation must be committed before +the first reported benchmark result and thereafter remain frozen for v1. + +--- + +# 5. Representation family + +The initial representation is observation-only. + +Permitted candidate history depths are: + + 0 + 1 + 2 + 4 + +Representation growth is monotone within an experimental run. + +FULL PRIME begins at depth 0. + +A repair proposal may only request the next permitted representation depth. + +The maximum number of accepted representation-growth operations in one run is +three. + +No repair may inject the hidden world parameter d. + +--- + +# 6. Experimental conditions + +At minimum the benchmark must contain: + +A. REACTIVE + Observation-only representation for the entire run. + +B. FIXED-H1 + Fixed history depth 1. + +C. FIXED-H2 + Fixed history depth 2. + +D. FIXED-H4 + Fixed history depth 4. + +E. ADAPTIVE-NO-VERIFIER + Uses the same obstruction/proposal mechanism as FULL PRIME but accepts a + proposed representation expansion without independent verifier authority. + +F. VERIFIER-NO-REPAIR + Runs verifier/evidence machinery but representation growth is disabled. + +G. FULL-PRIME + Obstruction detection, proposal, independent verification, authorization, + canonical repair receipt, and continued learning. + +All conditions must use the same underlying task-learning algorithm wherever +the comparison permits. + +Representation management, not a secretly stronger learner, is the intended +independent variable. + +--- + +# 7. Verifier requirement + +FULL PRIME candidate repair must be evaluated using evidence distinct from the +proposal decision itself. + +The verifier must independently compare the current representation against the +candidate representation on a bounded replay/evidence slice. + +The acceptance rule must include both: + +1. predictive/decision evidence supporting the candidate representation; and +2. an explicit complexity cost for representation growth. + +The proposal component may not directly authorize canonical representation +change. + +Rejected proposals have zero canonical representation effect. + +--- + +# 8. Development/evaluation separation + +Development world seeds: + + 0 through 31 inclusive + +Frozen evaluation world seeds: + + 1000 through 1127 inclusive + +Evaluation seeds are frozen but NOT claimed to be cryptographically blinded +from the implementer. + +Development worlds may be used to: + +- debug implementation; +- set implementation-correctness constants; +- select the fixed-history comparison baseline from H1/H2/H4. + +Frozen evaluation worlds must not be used to choose: + +- thresholds after seeing evaluation performance; +- alternative metrics; +- favourable baseline definitions; +- favourable environment variants; +- favourable seed subsets. + +All 128 frozen evaluation seeds must be reported. + +--- + +# 9. Primary metric + +Primary metric: + + area under the online learning curve + +computed over the preregistered training horizon. + +The exact horizon and normalization must be fixed in code before the first +evaluation-result inspection and recorded in the benchmark manifest. + +Higher is better. + +The metric must use every preregistered evaluation episode. + +No episode deletion is allowed except for a run that fails a predeclared +integrity check, in which case the complete failed run remains recorded. + +--- + +# 10. Secondary metrics + +The benchmark must also report: + +- final-window mean reward; +- cumulative regret against the environment's available optimal action; +- accepted repair count; +- rejected repair count; +- proposed repair count; +- final representation depth; +- representation-change episode indices; +- adaptation latency; +- canonical receipt count; +- integrity failures; +- deterministic run identity. + +Where meaningful, representation complexity must be reported alongside reward. + +--- + +# 11. Baseline selection rule + +The single FIXED representation used for the primary head-to-head comparison is +selected using development worlds only. + +The rule is: + +1. run FIXED-H1, FIXED-H2, and FIXED-H4 on every development seed; +2. select the depth with the highest mean primary metric; +3. ties select the smaller representation. + +After selection, that baseline is frozen for evaluation. + +All fixed baselines must still be reported on evaluation worlds. + +--- + +# 12. Success criterion + +The primary claim is supported only if, on all frozen evaluation worlds: + +1. FULL PRIME has positive paired mean primary-metric difference versus the + development-selected fixed baseline; + +2. a deterministic paired bootstrap 95% confidence interval for that + difference has lower bound greater than zero; + +3. FULL PRIME final-window reward is not materially degraded relative to that + selected fixed baseline; + +4. the improvement is not reproduced equally or better by the + ADAPTIVE-NO-VERIFIER ablation without being explicitly reported; + +5. all integrity and receipt checks pass. + +If condition 1 or 2 fails, the primary advantage claim is unsupported. + +If FULL PRIME loses, that result is retained. + +--- + +# 13. Ablation interpretation + +The benchmark must not report only FULL PRIME versus weak baselines. + +Interpretation requires examining: + +FULL PRIME vs ADAPTIVE-NO-VERIFIER + +to test whether verifier gating contributes useful selectivity; + +FULL PRIME vs VERIFIER-NO-REPAIR + +to test whether representation repair itself contributes useful adaptation; + +FULL PRIME vs fixed representations + +to test whether adaptive representation choice contributes learning efficiency. + +Ablation failures must be discussed rather than hidden. + +--- + +# 14. Determinism and provenance + +Each run must bind at least: + +- benchmark version; +- source commit; +- environment configuration; +- condition; +- world seed; +- learner seed; +- representation parameters; +- verifier parameters; +- result payload; +- receipt chain or equivalent canonical evidence. + +Canonical reports must contain no timestamps, random UUIDs, machine-specific +absolute paths, or scheduler-dependent ordering. + +Repeated execution from the same source/configuration must reproduce identical +canonical result bytes. + +--- + +# 15. Tamper and replay requirements + +Before public interpretation, v1 must test: + +- result tampering; +- receipt tampering; +- representation-repair receipt tampering; +- seed/configuration mismatch; +- replay from an empty benchmark state; +- duplicate result insertion; +- altered environment manifest; +- altered frozen contract. + +Tampered evidence must fail closed. + +--- + +# 16. Public-result gate + +A public claim stronger than: + + "controlled benchmark evidence" + +requires at least one additional learned-memory baseline. + +Candidate later baselines include: + +- recurrent neural agent; +- GRU/LSTM state estimator; +- learned latent-state model. + +Those may require PyTorch and belong to a later benchmark layer if not present +in the dependency-free v1 harness. + +Their absence must be stated clearly. + +--- + +# 17. Architecture constraint + +This benchmark does not create a parallel PRIME. + +It lives in the existing BoggersTheAI / PRIME research lineage. + +Existing PRIME authority boundaries remain authoritative. + +The sealed PRIME v18 archive remains immutable and proposal-only. + +Learned or heuristic machinery may propose. + +Verifier-governed authority decides canonical repair. + +--- + +# 18. Falsification policy + +No mechanism is protected from a negative result. + +If: + +- representation repair does not improve learning; +- verifier gating does not help; +- fixed history wins; +- complexity costs dominate; +- the adaptive condition becomes unstable; + +the result is evidence about the architecture. + +The benchmark exists to reduce uncertainty, not to manufacture a win. + diff --git a/experiments/prime_canonical_agent_benchmark_v1/EXPERIMENT_CONTRACT.sha256 b/experiments/prime_canonical_agent_benchmark_v1/EXPERIMENT_CONTRACT.sha256 new file mode 100644 index 0000000..bacbb97 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/EXPERIMENT_CONTRACT.sha256 @@ -0,0 +1 @@ +91681a38971cf85eb3315a5b56ab9fd7064c65f1a4c2575ab390eba8be372a48 EXPERIMENT_CONTRACT.md diff --git a/experiments/prime_canonical_agent_benchmark_v1/RETIREMENT.md b/experiments/prime_canonical_agent_benchmark_v1/RETIREMENT.md new file mode 100644 index 0000000..79bfd5b --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/RETIREMENT.md @@ -0,0 +1,85 @@ +# PRIME Canonical Agent Benchmark v1 — Retirement Record + +Status: RETIRED BEFORE ADAPTIVE IMPLEMENTATION AND BEFORE FROZEN EVALUATION + +The v1 experiment is retired because its frozen repair-transition rule is +incompatible with the information structure of its frozen environment. + +No evaluation seeds in the frozen range 1000 through 1127 were run before this +retirement decision. + +## Defect + +The environment uses binary observations with target action + + Y_t = X_(t-d) + +for hidden depth + + d in {0, 1, 2, 4}. + +The frozen contract required FULL PRIME to: + +1. begin at history depth 0; +2. propose only the next permitted history depth; +3. require predictive/decision evidence plus representation complexity cost + before authorizing repair. + +For d = 2, the intermediate depth-1 representation is + + H1_t = (X_(t-1), X_t) + +while the target is + + Y_t = X_(t-2). + +Under the frozen iid-style binary observation generator, H1_t contains no +systematic predictive information about Y_t beyond chance. + +Therefore an honest predictive verifier should not be expected to authorize +the H0 -> H1 transition after complexity cost. + +But without accepting H1, the frozen next-depth-only rule prevents PRIME from +ever proposing H2. + +For d = 4, the same structural problem prevents justified traversal through +intermediate H1 and H2 representations before reaching H4. + +## Consequence + +Continuing v1 would force one of two scientifically unacceptable choices: + +- make the verifier accept representation growth without supporting + predictive/decision evidence; or +- leave FULL PRIME structurally unable to reach representations that the + benchmark was intended to test. + +Neither is acceptable. + +## Preserved evidence + +The following remain valid historical artifacts: + +- the original frozen v1 experiment contract; +- the dependency-free environment; +- the common tabular learner; +- the fixed baseline apparatus; +- the development-only baseline selection; +- the selection of FIXED-H4 under the frozen development rule. + +These are not deleted or rewritten. + +## Resolution + +A successor experiment will retain the frozen environment, learner, fixed +baselines, metrics, development/evaluation split, and evaluation seeds. + +The repair rule will be changed explicitly so that obstruction may produce a +bounded set of strictly deeper candidate representations. + +Independent verifier authority will score those candidates and may authorize +the smallest candidate that supplies sufficient penalized predictive/decision +improvement. + +This retirement occurred before adaptive implementation and before frozen +evaluation inspection. diff --git a/experiments/prime_canonical_agent_benchmark_v1/RETIREMENT.sha256 b/experiments/prime_canonical_agent_benchmark_v1/RETIREMENT.sha256 new file mode 100644 index 0000000..517d6fe --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/RETIREMENT.sha256 @@ -0,0 +1 @@ +2f142e51e1dd8d7d63091e5b3aaf085e7603f3243baba04f3180d868464d134e RETIREMENT.md diff --git a/experiments/prime_canonical_agent_benchmark_v1/__init__.py b/experiments/prime_canonical_agent_benchmark_v1/__init__.py new file mode 100644 index 0000000..9329675 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/__init__.py @@ -0,0 +1,5 @@ +"""PRIME Canonical Agent Benchmark v1. + +The frozen experimental contract lives beside this package. +Do not alter that contract in response to benchmark outcomes. +""" diff --git a/experiments/prime_canonical_agent_benchmark_v1/baselines.py b/experiments/prime_canonical_agent_benchmark_v1/baselines.py new file mode 100644 index 0000000..a703843 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/baselines.py @@ -0,0 +1,39 @@ +"""Representation definitions for the initial frozen baseline apparatus.""" + +from dataclasses import dataclass, field + + +@dataclass +class HistoryRepresentation: + depth: int + _history: list[int] = field(default_factory=list) + + def reset(self) -> None: + self._history.clear() + + def observe(self, observation: int) -> tuple[int, ...]: + if observation not in (0, 1): + raise ValueError("observation must be binary") + + self._history.append(observation) + + max_width = self.depth + 1 + if len(self._history) > max_width: + self._history = self._history[-max_width:] + + # Left-pad initial history deterministically. + padding = (0,) * (max_width - len(self._history)) + return padding + tuple(self._history) + + +def depth_for_condition(condition: str) -> int: + mapping = { + "REACTIVE": 0, + "FIXED-H1": 1, + "FIXED-H2": 2, + "FIXED-H4": 4, + } + try: + return mapping[condition] + except KeyError as exc: + raise ValueError(f"unknown fixed condition: {condition}") from exc diff --git a/experiments/prime_canonical_agent_benchmark_v1/deterministic.py b/experiments/prime_canonical_agent_benchmark_v1/deterministic.py new file mode 100644 index 0000000..449c6b2 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/deterministic.py @@ -0,0 +1,26 @@ +"""Small deterministic primitives with no runtime randomness dependency.""" + +MASK64 = (1 << 64) - 1 + + +def splitmix64(value: int) -> int: + """Return one SplitMix64 output for an integer input.""" + z = (value + 0x9E3779B97F4A7C15) & MASK64 + z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & MASK64 + z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & MASK64 + return (z ^ (z >> 31)) & MASK64 + + +def deterministic_bit(seed: int, index: int) -> int: + """Generate a deterministic binary symbol.""" + value = splitmix64((seed & MASK64) ^ splitmix64(index & MASK64)) + return value & 1 + + +def learner_draw(seed: int, index: int) -> int: + """Deterministic pseudo-random 64-bit learner draw.""" + return splitmix64( + (seed & MASK64) + ^ 0xA0761D6478BD642F + ^ splitmix64(index & MASK64) + ) diff --git a/experiments/prime_canonical_agent_benchmark_v1/environment.py b/experiments/prime_canonical_agent_benchmark_v1/environment.py new file mode 100644 index 0000000..e19b470 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/environment.py @@ -0,0 +1,89 @@ +"""Dependency-free partially observable environment for benchmark v1.""" + +from dataclasses import dataclass + +from .deterministic import deterministic_bit, splitmix64 +from .manifest import DECISION_STEPS_PER_EPISODE, PERMITTED_DEPTHS, WARMUP_STEPS + + +@dataclass(frozen=True) +class StepResult: + reward: int + scored: bool + done: bool + next_observation: int | None + + +class MemoryAliasPOMDP: + """Binary-observation POMDP with hidden required temporal depth. + + The correct scored action at time t is the observation seen d steps earlier, + where d is a hidden world property in {0, 1, 2, 4}. + + The agent receives observations only through reset() and step(). + The hidden depth is never exposed through the public environment API. + """ + + def __init__(self, world_seed: int): + if not isinstance(world_seed, int) or isinstance(world_seed, bool): + raise TypeError("world_seed must be an integer") + + self._world_seed = world_seed + self._depth = PERMITTED_DEPTHS[world_seed % len(PERMITTED_DEPTHS)] + self._episode = -1 + self._stream: tuple[int, ...] = () + self._index = 0 + + def reset(self, episode: int) -> int: + if not isinstance(episode, int) or isinstance(episode, bool): + raise TypeError("episode must be an integer") + if episode < 0: + raise ValueError("episode must be non-negative") + + self._episode = episode + self._index = 0 + + total = WARMUP_STEPS + DECISION_STEPS_PER_EPISODE + + episode_seed = splitmix64( + (self._world_seed & ((1 << 64) - 1)) + ^ splitmix64(episode) + ^ 0xE7037ED1A0B428DB + ) + + self._stream = tuple( + deterministic_bit(episode_seed, i) + for i in range(total) + ) + + return self._stream[0] + + def step(self, action: int) -> StepResult: + if action not in (0, 1): + raise ValueError("action must be 0 or 1") + if self._episode < 0: + raise RuntimeError("reset() must be called before step()") + if self._index >= len(self._stream): + raise RuntimeError("episode already complete") + + current_index = self._index + scored = current_index >= WARMUP_STEPS + + if scored: + target_index = current_index - self._depth + target = self._stream[target_index] + reward = int(action == target) + else: + reward = 0 + + done = current_index == len(self._stream) - 1 + self._index += 1 + + next_observation = None if done else self._stream[self._index] + + return StepResult( + reward=reward, + scored=scored, + done=done, + next_observation=next_observation, + ) diff --git a/experiments/prime_canonical_agent_benchmark_v1/learner.py b/experiments/prime_canonical_agent_benchmark_v1/learner.py new file mode 100644 index 0000000..34164bd --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/learner.py @@ -0,0 +1,76 @@ +"""Common tabular learner used by all dependency-free fixed baselines.""" + +from dataclasses import dataclass, field + +from .deterministic import learner_draw +from .manifest import EXPLORATION_PERIOD + + +@dataclass +class BinaryTabularLearner: + """Deterministic epsilon-like tabular learner. + + Every condition uses the same learner. Only the supplied representation + depth differs. + + Action values are empirical binary-reward means compared exactly via + integer cross multiplication, avoiding floating-point ambiguity. + """ + + seed: int + successes: dict[tuple[tuple[int, ...], int], int] = field( + default_factory=dict + ) + counts: dict[tuple[tuple[int, ...], int], int] = field(default_factory=dict) + decision_index: int = 0 + + def choose(self, state: tuple[int, ...]) -> int: + draw = learner_draw(self.seed, self.decision_index) + + # Fixed 10% deterministic exploration. + explore = self.decision_index % EXPLORATION_PERIOD == 0 + + if explore: + action = (draw >> 8) & 1 + else: + action = self._greedy_action(state, draw) + + self.decision_index += 1 + return int(action) + + def _greedy_action(self, state: tuple[int, ...], draw: int) -> int: + k0 = (state, 0) + k1 = (state, 1) + + c0 = self.counts.get(k0, 0) + c1 = self.counts.get(k1, 0) + s0 = self.successes.get(k0, 0) + s1 = self.successes.get(k1, 0) + + if c0 == 0 and c1 == 0: + return int(draw & 1) + if c0 == 0: + return 0 + if c1 == 0: + return 1 + + # Compare s0/c0 to s1/c1 without floats. + left = s0 * c1 + right = s1 * c0 + + if left > right: + return 0 + if right > left: + return 1 + + return int(draw & 1) + + def update( + self, + state: tuple[int, ...], + action: int, + reward: int, + ) -> None: + key = (state, action) + self.counts[key] = self.counts.get(key, 0) + 1 + self.successes[key] = self.successes.get(key, 0) + reward diff --git a/experiments/prime_canonical_agent_benchmark_v1/manifest.py b/experiments/prime_canonical_agent_benchmark_v1/manifest.py new file mode 100644 index 0000000..d29c094 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/manifest.py @@ -0,0 +1,28 @@ +"""Frozen implementation constants for PRIME Canonical Agent Benchmark v1.""" + +BENCHMARK_VERSION = "prime-canonical-agent-benchmark-v1" + +# Frozen before any evaluation-seed result inspection. +DEVELOPMENT_SEEDS = tuple(range(0, 32)) +EVALUATION_SEEDS = tuple(range(1000, 1128)) + +PERMITTED_DEPTHS = (0, 1, 2, 4) +CONDITIONS = ( + "REACTIVE", + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", +) + +# The dependency-free apparatus is frozen at this horizon before adaptive +# PRIME is implemented. +EPISODES = 64 +DECISION_STEPS_PER_EPISODE = 64 +WARMUP_STEPS = 4 +FINAL_WINDOW_EPISODES = 8 + +# Deterministic exploration: exactly 1 in every 10 decisions is exploratory. +EXPLORATION_PERIOD = 10 + +# Canonical integer scaling for learning-curve statistics. +PPM = 1_000_000 diff --git a/experiments/prime_canonical_agent_benchmark_v1/provenance.py b/experiments/prime_canonical_agent_benchmark_v1/provenance.py new file mode 100644 index 0000000..52f99bd --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/provenance.py @@ -0,0 +1,74 @@ +"""Canonical benchmark provenance helpers.""" + +import hashlib +from pathlib import Path +import subprocess + + +BENCHMARK_DIR = Path(__file__).resolve().parent +REPO_ROOT = BENCHMARK_DIR.parent.parent + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def contract_sha256() -> str: + contract = BENCHMARK_DIR / "EXPERIMENT_CONTRACT.md" + expected_file = BENCHMARK_DIR / "EXPERIMENT_CONTRACT.sha256" + + expected = expected_file.read_text(encoding="utf-8").split()[0] + actual = _sha256(contract) + + if actual != expected: + raise RuntimeError("frozen experiment contract hash mismatch") + + return actual + + +def source_commit() -> str: + result = subprocess.run( + ["git", "-C", str(REPO_ROOT), "rev-parse", "HEAD"], + check=True, + capture_output=True, + text=True, + ) + commit = result.stdout.strip() + + if len(commit) != 40: + raise RuntimeError("unexpected git commit identity") + + return commit + + +def source_dirty() -> bool: + result = subprocess.run( + ["git", "-C", str(REPO_ROOT), "status", "--porcelain"], + check=True, + capture_output=True, + text=True, + ) + return bool(result.stdout.strip()) + + +def implementation_sha256() -> str: + """Hash the complete Python implementation of benchmark v1.""" + + digest = hashlib.sha256() + + paths = sorted( + path + for path in BENCHMARK_DIR.glob("*.py") + if path.name != "__pycache__" + ) + + for path in paths: + relative = path.name.encode("utf-8") + payload = path.read_bytes() + + digest.update(len(relative).to_bytes(8, "big")) + digest.update(relative) + digest.update(len(payload).to_bytes(8, "big")) + digest.update(payload) + + return digest.hexdigest() diff --git a/experiments/prime_canonical_agent_benchmark_v1/run_development_baselines.py b/experiments/prime_canonical_agent_benchmark_v1/run_development_baselines.py new file mode 100644 index 0000000..40f8cc2 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/run_development_baselines.py @@ -0,0 +1,72 @@ +"""Run and freeze development-only fixed baseline selection. + +This script MUST NOT run evaluation seeds. +""" + +import json + +from .manifest import DEVELOPMENT_SEEDS +from .provenance import contract_sha256, implementation_sha256 +from .runner import run_fixed_condition + +CONDITIONS = ("FIXED-H1", "FIXED-H2", "FIXED-H4") + + +def main() -> None: + rows = [] + + for condition in CONDITIONS: + metrics = [] + + for seed in DEVELOPMENT_SEEDS: + result = run_fixed_condition(seed, condition) + metrics.append(result.payload["primary_aulc_ppm"]) + + rows.append( + { + "condition": condition, + "mean_primary_aulc_ppm": sum(metrics) // len(metrics), + } + ) + + best_score = max(row["mean_primary_aulc_ppm"] for row in rows) + + winners = [ + row + for row in rows + if row["mean_primary_aulc_ppm"] == best_score + ] + + depth_order = { + "FIXED-H1": 1, + "FIXED-H2": 2, + "FIXED-H4": 4, + } + + selected = min( + winners, + key=lambda row: depth_order[row["condition"]], + )["condition"] + + report = { + "contract_sha256": contract_sha256(), + "development_seeds": list(DEVELOPMENT_SEEDS), + "implementation_sha256": implementation_sha256(), + "selection_rule": ( + "highest mean primary_aulc_ppm; ties select smaller depth" + ), + "rows": rows, + "selected_fixed_baseline": selected, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1/runner.py b/experiments/prime_canonical_agent_benchmark_v1/runner.py new file mode 100644 index 0000000..1c522ff --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/runner.py @@ -0,0 +1,133 @@ +"""Deterministic runner for the initial baseline apparatus.""" + +from dataclasses import dataclass +import hashlib +import json + +from .baselines import HistoryRepresentation, depth_for_condition +from .deterministic import splitmix64 +from .environment import MemoryAliasPOMDP +from .learner import BinaryTabularLearner +from .manifest import ( + BENCHMARK_VERSION, + DECISION_STEPS_PER_EPISODE, + EPISODES, + FINAL_WINDOW_EPISODES, + PPM, + WARMUP_STEPS, +) +from .provenance import ( + contract_sha256, + implementation_sha256, + source_commit, + source_dirty, +) + + +@dataclass(frozen=True) +class BaselineResult: + payload: dict + + def canonical_bytes(self) -> bytes: + return ( + json.dumps( + self.payload, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + def sha256(self) -> str: + return hashlib.sha256(self.canonical_bytes()).hexdigest() + + +def _primary_aulc_ppm(episode_rewards: list[int]) -> int: + cumulative = 0 + curve_sum = 0 + + for index, reward in enumerate(episode_rewards, start=1): + cumulative += reward + denominator = index * DECISION_STEPS_PER_EPISODE + curve_sum += (PPM * cumulative) // denominator + + return curve_sum // len(episode_rewards) + + +def _final_window_ppm(episode_rewards: list[int]) -> int: + window = episode_rewards[-FINAL_WINDOW_EPISODES:] + successes = sum(window) + trials = len(window) * DECISION_STEPS_PER_EPISODE + return (PPM * successes) // trials + + +def run_fixed_condition(world_seed: int, condition: str) -> BaselineResult: + depth = depth_for_condition(condition) + + env = MemoryAliasPOMDP(world_seed) + representation = HistoryRepresentation(depth=depth) + + learner_seed = splitmix64(world_seed ^ 0x8EBC6AF09C88C6E3) + learner = BinaryTabularLearner(seed=learner_seed) + + episode_rewards: list[int] = [] + + for episode in range(EPISODES): + representation.reset() + observation = env.reset(episode) + + scored_reward = 0 + total_steps = WARMUP_STEPS + DECISION_STEPS_PER_EPISODE + + for step_index in range(total_steps): + state = representation.observe(observation) + action = learner.choose(state) + result = env.step(action) + + if result.scored: + learner.update(state, action, result.reward) + scored_reward += result.reward + + expected_done = step_index == total_steps - 1 + + if result.done != expected_done: + raise RuntimeError("environment termination integrity failure") + + if not result.done: + if result.next_observation not in (0, 1): + raise RuntimeError("invalid next observation") + observation = result.next_observation + elif result.next_observation is not None: + raise RuntimeError("terminal step exposed next observation") + + episode_rewards.append(scored_reward) + + total_reward = sum(episode_rewards) + total_trials = EPISODES * DECISION_STEPS_PER_EPISODE + + payload = { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "representation_depth": depth, + "episodes": EPISODES, + "decision_steps_per_episode": DECISION_STEPS_PER_EPISODE, + "warmup_steps": WARMUP_STEPS, + "episode_rewards": episode_rewards, + "primary_aulc_ppm": _primary_aulc_ppm(episode_rewards), + "final_window_reward_ppm": _final_window_ppm(episode_rewards), + "total_reward": total_reward, + "cumulative_regret": total_trials - total_reward, + "proposed_repairs": 0, + "accepted_repairs": 0, + "rejected_repairs": 0, + "integrity_failures": 0, + "contract_sha256": contract_sha256(), + "implementation_sha256": implementation_sha256(), + "source_commit": source_commit(), + "source_dirty": source_dirty(), + } + + return BaselineResult(payload=payload) diff --git a/experiments/prime_canonical_agent_benchmark_v1/test_apparatus.py b/experiments/prime_canonical_agent_benchmark_v1/test_apparatus.py new file mode 100644 index 0000000..f363569 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1/test_apparatus.py @@ -0,0 +1,111 @@ +"""Dependency-free correctness tests for benchmark apparatus. + +These tests use development seeds only. +""" + +import json +import unittest + +from .baselines import HistoryRepresentation +from .environment import MemoryAliasPOMDP +from .runner import run_fixed_condition + + +class EnvironmentTests(unittest.TestCase): + def test_environment_is_deterministic(self): + actions = [0, 1] * 40 + + def trace(): + env = MemoryAliasPOMDP(7) + observation = env.reset(3) + out = [] + + for action in actions[:68]: + r = env.step(action) + out.append( + ( + observation, + r.reward, + r.scored, + r.done, + r.next_observation, + ) + ) + + if not r.done: + observation = r.next_observation + + return out + + self.assertEqual(trace(), trace()) + + def test_all_worlds_have_same_warmup_length(self): + for seed in range(8): + env = MemoryAliasPOMDP(seed) + env.reset(0) + scored = [] + for _ in range(8): + scored.append(env.step(0).scored) + self.assertEqual( + scored, + [False, False, False, False, True, True, True, True], + ) + + +class RepresentationTests(unittest.TestCase): + def test_depth_zero_is_current_observation_only(self): + rep = HistoryRepresentation(depth=0) + self.assertEqual(rep.observe(1), (1,)) + self.assertEqual(rep.observe(0), (0,)) + self.assertEqual(rep.observe(1), (1,)) + + def test_depth_four_tracks_five_symbols(self): + rep = HistoryRepresentation(depth=4) + for bit in (1, 0, 1, 1, 0): + state = rep.observe(bit) + self.assertEqual(state, (1, 0, 1, 1, 0)) + + +class RunnerTests(unittest.TestCase): + def test_result_is_byte_reproducible(self): + first = run_fixed_condition(3, "FIXED-H2") + second = run_fixed_condition(3, "FIXED-H2") + + self.assertEqual(first.canonical_bytes(), second.canonical_bytes()) + self.assertEqual(first.sha256(), second.sha256()) + + def test_result_contains_no_native_floats(self): + result = run_fixed_condition(4, "REACTIVE").payload + + def walk(value): + self.assertNotIsInstance(value, float) + if isinstance(value, dict): + for k, v in value.items(): + self.assertIsInstance(k, str) + walk(v) + elif isinstance(value, list): + for item in value: + walk(item) + + walk(result) + + def test_canonical_json_round_trip(self): + result = run_fixed_condition(5, "FIXED-H1") + decoded = json.loads(result.canonical_bytes()) + self.assertEqual(decoded, result.payload) + + def test_fixed_conditions_have_zero_repairs(self): + for condition in ( + "REACTIVE", + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", + ): + payload = run_fixed_condition(6, condition).payload + self.assertEqual(payload["proposed_repairs"], 0) + self.assertEqual(payload["accepted_repairs"], 0) + self.assertEqual(payload["rejected_repairs"], 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/ADAPTIVE_RULES.md b/experiments/prime_canonical_agent_benchmark_v1_1/ADAPTIVE_RULES.md new file mode 100644 index 0000000..fc6260b --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/ADAPTIVE_RULES.md @@ -0,0 +1,405 @@ +# PRIME Canonical Agent Benchmark v1.1 +## Frozen Adaptive Repair Rules + +Status: FROZEN BEFORE ADAPTIVE IMPLEMENTATION OR ADAPTIVE DEVELOPMENT RESULTS + +These rules specify the hypothesis-bearing adaptive mechanism. + +They may not be tuned in response to development or evaluation performance. +An implementation defect may be corrected, but any substantive rule change +requires a new benchmark version and explicit lineage. + +--- + +# 1. Initial representation + +The adaptive conditions begin at representation depth: + + H0 + +Permitted depths are: + + H0, H1, H2, H4 + +where Hd contains the current binary observation and the preceding d binary +observations. + +Representation growth is monotone. + +--- + +# 2. Current-representation evidence + +The policy may retain only the state exposed by its currently authorized +representation. + +For each scored decision it may retain: + +- current authorized representation state; +- chosen binary action; +- received binary reward; +- inferred correct binary action. + +Because the action space is binary and reward is exactly 1 for the correct +action and 0 otherwise, the historical correct action is inferable as: + + target = action if reward == 1 + target = 1 - action if reward == 0 + +No latent environment state or hidden dependency depth is exposed. + +--- + +# 3. Obstruction definition + +A representation obstruction exists when one currently represented state has +repeated, contradictory verified target actions. + +For each current representation state s, count: + + N(s, 0) + N(s, 1) + +An obstruction is declared when there exists s such that: + + N(s, 0) >= 8 + and + N(s, 1) >= 8 + +Only evidence gathered since the most recent authorized representation change +is used for this obstruction test. + +This is a structural aliasing test. + +It does not inspect reward averages from frozen evaluation worlds and does not +know the hidden environment depth. + +--- + +# 4. Proposal rule + +When an obstruction is first declared, the proposal mechanism nominates every +strictly deeper permitted representation. + +Examples: + + H0 -> {H1, H2, H4} + H1 -> {H2, H4} + H2 -> {H4} + +The proposal mechanism: + +- cannot authorize a repair; +- cannot access hidden environment depth; +- cannot rank candidates using frozen evaluation outcomes. + +Candidate order is always increasing representation depth. + +--- + +# 5. Prospective shadow probe + +FULL-PRIME does not retain deeper historical representations before a proposal. + +After a proposal, the independent verifier opens a prospective shadow probe +beginning at the next complete episode. + +Probe duration: + + 4 complete episodes + +Each candidate representation is instantiated independently for the probe. + +Candidate shadow representations receive the same newly arriving public binary +observations as the policy, but: + +- they do not choose actions; +- they cannot influence policy; +- they cannot mutate canonical representation state; +- they cannot access hidden depth. + +The currently authorized representation is shadow-scored over the same probe +events. + +The probe therefore compares representations on common prospective evidence +without granting candidate representations policy authority. + +--- + +# 6. Probe target reconstruction + +For every scored probe event, the verifier records: + +- state under current representation; +- state under each candidate representation; +- inferred historical correct binary action. + +The correct action is inferred only from the policy's public action/reward +feedback using the binary complement rule specified above. + +--- + +# 7. Train/validation split + +Probe events are indexed from zero in deterministic observation order. + +Training events: + + even indices + +Validation events: + + odd indices + +No random split is used. + +Each representation learns a deterministic state-to-target predictor on the +training half. + +For each represented state: + +- predict target 0 when count(0) > count(1); +- predict target 1 when count(1) > count(0); +- ties predict 0. + +Previously unseen validation states also predict 0. + +This predictor is verifier-only and never controls the benchmark agent. + +--- + +# 8. Paired candidate comparison + +For every validation event compare: + + prediction(current) + prediction(candidate) + true inferred target + +Count: + + wins = candidate correct, current wrong + losses = current correct, candidate wrong + +Events on which both agree in correctness are not discordant. + +Let: + + m = wins + losses + +A candidate must satisfy BOTH the statistical evidence rule and the explicit +representation complexity rule. + +--- + +# 9. Statistical evidence rule + +Use an exact one-sided paired sign test. + +Under the null hypothesis that neither representation is better on discordant +events: + + W ~ Binomial(m, 1/2) + +The exact upper-tail probability is represented without floating point as: + + numerator = + sum(comb(m, k) for k in range(wins, m + 1)) + + denominator = + 2 ** m + +The frozen significance requirement is: + + 64 * numerator <= denominator + +equivalent to: + + p <= 1/64 + +No asymptotic approximation or floating-point p-value is used. + +If m == 0, the candidate fails. + +--- + +# 10. Explicit representation complexity cost + +The representation complexity of Hd is its maximum number of binary states: + + C(d) = 2 ** (d + 1) + +For current depth c and candidate depth d, define: + + complexity_cost = C(d) - C(c) + +The candidate must additionally satisfy: + + wins - losses > complexity_cost + +Thus a larger representation must supply correspondingly stronger paired +decision evidence. + +This cost is frozen before observing adaptive results. + +--- + +# 11. Authorization rule + +FULL-PRIME independently evaluates every proposed candidate. + +A candidate is verifier-supported only when: + +1. its exact paired sign test passes; +2. its net paired advantage exceeds its explicit complexity cost. + +If no candidate passes: + + reject proposal + canonical depth unchanged + +If one or more candidates pass: + + authorize the smallest passing depth + +At most one representation repair is authorized per repair event. + +After authorization: + +- canonical representation depth changes; +- policy continues learning under the new representation; +- obstruction evidence is cleared; +- unused candidate shadows are discarded; +- a canonical hash-chained repair receipt is created. + +Rejected proposals have zero canonical representation effect. + +--- + +# 12. ADAPTIVE-NO-VERIFIER ablation + +This condition uses the identical obstruction detector and proposal candidate +set. + +It does NOT run the independent verifier authorization rule. + +On obstruction it immediately accepts: + + the smallest proposed deeper representation + +Thus it climbs the representation ladder one obstruction at a time. + +This deliberately tests whether independent verifier selection provides value +beyond ungated adaptive growth. + +Every ungated repair remains recorded. + +--- + +# 13. VERIFIER-NO-REPAIR ablation + +This condition uses: + +- the identical obstruction detector; +- the identical proposal rule; +- the identical prospective shadow probe; +- the identical verifier scoring rule. + +However representation mutation is disabled. + +Even a verifier-supported candidate produces: + + canonical representation effect = zero + +The policy therefore remains at H0. + +Verifier decisions remain recorded. + +--- + +# 14. Repair limits + +Maximum accepted representation repairs per run: + + 3 + +No representation may shrink in v1.1. + +No repair may exceed H4. + +--- + +# 15. Receipt chain + +Every proposal resolution generates a deterministic canonical receipt containing +at least: + +- benchmark version; +- condition; +- world seed; +- receipt sequence; +- previous receipt hash; +- obstruction episode; +- current representation depth; +- candidate depths; +- verifier evidence summary; +- complexity costs; +- supported candidates; +- authorized depth or null; +- canonical depth before; +- canonical depth after. + +Canonical receipt JSON: + +- sorted keys; +- compact separators; +- UTF-8; +- trailing newline; +- no native floats; +- no timestamps; +- no UUIDs. + +Receipt hash: + + SHA-256(canonical receipt bytes) + +Each receipt commits to the previous receipt hash. + +Tampering must cause chain verification failure. + +--- + +# 16. Development restriction + +Adaptive development runs may use only seeds: + + 0 through 31 inclusive + +The rules in this file may NOT be changed because adaptive development +performance is poor. + +Development may be used only to: + +- find implementation bugs; +- verify invariants; +- verify determinism; +- verify that the implementation matches these frozen rules. + +--- + +# 17. Evaluation restriction + +Seeds: + + 1000 through 1127 inclusive + +remain untouched until: + +- adaptive implementation is complete; +- adaptive tests pass; +- receipt tamper tests pass; +- development invariant tests pass; +- implementation source is committed; +- the worktree is clean; +- the implementation manifest is frozen. + diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/ADAPTIVE_RULES.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/ADAPTIVE_RULES.sha256 new file mode 100644 index 0000000..3769c33 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/ADAPTIVE_RULES.sha256 @@ -0,0 +1 @@ +41c026c7a81dc1e7e3d7bce4cd55ca2d5159e19705272b775aed8f2cbafdcacc ADAPTIVE_RULES.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json b/experiments/prime_canonical_agent_benchmark_v1_1/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json new file mode 100644 index 0000000..695b515 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json @@ -0,0 +1,1860 @@ +{ + "by_hidden_depth_diagnostic": [ + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_depth_counts": { + "0": 8 + }, + "mean_final_window_reward_ppm": 950439, + "mean_primary_aulc_ppm": 948283, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_depth_counts": { + "0": 8 + }, + "mean_final_window_reward_ppm": 950439, + "mean_primary_aulc_ppm": 948283, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_depth_counts": { + "0": 8 + }, + "mean_final_window_reward_ppm": 950439, + "mean_primary_aulc_ppm": 948283, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_depth_counts": { + "1": 8 + }, + "mean_final_window_reward_ppm": 945067, + "mean_primary_aulc_ppm": 931407, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_depth_counts": { + "0": 8 + }, + "mean_final_window_reward_ppm": 509032, + "mean_primary_aulc_ppm": 499660, + "rejected_repairs": 0, + "verifier_supported_repairs": 8, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_depth_counts": { + "1": 8 + }, + "mean_final_window_reward_ppm": 945067, + "mean_primary_aulc_ppm": 823052, + "rejected_repairs": 0, + "verifier_supported_repairs": 8, + "world_count": 8 + }, + { + "accepted_repairs": 16, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_depth_counts": { + "2": 8 + }, + "mean_final_window_reward_ppm": 953857, + "mean_primary_aulc_ppm": 898704, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_depth_counts": { + "0": 8 + }, + "mean_final_window_reward_ppm": 503173, + "mean_primary_aulc_ppm": 506819, + "rejected_repairs": 0, + "verifier_supported_repairs": 8, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_depth_counts": { + "2": 8 + }, + "mean_final_window_reward_ppm": 953857, + "mean_primary_aulc_ppm": 827187, + "rejected_repairs": 0, + "verifier_supported_repairs": 8, + "world_count": 8 + }, + { + "accepted_repairs": 24, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_depth_counts": { + "4": 8 + }, + "mean_final_window_reward_ppm": 951415, + "mean_primary_aulc_ppm": 848638, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_depth_counts": { + "0": 8 + }, + "mean_final_window_reward_ppm": 503905, + "mean_primary_aulc_ppm": 499279, + "rejected_repairs": 0, + "verifier_supported_repairs": 8, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_depth_counts": { + "4": 8 + }, + "mean_final_window_reward_ppm": 951415, + "mean_primary_aulc_ppm": 809745, + "rejected_repairs": 0, + "verifier_supported_repairs": 8, + "world_count": 8 + } + ], + "condition_summaries": [ + { + "all_receipt_chains_valid": true, + "condition": "ADAPTIVE-NO-VERIFIER", + "mean_final_window_reward_ppm": 950194, + "mean_primary_aulc_ppm": 906758, + "total_accepted_repairs": 48, + "total_proposed_repairs": 48, + "total_rejected_repairs": 0 + }, + { + "all_receipt_chains_valid": true, + "condition": "VERIFIER-NO-REPAIR", + "mean_final_window_reward_ppm": 616637, + "mean_primary_aulc_ppm": 613510, + "total_accepted_repairs": 0, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0 + }, + { + "all_receipt_chains_valid": true, + "condition": "FULL-PRIME", + "mean_final_window_reward_ppm": 950194, + "mean_primary_aulc_ppm": 852067, + "total_accepted_repairs": 24, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0 + } + ], + "development_seed_count": 32, + "evaluation_seeds_run": false, + "fixed_h4_mean_primary_aulc_ppm": 918812, + "frozen_identities": { + "v1_1_adaptive_rules_sha256": "41c026c7a81dc1e7e3d7bce4cd55ca2d5159e19705272b775aed8f2cbafdcacc", + "v1_1_contract_sha256": "5d950c719cb374a4ca835164c7747a18aba84dcffb1082253b916630322a7773", + "v1_1_lineage_sha256": "9b1516271cf7a8873996239dff84aee579a09d86e828cd2b33659a04f073340f", + "v1_contract_sha256": "91681a38971cf85eb3315a5b56ab9fd7064c65f1a4c2575ab390eba8be372a48", + "v1_development_selection_sha256": "a3c9b203d3c9882bea6644d64a8cf509c6254576f680fe15dc0b19fe536c6f19", + "v1_retirement_sha256": "2f142e51e1dd8d7d63091e5b3aaf085e7603f3243baba04f3180d868464d134e" + }, + "implementation_sha256": "b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f", + "rows": [ + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916834, + "primary_aulc_ppm": 944749, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 0 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916834, + "primary_aulc_ppm": 944749, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 0 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916834, + "primary_aulc_ppm": 944749, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 0 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 920777, + "primary_aulc_ppm": 937477, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 1 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 523437, + "fixed_h4_primary_aulc_ppm": 920777, + "primary_aulc_ppm": 499562, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 1 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 920777, + "primary_aulc_ppm": 823730, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 1 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 923361, + "primary_aulc_ppm": 908004, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 2 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 509765, + "fixed_h4_primary_aulc_ppm": 923361, + "primary_aulc_ppm": 498556, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 2 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 923361, + "primary_aulc_ppm": 833655, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 2 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "fixed_h4_primary_aulc_ppm": 919595, + "primary_aulc_ppm": 855828, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 2 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 3 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 492187, + "fixed_h4_primary_aulc_ppm": 919595, + "primary_aulc_ppm": 507223, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 3 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "fixed_h4_primary_aulc_ppm": 919595, + "primary_aulc_ppm": 816185, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 3 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 917024, + "primary_aulc_ppm": 949322, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 4 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 917024, + "primary_aulc_ppm": 949322, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 4 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 917024, + "primary_aulc_ppm": 949322, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 4 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 917495, + "primary_aulc_ppm": 931024, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 5 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 513671, + "fixed_h4_primary_aulc_ppm": 917495, + "primary_aulc_ppm": 496407, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 5 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 917495, + "primary_aulc_ppm": 821401, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 5 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 920350, + "primary_aulc_ppm": 895543, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 6 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 537109, + "fixed_h4_primary_aulc_ppm": 920350, + "primary_aulc_ppm": 522717, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 6 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 920350, + "primary_aulc_ppm": 845284, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 6 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 915244, + "primary_aulc_ppm": 839177, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 3 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 7 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 500000, + "fixed_h4_primary_aulc_ppm": 915244, + "primary_aulc_ppm": 491719, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 7 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 915244, + "primary_aulc_ppm": 798641, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 7 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 922444, + "primary_aulc_ppm": 954301, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 922444, + "primary_aulc_ppm": 954301, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 8 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 922444, + "primary_aulc_ppm": 954301, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 8 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 919497, + "primary_aulc_ppm": 930284, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 9 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 494140, + "fixed_h4_primary_aulc_ppm": 919497, + "primary_aulc_ppm": 492734, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 9 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 919497, + "primary_aulc_ppm": 821703, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 9 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917682, + "primary_aulc_ppm": 896085, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 10 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 496093, + "fixed_h4_primary_aulc_ppm": 917682, + "primary_aulc_ppm": 499187, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 10 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917682, + "primary_aulc_ppm": 821110, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 10 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 964843, + "fixed_h4_primary_aulc_ppm": 921148, + "primary_aulc_ppm": 839951, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 3 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 11 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 521484, + "fixed_h4_primary_aulc_ppm": 921148, + "primary_aulc_ppm": 503822, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 11 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 964843, + "fixed_h4_primary_aulc_ppm": 921148, + "primary_aulc_ppm": 803366, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 11 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917430, + "primary_aulc_ppm": 947417, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 12 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917430, + "primary_aulc_ppm": 947417, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 12 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917430, + "primary_aulc_ppm": 947417, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 12 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 935546, + "fixed_h4_primary_aulc_ppm": 926299, + "primary_aulc_ppm": 944501, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 13 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 519531, + "fixed_h4_primary_aulc_ppm": 926299, + "primary_aulc_ppm": 529573, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 13 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 935546, + "fixed_h4_primary_aulc_ppm": 926299, + "primary_aulc_ppm": 845557, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 13 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 915702, + "primary_aulc_ppm": 900467, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 14 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 486328, + "fixed_h4_primary_aulc_ppm": 915702, + "primary_aulc_ppm": 498962, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 14 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 915702, + "primary_aulc_ppm": 823286, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 14 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 920815, + "primary_aulc_ppm": 852154, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 3 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 15 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 511718, + "fixed_h4_primary_aulc_ppm": 920815, + "primary_aulc_ppm": 507244, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 15 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 920815, + "primary_aulc_ppm": 821363, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 15 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916101, + "primary_aulc_ppm": 945966, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 16 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916101, + "primary_aulc_ppm": 945966, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 16 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916101, + "primary_aulc_ppm": 945966, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 16 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 918959, + "primary_aulc_ppm": 928281, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 17 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 511718, + "fixed_h4_primary_aulc_ppm": 918959, + "primary_aulc_ppm": 504527, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 17 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 918959, + "primary_aulc_ppm": 827327, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 17 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 923809, + "primary_aulc_ppm": 896868, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 18 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 531250, + "fixed_h4_primary_aulc_ppm": 923809, + "primary_aulc_ppm": 501413, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 18 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 923809, + "primary_aulc_ppm": 821803, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 18 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916506, + "primary_aulc_ppm": 838276, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 3 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 19 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 494140, + "fixed_h4_primary_aulc_ppm": 916506, + "primary_aulc_ppm": 500458, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 19 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 916506, + "primary_aulc_ppm": 809256, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 19 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 914695, + "primary_aulc_ppm": 943098, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 20 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 914695, + "primary_aulc_ppm": 943098, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 20 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 914695, + "primary_aulc_ppm": 943098, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 20 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 917587, + "primary_aulc_ppm": 932640, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 21 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 494140, + "fixed_h4_primary_aulc_ppm": 917587, + "primary_aulc_ppm": 490731, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 21 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 917587, + "primary_aulc_ppm": 820068, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 21 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 920261, + "primary_aulc_ppm": 890236, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 22 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 474609, + "fixed_h4_primary_aulc_ppm": 920261, + "primary_aulc_ppm": 512884, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 22 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 920261, + "primary_aulc_ppm": 826526, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 22 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 919780, + "primary_aulc_ppm": 847661, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 2 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 23 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 537109, + "fixed_h4_primary_aulc_ppm": 919780, + "primary_aulc_ppm": 495384, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 23 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 919780, + "primary_aulc_ppm": 806009, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 23 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 921200, + "primary_aulc_ppm": 950518, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 24 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 921200, + "primary_aulc_ppm": 950518, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 24 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 921200, + "primary_aulc_ppm": 950518, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 24 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 913963, + "primary_aulc_ppm": 920950, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 25 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 507812, + "fixed_h4_primary_aulc_ppm": 913963, + "primary_aulc_ppm": 486962, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 25 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 913963, + "primary_aulc_ppm": 806794, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 25 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 916068, + "primary_aulc_ppm": 905951, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 26 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 498046, + "fixed_h4_primary_aulc_ppm": 916068, + "primary_aulc_ppm": 502709, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 26 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 916068, + "primary_aulc_ppm": 824587, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 26 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 920142, + "primary_aulc_ppm": 853301, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 2 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 27 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 486328, + "fixed_h4_primary_aulc_ppm": 920142, + "primary_aulc_ppm": 504740, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 27 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 920142, + "primary_aulc_ppm": 816282, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 27 + }, + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 962890, + "fixed_h4_primary_aulc_ppm": 922148, + "primary_aulc_ppm": 950896, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 28 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 962890, + "fixed_h4_primary_aulc_ppm": 922148, + "primary_aulc_ppm": 950896, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 28 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 962890, + "fixed_h4_primary_aulc_ppm": 922148, + "primary_aulc_ppm": 950896, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 28 + }, + { + "accepted_repairs": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 917877, + "primary_aulc_ppm": 926103, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 29 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 0, + "final_window_reward_ppm": 507812, + "fixed_h4_primary_aulc_ppm": 917877, + "primary_aulc_ppm": 496788, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 29 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 917877, + "primary_aulc_ppm": 817842, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 29 + }, + { + "accepted_repairs": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 917019, + "primary_aulc_ppm": 896481, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 30 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 0, + "final_window_reward_ppm": 492187, + "fixed_h4_primary_aulc_ppm": 917019, + "primary_aulc_ppm": 518130, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 30 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 917019, + "primary_aulc_ppm": 821251, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 30 + }, + { + "accepted_repairs": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 914185, + "primary_aulc_ppm": 862763, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 0, + 1, + 2 + ], + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 31 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 0, + "final_window_reward_ppm": 488281, + "fixed_h4_primary_aulc_ppm": 914185, + "primary_aulc_ppm": 483647, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 31 + }, + { + "accepted_repairs": 1, + "condition": "FULL-PRIME", + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 914185, + "primary_aulc_ppm": 806861, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "representation_change_episodes": [ + 5 + ], + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 31 + } + ], + "status": "DEVELOPMENT_ONLY_NOT_EVALUATION" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 new file mode 100644 index 0000000..e8c075e --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 @@ -0,0 +1 @@ +492a6d8c2a0423a44f30726031f96ea5535c32dd6682a79d48322a101d214bd6 DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/EVALUATION_ANALYSIS_PLAN.md b/experiments/prime_canonical_agent_benchmark_v1_1/EVALUATION_ANALYSIS_PLAN.md new file mode 100644 index 0000000..a1811a9 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/EVALUATION_ANALYSIS_PLAN.md @@ -0,0 +1,226 @@ +# PRIME Canonical Agent Benchmark v1.1 +## Frozen Evaluation Analysis Plan + +Status: FROZEN BEFORE ANY EVALUATION SEED IS RUN + +Evaluation seeds: + + 1000 through 1127 inclusive + +Number of paired worlds: + + 128 + +No evaluation result has been inspected before this plan is frozen. + +--- + +# 1. Conditions + +Every evaluation seed is run under all seven frozen conditions: + + REACTIVE + FIXED-H1 + FIXED-H2 + FIXED-H4 + ADAPTIVE-NO-VERIFIER + VERIFIER-NO-REPAIR + FULL-PRIME + +The development-selected fixed comparator remains: + + FIXED-H4 + +This selection may not change after evaluation. + +--- + +# 2. Primary comparison + +For every evaluation seed i define: + + D_i = + primary_AULC(FULL-PRIME, i) + - + primary_AULC(FIXED-H4, i) + +The primary paired mean advantage is: + + mean(D_i) + +Because all runs contain the same number of seeds, inference may operate on +the integer sum of paired deltas without floating-point arithmetic. + +--- + +# 3. Deterministic paired bootstrap + +Number of bootstrap replicates: + + 16384 + +Sample size per replicate: + + 128 paired worlds + +Sampling: + + with replacement + +Bootstrap generator seed: + + 0x5052494D45563131 + +The generator is SplitMix64 using the already frozen benchmark SplitMix64 +implementation. + +For bootstrap replicate r and draw j, the sampled source index is: + + splitmix64( + BOOTSTRAP_SEED + XOR splitmix64(r) + XOR splitmix64(j) + ) mod 128 + +Each bootstrap replicate stores the SUM of its 128 sampled paired deltas. + +The bootstrap sums are sorted in ascending order. + +The frozen 95% percentile interval uses zero-based order-statistic indices: + + lower index = 409 + upper index = 15974 + +The primary confidence requirement is: + + bootstrap_sums[409] > 0 + +No normal approximation, floating-point bootstrap probability, or +post-evaluation choice of interval is permitted. + +--- + +# 4. Primary support rule + +The controlled-benchmark primary claim is supported only if ALL are true: + +1. mean paired primary AULC advantage of FULL-PRIME over FIXED-H4 is positive; +2. the frozen paired-bootstrap 95% lower bound is strictly positive; +3. FULL-PRIME mean final-window reward is not below FIXED-H4 mean + final-window reward; +4. all frozen-input, receipt-chain, source-cleanliness, and deterministic + integrity checks pass. + +For criterion 3, "not materially degraded" is conservatively interpreted as: + + mean_final(FULL-PRIME) + - + mean_final(FIXED-H4) + >= 0 + +No favourable degradation margin is introduced. + +A failure is retained and reported. + +--- + +# 5. Verifier-specific comparison + +Separately define: + + V_i = + primary_AULC(FULL-PRIME, i) + - + primary_AULC(ADAPTIVE-NO-VERIFIER, i) + +The same deterministic paired bootstrap algorithm is applied to V_i. + +A verifier-specific performance contribution is supported only if: + + mean(V_i) > 0 + and + bootstrap lower bound > 0 + +If ADAPTIVE-NO-VERIFIER performs equally or better, that is reported +explicitly. + +This verifier-specific result does not rewrite the primary comparison. + +--- + +# 6. Structural diagnostics + +The following are reported but are not substituted for the primary metric: + +- final representation depth; +- accepted repair count; +- rejected repair count; +- verifier-supported repair count; +- representation-change episodes; +- adaptation latency; +- canonical receipt count; +- receipt-chain validity; +- final-window reward; +- cumulative regret. + +For diagnostic reporting only, worlds may be grouped by their known +environment-generation depth after the run. + +The agent never receives that hidden depth. + +--- + +# 7. Integrity requirements + +Before evaluation begins: + +- Git worktree must be clean. +- Frozen contract hashes must verify. +- Frozen adaptive-rule hash must verify. +- Frozen development diagnostic hash must verify. +- Core implementation hash must equal the development-frozen identity: + + b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f + +Evaluation output is written outside the Git worktree during execution. + +Every adaptive receipt chain must verify. + +Every adaptive result must report: + + source_dirty = false + +The evaluation harness must fail closed if these conditions do not hold. + +--- + +# 8. Evaluation-output policy + +All 128 evaluation worlds are retained. + +No seed may be removed because it is surprising, unfavourable, or anomalous. + +A failed integrity run remains documented. + +The evaluation report must state whether the preregistered primary claim is: + + SUPPORTED + +or: + + NOT SUPPORTED + +No threshold or metric may be changed after inspecting the evaluation. + +--- + +# 9. Claim boundary + +Even a positive result supports only controlled benchmark evidence for +verifier-governed adaptive representation repair. + +It does not establish AGI, universal superiority, optimal POMDP solving, +production security, or broad real-world generality. + +A stronger public performance claim additionally requires a learned-memory +baseline as specified in the frozen experiment contract. diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/EVALUATION_ANALYSIS_PLAN.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/EVALUATION_ANALYSIS_PLAN.sha256 new file mode 100644 index 0000000..f542e33 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/EVALUATION_ANALYSIS_PLAN.sha256 @@ -0,0 +1 @@ +a1d458c1eb06a5a0498971e495ee4e93173c5b3179c7e54ca26f3d9fb86023b3 EVALUATION_ANALYSIS_PLAN.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/EXPERIMENT_CONTRACT.md b/experiments/prime_canonical_agent_benchmark_v1_1/EXPERIMENT_CONTRACT.md new file mode 100644 index 0000000..2faac9c --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/EXPERIMENT_CONTRACT.md @@ -0,0 +1,461 @@ +# PRIME Canonical Agent Benchmark v1.1 +## Frozen Experimental Contract + +Status: FROZEN BEFORE BENCHMARK IMPLEMENTATION OR RESULT INSPECTION + +## Scientific lineage + +v1.1 is a preregistered successor to the retired v1 contract. + +No frozen evaluation seeds were inspected before this successor was defined. + +v1.1 reuses without modification the v1: + +- MemoryAlias-POMDP environment; +- deterministic binary stream generator; +- common tabular learner; +- fixed representations; +- training horizon; +- primary and secondary metrics; +- development seeds; +- frozen evaluation seeds; +- development-only fixed-baseline selection. + +The frozen v1 development-selected baseline remains: + + FIXED-H4 + +The sole substantive experimental-design correction is the candidate repair +transition rule documented below. + +The reason for that correction is preserved in the v1 RETIREMENT.md record. + +--- + +This document defines the first canonical controlled experiment for testing +whether verifier-governed adaptive representation repair provides measurable +decision-making benefit under partial observability. + +The contract must not be edited in response to benchmark outcomes. + +If the design itself later proves defective, the experiment is retired and a +new version is created with explicit lineage. Results from this version are not +silently reinterpreted under a changed contract. + +--- + +# 1. Primary research question + +Does verifier-governed adaptive representation repair improve online learning +under partial observability when the minimum useful memory representation +varies between worlds? + +The tested mechanism is not merely "more memory." + +The tested mechanism is: + + observation/history + -> detect representation obstruction + -> propose bounded representation growth + -> independently verify candidate repair + -> authorize or reject repair + -> continue learning with canonical receipt history + +Proposal is never authority. + +--- + +# 2. Primary claim + +The FULL PRIME condition will be considered supported on this benchmark only if +it achieves better frozen-evaluation learning efficiency than the fixed +representation selected using development worlds, while maintaining competitive +final task performance. + +The benchmark does not presuppose that this claim is true. + +A null or negative result is a valid result. + +--- + +# 3. Explicit non-claims + +This benchmark does NOT by itself establish: + +- general intelligence; +- AGI; +- universal superiority of TS or PRIME; +- superiority over all recurrent neural architectures; +- optimal POMDP solution; +- production security; +- external scientific replication; +- broad real-world generalisation; +- that the sealed PRIME v18 proposal model is semantic authority. + +The first benchmark is a controlled mechanistic test. + +Broader claims require stronger external environments and learned-memory +baselines. + +--- + +# 4. Controlled environment family + +Working environment name: + + MemoryAlias-POMDP + +Each world contains a latent dependency depth: + + d in {0, 1, 2, 4} + +The agent is NOT told d. + +At each decision step the environment exposes only the current binary +observation. + +The correct action depends on information whose required temporal depth is +determined by d. + +Therefore the current observation is insufficient in worlds with d > 0. + +The implementation may retain past observations/actions only through the +representation supplied to that experimental condition. + +No agent may inspect: + +- latent environment state; +- d; +- future observations; +- evaluation labels before acting; +- another condition's internal state. + +Environment randomness must be deterministic from an explicit seed. + +The exact environment transition/reward implementation must be committed before +the first reported benchmark result and thereafter remain frozen for v1. + +--- + +# 5. Representation family + +The initial representation is observation-only. + +Permitted candidate history depths are: + + 0 + 1 + 2 + 4 + +Representation growth is monotone within an experimental run. + +FULL PRIME begins at depth 0. + +When the current representation produces a verified obstruction, the proposal +mechanism may nominate a bounded candidate set containing any strictly deeper +permitted representation. + +The proposal mechanism may not authorize a candidate and may not use frozen +evaluation outcomes to rank candidates. + +The independent verifier evaluates the current representation against the +proposed deeper candidates using bounded evidence. + +At most one representation may be authorized per repair event. + +If multiple candidates satisfy the frozen verifier rule, the smallest +sufficient representation depth must be selected. + +If no candidate satisfies the verifier rule, the proposal is rejected with +zero canonical representation effect. + +The maximum number of accepted representation-growth operations in one run is +three. + +No repair may inject the hidden world parameter d. + +--- + +# 6. Experimental conditions + +At minimum the benchmark must contain: + +A. REACTIVE + Observation-only representation for the entire run. + +B. FIXED-H1 + Fixed history depth 1. + +C. FIXED-H2 + Fixed history depth 2. + +D. FIXED-H4 + Fixed history depth 4. + +E. ADAPTIVE-NO-VERIFIER + Uses the same obstruction/proposal mechanism as FULL PRIME but accepts a + proposed representation expansion without independent verifier authority. + +F. VERIFIER-NO-REPAIR + Runs verifier/evidence machinery but representation growth is disabled. + +G. FULL-PRIME + Obstruction detection, proposal, independent verification, authorization, + canonical repair receipt, and continued learning. + +All conditions must use the same underlying task-learning algorithm wherever +the comparison permits. + +Representation management, not a secretly stronger learner, is the intended +independent variable. + +--- + +# 7. Verifier requirement + +FULL PRIME candidate repair must be evaluated using evidence distinct from the +proposal decision itself. + +The verifier must independently compare the current representation against the +candidate representation on a bounded replay/evidence slice. + +The acceptance rule must include both: + +1. predictive/decision evidence supporting the candidate representation; and +2. an explicit complexity cost for representation growth. + +The proposal component may not directly authorize canonical representation +change. + +Rejected proposals have zero canonical representation effect. + +--- + +# 8. Development/evaluation separation + +Development world seeds: + + 0 through 31 inclusive + +Frozen evaluation world seeds: + + 1000 through 1127 inclusive + +Evaluation seeds are frozen but NOT claimed to be cryptographically blinded +from the implementer. + +Development worlds may be used to: + +- debug implementation; +- set implementation-correctness constants; +- select the fixed-history comparison baseline from H1/H2/H4. + +Frozen evaluation worlds must not be used to choose: + +- thresholds after seeing evaluation performance; +- alternative metrics; +- favourable baseline definitions; +- favourable environment variants; +- favourable seed subsets. + +All 128 frozen evaluation seeds must be reported. + +--- + +# 9. Primary metric + +Primary metric: + + area under the online learning curve + +computed over the preregistered training horizon. + +The exact horizon and normalization must be fixed in code before the first +evaluation-result inspection and recorded in the benchmark manifest. + +Higher is better. + +The metric must use every preregistered evaluation episode. + +No episode deletion is allowed except for a run that fails a predeclared +integrity check, in which case the complete failed run remains recorded. + +--- + +# 10. Secondary metrics + +The benchmark must also report: + +- final-window mean reward; +- cumulative regret against the environment's available optimal action; +- accepted repair count; +- rejected repair count; +- proposed repair count; +- final representation depth; +- representation-change episode indices; +- adaptation latency; +- canonical receipt count; +- integrity failures; +- deterministic run identity. + +Where meaningful, representation complexity must be reported alongside reward. + +--- + +# 11. Baseline selection rule + +The single FIXED representation used for the primary head-to-head comparison is +selected using development worlds only. + +The rule is: + +1. run FIXED-H1, FIXED-H2, and FIXED-H4 on every development seed; +2. select the depth with the highest mean primary metric; +3. ties select the smaller representation. + +After selection, that baseline is frozen for evaluation. + +All fixed baselines must still be reported on evaluation worlds. + +--- + +# 12. Success criterion + +The primary claim is supported only if, on all frozen evaluation worlds: + +1. FULL PRIME has positive paired mean primary-metric difference versus the + development-selected fixed baseline; + +2. a deterministic paired bootstrap 95% confidence interval for that + difference has lower bound greater than zero; + +3. FULL PRIME final-window reward is not materially degraded relative to that + selected fixed baseline; + +4. the improvement is not reproduced equally or better by the + ADAPTIVE-NO-VERIFIER ablation without being explicitly reported; + +5. all integrity and receipt checks pass. + +If condition 1 or 2 fails, the primary advantage claim is unsupported. + +If FULL PRIME loses, that result is retained. + +--- + +# 13. Ablation interpretation + +The benchmark must not report only FULL PRIME versus weak baselines. + +Interpretation requires examining: + +FULL PRIME vs ADAPTIVE-NO-VERIFIER + +to test whether verifier gating contributes useful selectivity; + +FULL PRIME vs VERIFIER-NO-REPAIR + +to test whether representation repair itself contributes useful adaptation; + +FULL PRIME vs fixed representations + +to test whether adaptive representation choice contributes learning efficiency. + +Ablation failures must be discussed rather than hidden. + +--- + +# 14. Determinism and provenance + +Each run must bind at least: + +- benchmark version; +- source commit; +- environment configuration; +- condition; +- world seed; +- learner seed; +- representation parameters; +- verifier parameters; +- result payload; +- receipt chain or equivalent canonical evidence. + +Canonical reports must contain no timestamps, random UUIDs, machine-specific +absolute paths, or scheduler-dependent ordering. + +Repeated execution from the same source/configuration must reproduce identical +canonical result bytes. + +--- + +# 15. Tamper and replay requirements + +Before public interpretation, v1 must test: + +- result tampering; +- receipt tampering; +- representation-repair receipt tampering; +- seed/configuration mismatch; +- replay from an empty benchmark state; +- duplicate result insertion; +- altered environment manifest; +- altered frozen contract. + +Tampered evidence must fail closed. + +--- + +# 16. Public-result gate + +A public claim stronger than: + + "controlled benchmark evidence" + +requires at least one additional learned-memory baseline. + +Candidate later baselines include: + +- recurrent neural agent; +- GRU/LSTM state estimator; +- learned latent-state model. + +Those may require PyTorch and belong to a later benchmark layer if not present +in the dependency-free v1 harness. + +Their absence must be stated clearly. + +--- + +# 17. Architecture constraint + +This benchmark does not create a parallel PRIME. + +It lives in the existing BoggersTheAI / PRIME research lineage. + +Existing PRIME authority boundaries remain authoritative. + +The sealed PRIME v18 archive remains immutable and proposal-only. + +Learned or heuristic machinery may propose. + +Verifier-governed authority decides canonical repair. + +--- + +# 18. Falsification policy + +No mechanism is protected from a negative result. + +If: + +- representation repair does not improve learning; +- verifier gating does not help; +- fixed history wins; +- complexity costs dominate; +- the adaptive condition becomes unstable; + +the result is evidence about the architecture. + +The benchmark exists to reduce uncertainty, not to manufacture a win. + diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/EXPERIMENT_CONTRACT.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/EXPERIMENT_CONTRACT.sha256 new file mode 100644 index 0000000..7f218d8 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/EXPERIMENT_CONTRACT.sha256 @@ -0,0 +1 @@ +5d950c719cb374a4ca835164c7747a18aba84dcffb1082253b916630322a7773 EXPERIMENT_CONTRACT.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/FROZEN_EVALUATION_RESULT.json b/experiments/prime_canonical_agent_benchmark_v1_1/FROZEN_EVALUATION_RESULT.json new file mode 100644 index 0000000..c97bf69 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/FROZEN_EVALUATION_RESULT.json @@ -0,0 +1 @@ +{"benchmark":"prime-canonical-agent-benchmark-v1.1","condition_summaries":{"ADAPTIVE-NO-VERIFIER":{"all_receipt_chains_valid":true,"mean_cumulative_regret":251,"mean_final_window_reward_ppm":949096,"mean_primary_aulc_ppm":905346,"total_accepted_repairs":192,"total_rejected_repairs":0,"world_count":128},"FIXED-H1":{"all_receipt_chains_valid":true,"mean_cumulative_regret":1124,"mean_final_window_reward_ppm":724013,"mean_primary_aulc_ppm":723884,"total_accepted_repairs":0,"total_rejected_repairs":0,"world_count":128},"FIXED-H2":{"all_receipt_chains_valid":true,"mean_cumulative_regret":668,"mean_final_window_reward_ppm":837188,"mean_primary_aulc_ppm":832090,"total_accepted_repairs":0,"total_rejected_repairs":0,"world_count":128},"FIXED-H4":{"all_receipt_chains_valid":true,"mean_cumulative_regret":234,"mean_final_window_reward_ppm":949096,"mean_primary_aulc_ppm":918420,"total_accepted_repairs":0,"total_rejected_repairs":0,"world_count":128},"FULL-PRIME":{"all_receipt_chains_valid":true,"mean_cumulative_regret":322,"mean_final_window_reward_ppm":949096,"mean_primary_aulc_ppm":852920,"total_accepted_repairs":96,"total_rejected_repairs":0,"world_count":128},"REACTIVE":{"all_receipt_chains_valid":true,"mean_cumulative_regret":1586,"mean_final_window_reward_ppm":612060,"mean_primary_aulc_ppm":613189,"total_accepted_repairs":0,"total_rejected_repairs":0,"world_count":128},"VERIFIER-NO-REPAIR":{"all_receipt_chains_valid":true,"mean_cumulative_regret":1586,"mean_final_window_reward_ppm":612060,"mean_primary_aulc_ppm":613189,"total_accepted_repairs":0,"total_rejected_repairs":0,"world_count":128}},"evaluation_seed_count":128,"evaluation_seeds":[1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127],"full_prime_depth_diagnostics":[{"final_depth_counts":{"0":32},"hidden_depth":0,"mean_primary_aulc_ppm":948352,"world_count":32},{"final_depth_counts":{"1":32},"hidden_depth":1,"mean_primary_aulc_ppm":826700,"world_count":32},{"final_depth_counts":{"2":32},"hidden_depth":2,"mean_primary_aulc_ppm":826471,"world_count":32},{"final_depth_counts":{"4":32},"hidden_depth":4,"mean_primary_aulc_ppm":810156,"world_count":32}],"preflight":{"analysis_plan_sha256":"a1d458c1eb06a5a0498971e495ee4e93173c5b3179c7e54ca26f3d9fb86023b3","core_implementation_sha256":"b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f","evaluation_harness_sha256":"f7ca7f3fb90461a211d6f55ff5e48d7b3dc9e578ff6f9261bcd8f42b71cde1a8","frozen_identities":{"v1_1_adaptive_rules_sha256":"41c026c7a81dc1e7e3d7bce4cd55ca2d5159e19705272b775aed8f2cbafdcacc","v1_1_contract_sha256":"5d950c719cb374a4ca835164c7747a18aba84dcffb1082253b916630322a7773","v1_1_lineage_sha256":"9b1516271cf7a8873996239dff84aee579a09d86e828cd2b33659a04f073340f","v1_contract_sha256":"91681a38971cf85eb3315a5b56ab9fd7064c65f1a4c2575ab390eba8be372a48","v1_development_selection_sha256":"a3c9b203d3c9882bea6644d64a8cf509c6254576f680fe15dc0b19fe536c6f19","v1_retirement_sha256":"2f142e51e1dd8d7d63091e5b3aaf085e7603f3243baba04f3180d868464d134e"},"source_commit":"8d2f03495bead25bedb31c6008e46d1ebb22b8ee"},"primary_comparison_full_vs_fixed_h4":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":-74816,"lower_sum_delta":-9576385,"observed_mean_delta_ppm":-65501,"observed_sum_delta":-8384081,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":-55695,"upper_sum_delta":-7128885},"bootstrap_lower_positive":false,"claim":"NOT SUPPORTED","final_not_degraded":true,"integrity_pass":true,"mean_delta_positive":false,"mean_final_delta_ppm":0},"rows":[{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":193,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1000:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951954,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":195,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1000:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":949637,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":198,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1000:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":946163,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":218,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1000:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":925318,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":193,"deterministic_run_identity":"654add4bcaee305cd616e9b843da3618396c1d22f976d18280e9b7dcc8bf5d9d","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951954,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":193,"deterministic_run_identity":"ace4e0d02f59eeb4040c2341226937f971f20c40d38cb43ae0f722a0ed8ce960","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951954,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":193,"deterministic_run_identity":"f6f8478dcec8412909c5854841f5152391aa1fe1fe0a6d1ff290286c192e83c5","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951954,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1000},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2059,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1001:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":496649,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1001},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":212,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1001:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":945105,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1001},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1001:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":941630,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1001},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1001:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":918348,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1001},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":229,"deterministic_run_identity":"28ecc150227f7e0efb7a448cfbbdd6e46c99ae8633a14012b263d22525e59d9e","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":925416,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1001},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2059,"deterministic_run_identity":"9644e2dc3350e2470c65f20166d1ddc2b32f9030f0997e6d219388a87fc93dc2","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":496649,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1001},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":352,"deterministic_run_identity":"c05fc264d24c00fe9adc146aa22813d4003476a5f0c8fdc573d62f2a95bf4b6b","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":826836,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1001},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2051,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1002:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":460937,"primary_aulc_ppm":508186,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1002},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2071,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1002:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":464843,"primary_aulc_ppm":502143,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1002},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1002:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940424,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1002},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1002:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917407,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1002},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"deterministic_run_identity":"e10c98018fe76069d1e77dfd453b3dfb4e8f7e50c5b9204113cf99bd624a4afa","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":898979,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1002},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2051,"deterministic_run_identity":"1bab007c39c2b10c3b44b6c3925ecda5e56b8a22852cfbcbdfbe2115d2eb7c9e","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":460937,"primary_aulc_ppm":508186,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1002},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":347,"deterministic_run_identity":"6954bf416f663f8c5ad704f3404cc2385780c490c4c9a4ab141ec7916add9a68","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":829895,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1002},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2058,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1003:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":492135,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1003},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2014,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1003:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":486328,"primary_aulc_ppm":511291,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1003},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2018,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1003:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":486328,"primary_aulc_ppm":505547,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1003},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1003:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":922672,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1003},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":327,"deterministic_run_identity":"b2ce74511966efb24e3e7c55cd136dac27a3cc8abccffa7d714052f850de3cc7","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":845410,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1003},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2058,"deterministic_run_identity":"cd6a14e771fe876530841242cfc30b6b14705b7e9fa34a2239fe574aeb46ed00","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":492135,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1003},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":385,"deterministic_run_identity":"1e003aabc49cdbb26aca4d2e3ce233def43bbd1e75995f7145231cec38b14f4f","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":807409,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1003},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":197,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1004:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950424,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":199,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1004:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":948107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1004:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":944633,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1004:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":920599,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":197,"deterministic_run_identity":"041beeb75c1be39351e4c07625db02e78f3732829755545d7497921c516cd1d6","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950424,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":197,"deterministic_run_identity":"ecd457c8bef6cf0bedff9b08a317e5066a6a80abb4cfde31a935cafd77ce1e37","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950424,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":197,"deterministic_run_identity":"4c3c60b2ce36f9dddadd944c98458e5849e2483bb50e8e3e8f3538c47660b084","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950424,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1004},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2065,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1005:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":507639,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1005},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1005:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":943116,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1005},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1005:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":938484,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1005},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1005:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917074,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1005},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":229,"deterministic_run_identity":"6720740ea5b0c2b3df5a7da16b04654aacab70b02bdbd57a8d729475784501ea","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926902,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1005},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2065,"deterministic_run_identity":"158c7bb1683018e65a1ba8930ef868783a3034f04305dd38c1c36dc14097edaf","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":507639,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1005},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":347,"deterministic_run_identity":"7ecfe7d846766c22fb1c98f94db441019f042ef0b3849441382de1c74f0e07f1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":831550,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1005},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1006:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":504512,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1006},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2000,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1006:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":514864,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1006},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":194,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1006:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":946371,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1006},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1006:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":923781,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1006},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"deterministic_run_identity":"85646b690f03c98171e4672069490c7d365349a3c339bce2c118a9331719f5b6","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":912058,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1006},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2039,"deterministic_run_identity":"9b43b15cef427f20e1f88c2010030bf0d7a48e96b5cc355dc5ff7c217133c2a3","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":504512,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1006},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":333,"deterministic_run_identity":"3eb7b5fea05ee5a565eca1dee7d940a3ee6fed38b656a3965b7900e6c52b59db","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":831816,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1006},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2005,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1007:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":516913,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1007},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2043,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1007:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":527343,"primary_aulc_ppm":493168,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1007},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":1993,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1007:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":535156,"primary_aulc_ppm":518758,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1007},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1007:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":924661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1007},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":289,"deterministic_run_identity":"5cec20aebc06e5c58b0b0375ed66b9dd5e3a9e75544c513068fcf3993c3759b6","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":859836,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1007},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2005,"deterministic_run_identity":"ab65f06649d86987bec80b5c25bab8ca4f14d640ca773b5a7eb222fb70b8b663","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":516913,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1007},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":359,"deterministic_run_identity":"8be89eff9689585bcd5a037ea0a2ab1660caf59ec01c6ef38da4c7b121d5df7b","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":814033,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1007},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":203,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1008:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1008:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":946834,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1008:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":943359,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1008:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":920261,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":203,"deterministic_run_identity":"34370481fa0f20fd426d6289104aeca9f2bc13d4b1eb3ec5adf85b1cb44762d9","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":203,"deterministic_run_identity":"5a34a9bfb5672ffdfeb5da8e0c68472ade885daae949bfaa9a1664c1f22cfd05","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":203,"deterministic_run_identity":"6c2b5fee86eb13b5ef19c65fe8a6d7c0414c871e38e4368ac6b94be5801fb176","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1008},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2023,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1009:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":508399,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1009},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1009:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":945011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1009},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":212,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1009:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1009},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1009:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916426,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1009},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"deterministic_run_identity":"236893e5fc8fa301cd56e6d2cc56e5d10db102fab17c248892f1aaa7b27e15fb","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":929955,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1009},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2023,"deterministic_run_identity":"40bd372f988f6cd7ff2a5217bffe0c5ed32b81a76dfe42592afcaeb08afca43f","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":508399,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1009},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":340,"deterministic_run_identity":"846a23932446be04454228cefc881676f22cf23c5ea1ffb45af5a8359daa0eb6","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":834808,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1009},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2046,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1010:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":511874,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1010},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2005,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1010:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":490234,"primary_aulc_ppm":518234,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1010},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1010:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":943042,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1010},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1010:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":918176,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1010},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":243,"deterministic_run_identity":"adbce6f7706bb84ad4683e8f84f93dd19f65572c9a1843a7c1d3d113e2b04294","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":908911,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1010},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2046,"deterministic_run_identity":"b1c806f2cd4ccffc33ff93e6a8ea3fd9b54f28bc39525aa50e348c375c51e8f4","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":511874,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1010},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":345,"deterministic_run_identity":"e20b85491243d23e8657c07d8e031645ca5d7def94760943a1cc67ba24f07644","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":837505,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1010},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2064,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1011:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":496772,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1011},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2043,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1011:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":501198,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1011},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2080,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1011:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":511718,"primary_aulc_ppm":488626,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1011},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1011:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":918870,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1011},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":335,"deterministic_run_identity":"b94ebbe8fb7a4d3a0e58473f76a587cdcfb32f95357f793fc2c2a55d012d153b","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":842798,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1011},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2064,"deterministic_run_identity":"1a11b377fe89e822571bf473eeb142b1dddc070e488ea0e7dde89a36e8dfd7a9","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":496772,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1011},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":392,"deterministic_run_identity":"439f2ea723cf35021f196df2700cceedbdfc2af2969cfbee9997940931068e72","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":806095,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1011},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":192,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1012:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":950771,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":194,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1012:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":948454,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":198,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1012:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":943822,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":220,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1012:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921353,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":192,"deterministic_run_identity":"938e5a66b00b8d9a18ef0e3aa71a5cd952a031b5c5458957cbc8b0f205782e59","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":950771,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":192,"deterministic_run_identity":"1a3509f29aefac71f63eacf51e901bcb58328c8f6d8e6189cb578935fc690442","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":950771,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":192,"deterministic_run_identity":"b514ce85c68b744c526ea6518f7f8805b7b0cfaca31890b6680556786f08c50e","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":950771,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1012},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2049,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1013:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":503082,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1013},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1013:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":945251,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1013},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1013:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940618,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1013},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1013:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917091,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1013},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":209,"deterministic_run_identity":"58684431c7bcfc5f33e815a596dbc2a7fffdd97c0310b3e8b6e9d4441ee19b4b","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":934827,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1013},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2049,"deterministic_run_identity":"8bcdef831bc2cd53f8943fb8a4f0db6cf030dafe96e24f0e822699cee32a06df","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":503082,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1013},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":346,"deterministic_run_identity":"e04a6cc50b7cb7d7125d7ec874cff05340bad4b6424c5eb29190f86e84859987","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":827858,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1013},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1993,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1014:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":510269,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1014},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1014:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":482421,"primary_aulc_ppm":495661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1014},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1014:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":945095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1014},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1014:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":920957,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1014},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":250,"deterministic_run_identity":"58185becac1b9ff19f05051da4348c09475f543191930bbbd5903d5358a897da","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":898348,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1014},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1993,"deterministic_run_identity":"ba84cf54da1fd43bbafb1ae5ec860251bf4d2a21fde2d7b78c09dd327eb7d25f","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":510269,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1014},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":346,"deterministic_run_identity":"c7c20ecb2a969ad1958e924c0dbad85a4317cd5d6df3e8ecc522c9decc354ea3","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":830209,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1014},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2063,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1015:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":492914,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1015},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2108,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1015:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":468750,"primary_aulc_ppm":500281,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1015},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2065,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1015:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":472656,"primary_aulc_ppm":502473,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1015},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1015:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":914295,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1015},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":314,"deterministic_run_identity":"fa56365548852255bc2d358f7152f576b763fbc195752f232548a7dee3d70da5","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":848638,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1015},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2063,"deterministic_run_identity":"6b050d90c704f36d535989de5d8a0b0ad4cd4eba4650e67cdb252e2d7009a795","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":492914,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1015},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":385,"deterministic_run_identity":"958dd8aaee5e7d60fa498ded4e08b4b72e424c2a5ff1158bebfd5ed8b01b3342","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":805603,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1015},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":196,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1016:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952066,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":198,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1016:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":949750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":201,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1016:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":946275,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1016:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":921043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":196,"deterministic_run_identity":"7f1e801630cef4bf52b60cc20ecfc30499a1b13d7f94e63f7ca7b7aa927be637","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952066,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":196,"deterministic_run_identity":"74d3a7c120624116f4cd71006a58231c0ab14d21ca1301d3cd8f1b4426f96a0d","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952066,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":196,"deterministic_run_identity":"4e6860edf4911a4a7ab6889d75e42c506d2f99f026d78a6dfde83023bd5770b5","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952066,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1016},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2104,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1017:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":479462,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1017},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1017:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":949943,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1017},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1017:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":946469,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1017},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1017:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":923552,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1017},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":223,"deterministic_run_identity":"dcb01d3da761629eaff3748710a8ab5199981b1b997883f50b68623b5db05e72","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":925621,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1017},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2104,"deterministic_run_identity":"62c7f0b5c267490935a5b9e45d24bf54fd2ed22b12168f220f6cd4ae6e0f1fec","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":479462,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1017},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":350,"deterministic_run_identity":"c4e98fdc7e5990fbaf417364b173a330447a34e70dc91b8549296914b70bb9b8","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":824342,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1017},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2065,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1018:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":503457,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1018},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2066,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1018:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":490234,"primary_aulc_ppm":502503,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1018},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":225,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1018:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939579,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1018},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1018:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":914334,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1018},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":266,"deterministic_run_identity":"6101ea3f91090a0beafadbc16d45758c8544d612395e14ca70b5b1d717b06c6a","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":896000,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1018},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2065,"deterministic_run_identity":"e81c9115b70119795422c8421c327de99a8c5305eba9f6ed05d24bec4b391c56","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":503457,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1018},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":355,"deterministic_run_identity":"34d99b26509c18b4ae40b01b808138651836149bc096994b232c3dcf71804b70","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":832111,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1018},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1986,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1019:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":525390,"primary_aulc_ppm":511387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1019},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1972,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1019:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":548828,"primary_aulc_ppm":505885,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1019},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2015,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1019:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":531250,"primary_aulc_ppm":513433,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1019},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":218,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1019:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":923107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1019},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":302,"deterministic_run_identity":"d23e9a53b705c2b639bf54a7fd7387c9a50e541119d43bbd7b673fc983a68a2e","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":853864,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1019},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1986,"deterministic_run_identity":"6b5b0f68c8dbbf8d66915badfe016c3ab382297fd1d21edbe1747b798cb1c0a0","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":525390,"primary_aulc_ppm":511387,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1019},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":362,"deterministic_run_identity":"5c5055370ac918b16e1512dd640fea115564557a021fe480410e0d1bea29fec2","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":816753,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1019},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":204,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1020:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":951336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":206,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1020:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":949020,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":210,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1020:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":944387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1020:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":918056,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":204,"deterministic_run_identity":"ecd491970d44442c6c194bcdfceafe09a1d873d8b782a0a90f40bba3129dcba5","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":951336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":204,"deterministic_run_identity":"25065b2b301211c1aea8e5f332c32e113e829131a0f138fee157dfff727e993f","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":951336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":204,"deterministic_run_identity":"f76c715c51ac7d56e89cd750ea1bf8fab6703565e758ab7fe8f6f99a9967d0a5","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":951336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1020},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2044,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1021:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":507399,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1021},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":210,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1021:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":945368,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1021},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1021:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":940735,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1021},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1021:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":916133,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1021},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"deterministic_run_identity":"9b8ea71174837d3c79b3fbdb2d0c29ead629bfd32a3b6026a6eed4a36bbdc405","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":932628,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1021},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2044,"deterministic_run_identity":"c0b9d809cb68f6e77d552ed765b371fe2a2a0a9dcfaec02f5c0e75a6ae47ac64","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":507399,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1021},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":346,"deterministic_run_identity":"54c32dcb187dbac3a397167c90cba12a2759dec9f6dbeaa0f01036986d8ad830","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":833339,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1021},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2031,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1022:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":496280,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1022},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2004,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1022:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":527343,"primary_aulc_ppm":510465,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1022},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1022:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":940041,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1022},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1022:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":915560,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1022},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":248,"deterministic_run_identity":"f5e31681eb6e02fed21897fdc733dc81adb91266ddc4ce9977b845dc53910b72","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":898597,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1022},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2031,"deterministic_run_identity":"935cbaa8e9a90bedb6216c4c0c13ad86110e850c39af555c8fe1440519634b83","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":496280,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1022},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":357,"deterministic_run_identity":"625bd4174e94e584a53a9f8f5b37b425418e4b58d46cc28717035c1479b18b09","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":816468,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1022},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2103,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1023:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":486733,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1023},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2076,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1023:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":508025,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1023},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2053,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1023:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":488281,"primary_aulc_ppm":499001,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1023},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1023:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918714,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1023},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":352,"deterministic_run_identity":"694e16b766b99f14b6477be7c3f83c2b57dacf2dc7d7e6eb32ad584e275efc65","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":829986,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1023},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2103,"deterministic_run_identity":"e31183878ae57ad770fc4277105375e9097ea84473e739d4c9eab78b8d954953","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":486733,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1023},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":405,"deterministic_run_identity":"a1d0bddd880a3860bc22c3d672ffce91ce37c46ecaba359e2c1dd25d40e4a4ad","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":796410,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1023},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1024:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":944224,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1024:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":941908,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":220,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1024:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":939591,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":243,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1024:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":915395,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"deterministic_run_identity":"acd8a090519e02efb25a9e538d2c2df61c52f8116b98881c3153bdc69583e2c3","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":944224,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":216,"deterministic_run_identity":"c769931d298ae132f9df408da46598ada5ed42a38ce173b43a7f6cbeec1e9053","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":944224,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":216,"deterministic_run_identity":"88890d639378bcc07153a24b88c4c02075f6971b67abd073ea728f1b23a13179","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":944224,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1024},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2046,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1025:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":491487,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1025},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1025:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":942476,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1025},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":220,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1025:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":937843,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1025},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":243,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1025:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":913728,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1025},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":231,"deterministic_run_identity":"71f525ac44c5232ebaf3fe666e11316d4ae02349d084b75173c8b9d2c8cf7689","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":925103,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1025},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2046,"deterministic_run_identity":"ae37c63a34c2b2c7da15c65545e812001f67c987e0ecdd86cb98ef317d805463","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":491487,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1025},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":370,"deterministic_run_identity":"2b8f33aedb6fda86c2b1ee6f6d62df21a4134d749d5cdc085a8e2ecff50d573d","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":813527,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1025},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2074,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1026:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":494209,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1026},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2091,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1026:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":491159,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1026},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1026:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":941715,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1026},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1026:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":933593,"primary_aulc_ppm":920323,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1026},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":278,"deterministic_run_identity":"318a2aff766974c43d4d63e434f954128bc52423671f37213b0cc8f5b0d25482","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":891008,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1026},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2074,"deterministic_run_identity":"6f9d1dc6ce48cbb2d578adefe9c2e0ce4a91893cabae38b3276cd10ba5b7b681","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":494209,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1026},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":384,"deterministic_run_identity":"ea5394ebe2787bc6df0c0e1c295593b5e92d0ee523883c253ec3b29693db469d","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":816890,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1026},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2013,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1027:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":516576,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1027},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1027:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":453125,"primary_aulc_ppm":508540,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1027},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2013,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1027:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":458984,"primary_aulc_ppm":515632,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1027},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1027:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":920544,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1027},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":317,"deterministic_run_identity":"69bbef3cb90dd0f37cb5973b2a33b915fef3f2c61fbcda4defbabb218bf37237","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":843532,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1027},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2013,"deterministic_run_identity":"fc56be9cebdd4699993fedbd15ce2ec5ce45a50e19e724ced48c8edc9224caf7","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":516576,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1027},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":373,"deterministic_run_identity":"515d9fe29f68ff471cedccbcec325756424954ae689ba8aba728fa88cef72ca4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":812874,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1027},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1028:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":944769,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1028:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":942453,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1028:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":938978,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1028:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916610,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"deterministic_run_identity":"1a2cfc22ee8c1b2b72e2c0c239b7d9fef183d5c493adb055a60be530f93be845","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":944769,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":216,"deterministic_run_identity":"4ada501250c62f0b1e395b3ce63ecc689bfb0c372498dbbefc7891c47301abf6","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":944769,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":216,"deterministic_run_identity":"fd8538ddf1429332ad3a3bf3d8c10e5ff45bf3de3ba3872ae9eed652842f47f6","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":944769,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1028},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2088,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1029:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":500391,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1029},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1029:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":948374,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1029},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":206,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1029:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":943741,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1029},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1029:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":919423,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1029},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":217,"deterministic_run_identity":"955953df89bb09ee83959fad9fdcc14eba73442ef5127e32685d2c1165d3d2ab","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":931001,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1029},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2088,"deterministic_run_identity":"d93459c81ec36148d876fc822c3365b477bf46dd578cf6489b0cf145ae14d528","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":500391,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1029},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":338,"deterministic_run_identity":"f636a7775b9103dc5d5df208b582dcfe6b64e52773aa48cbac5b69e947163290","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":837688,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1029},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2020,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1030:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":539062,"primary_aulc_ppm":502938,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1030},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2027,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1030:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":537109,"primary_aulc_ppm":499422,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1030},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":203,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1030:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":943794,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1030},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1030:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":922340,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1030},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"deterministic_run_identity":"d90421c83e8bdba6169adef733955490727c3955e5ebc4feb4f2e059b14f1a36","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":908201,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1030},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2020,"deterministic_run_identity":"ec2c52b8ab157fc38d4e8c0fcf37591a95780c2cf07b322f95ec7fe38d56db21","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":539062,"primary_aulc_ppm":502938,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1030},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":339,"deterministic_run_identity":"c944f28f78a37e29d50bfec39fbf311c5f9d71dd4cd6db2c8ad359e0a347472d","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":833703,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1030},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2045,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1031:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":494358,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1031},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2033,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1031:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":560546,"primary_aulc_ppm":497822,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1031},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2006,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1031:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":550781,"primary_aulc_ppm":495269,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1031},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1031:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":913216,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1031},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":312,"deterministic_run_identity":"f3dbbdbfcd9a0c6506e44d59561618e3b748cdff9d1ec4ea105aed0dea5ec145","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":858323,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1031},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2045,"deterministic_run_identity":"094b8fad17c267fc7816c9d9bbc28a5d6fa2daac946458a22b97daea9e3ce7c2","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":494358,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1031},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":402,"deterministic_run_identity":"75e6548f2acc99bf84ca30047865870d9d67a7569de743171c1ccc90379f9ef6","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":797618,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1031},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":199,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1032:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":947790,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":201,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1032:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":945474,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1032:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":941999,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1032:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":916216,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":199,"deterministic_run_identity":"4ae1a0cad35655bd20f04fe6310f940681332c207a7edecdac1be4ffc54d6f94","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":947790,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":199,"deterministic_run_identity":"34d519300c8e9743ab556c2c5dce08294722f1542d1d7e879ff704de1e5d105a","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":947790,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":199,"deterministic_run_identity":"88b17e4ea726f97086bd69d2b9fb486dc7e23c982e203b1ddcf0dadec6a5646d","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":947790,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1032},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2064,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1033:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":502634,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1033},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1033:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":944747,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1033},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1033:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":942430,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1033},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1033:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":919636,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1033},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"deterministic_run_identity":"aa1010ee6ad2062007e8036c4633abfae3b180fdedc5a94e60e395ad50b9030a","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":926216,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1033},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2064,"deterministic_run_identity":"b35d429add8f1e0523fb6219b4a3fdf752644b1a6a2867e66b67fc6fca1800ee","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":502634,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1033},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":346,"deterministic_run_identity":"a7cb916d95f2397b7a68b0f135203bb8306f41ba9ad4bcca5d037b02356b30be","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":835097,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1033},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2066,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1034:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":492563,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1034},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1968,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1034:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":550781,"primary_aulc_ppm":514040,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1034},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":198,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1034:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":941640,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1034},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":222,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1034:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":915675,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1034},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":242,"deterministic_run_identity":"c8eecd6dc282602a0457d936f761ab0d76f6bab0242ca59353d859a07c95fe9e","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":895319,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1034},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2066,"deterministic_run_identity":"2f558151a5f370b52672c8671f33deb0ea6bfa92e95c6deed55ca521d1a7d5a6","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":492563,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1034},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":338,"deterministic_run_identity":"5876c3f926ae5861d368ea237d39f6a1b9d7c72551469f94c2d7c3e1f95d21bf","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":827160,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1034},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2034,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1035:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":503749,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1035},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2050,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1035:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":507812,"primary_aulc_ppm":498142,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1035},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2146,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1035:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":464843,"primary_aulc_ppm":476456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1035},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":251,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1035:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":916360,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1035},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":328,"deterministic_run_identity":"19346dc2601b09835b7119cd05aff435f736ab2867bc0060d2ae8f56f65adc51","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":851208,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1035},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2034,"deterministic_run_identity":"360366790621a2a2200e9b4e89b3a4e3c325e4f654be3550db6205a4c8da4478","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":503749,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1035},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":388,"deterministic_run_identity":"041c53777bd3d08111071251cd7d37193362ed068be42997c11fa2a8107f53b2","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":815950,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1035},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1036:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947137,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":207,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1036:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":944821,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1036:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940188,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":233,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1036:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917149,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":205,"deterministic_run_identity":"30dcb2f726c4b7557283132ca6bc80289f0e7bae8dce318162757c104bb98d84","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947137,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":205,"deterministic_run_identity":"8e3b5551d0c79e37a622a5c0a43deeb6ba8cdd5c625855e02f827740c4d01344","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947137,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":205,"deterministic_run_identity":"065a76386c3e92b9adf0cd89f279ad89bc053522cddec8ff72999c25d97ccc8a","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947137,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1036},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2048,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1037:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":492777,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1037},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1037:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":945252,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1037},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1037:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":940619,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1037},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1037:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":919287,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1037},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"deterministic_run_identity":"12c2b49a4ed36e379d94ff4a82e30f3f254bae38434cfe530ee78957ec2a8e55","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":926721,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1037},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2048,"deterministic_run_identity":"53907f6201952417a12c6959cf7f025e92dbcc5588ccf0068cd371c376a9b579","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":492777,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1037},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":360,"deterministic_run_identity":"bf125aff1a785d7f97176266d39aa23881c06d2a18a9f1c821f6e5daaba4c507","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":816174,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1037},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2037,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1038:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":511598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1038},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2010,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1038:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":541015,"primary_aulc_ppm":504434,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1038},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1038:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":944999,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1038},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1038:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":921716,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1038},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":264,"deterministic_run_identity":"f3916f5c29e98fe62a6b836b43a3424f0d5aae63c7387a25c2f09227a3c59fb0","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":897886,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1038},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2037,"deterministic_run_identity":"a6f952545dab6b39b1cfd9279024a6c8fb5023b1b048760df876721d92a8a710","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":511598,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1038},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":354,"deterministic_run_identity":"9f988cdc4d7ac52e795cc54cddd22cf0867af57f7eb54ef8f7fb016e76df4ac8","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":833205,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1038},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2060,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1039:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":496199,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1039},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2037,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1039:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":462890,"primary_aulc_ppm":498021,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1039},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2037,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1039:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":496093,"primary_aulc_ppm":498762,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1039},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1039:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":918117,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1039},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":318,"deterministic_run_identity":"a0ab4cc043c70fb29edde01558fe6b01d2fd9e6aa750ec8eaaabaf55e305293e","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":850517,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1039},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2060,"deterministic_run_identity":"064a5025ca31512bb994693c11724ec9a4342e8ddeff7b2dc3450cef8ff7763c","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":496199,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1039},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":378,"deterministic_run_identity":"8e1998134ab01e11887d3dddb0a80c3fd8d5140f676824a6a9b36d34f1e6dedc","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":809379,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1039},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":201,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1040:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":958984,"primary_aulc_ppm":948025,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":203,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1040:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":958984,"primary_aulc_ppm":945708,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":206,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1040:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":942234,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1040:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":918788,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":201,"deterministic_run_identity":"5c618dbee2cb82215a1ecdfcc7c63818d0fe31ca6b6c07a83d04c07d6087d0e6","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":958984,"primary_aulc_ppm":948025,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":201,"deterministic_run_identity":"d94d175888e10e0623c154d063ceecce1b41bdd87d4a6a7dabd7d01a52d6819a","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":958984,"primary_aulc_ppm":948025,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":201,"deterministic_run_identity":"124ffcbbf932404c6663bcff770a3a4d38b3b6b7c7da25f0c989115533352121","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":958984,"primary_aulc_ppm":948025,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1040},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2082,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1041:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":455078,"primary_aulc_ppm":486937,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1041},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":194,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1041:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":947838,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1041},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":197,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1041:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":944363,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1041},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1041:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":920592,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1041},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":210,"deterministic_run_identity":"8d067fee3bcb1b4c473ade50240bdc62f4d0213921e2b130970b7f600b9a5154","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":929307,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1041},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2082,"deterministic_run_identity":"d30e286d787cba053cbbc9d9a48cd12b74a6c1a6d8bc618c3a0e42891b36a9c5","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":455078,"primary_aulc_ppm":486937,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1041},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":342,"deterministic_run_identity":"c87c5dc7d76185ccf02a7a2b5e9581b385e6e55e84ca8275263eb818c09e0d3a","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":823518,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1041},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2028,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1042:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":512948,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1042},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2076,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1042:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":493917,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1042},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1042:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":940337,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1042},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1042:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":917665,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1042},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":255,"deterministic_run_identity":"95145a63e8c7d0e8cbdc6b10761029cd093fd1f1fe314bb2f88425b24abbbf8e","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":900233,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1042},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2028,"deterministic_run_identity":"06960f77d1deb6fb5592f18aee5a197d13e7108b28fc4d7c4799c55327db1a72","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":512948,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1042},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":344,"deterministic_run_identity":"33fde384ebd1e62ba1ae09f93aa2b2c73c02341dab0df9d0ab12618b18a95f97","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":834627,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1042},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2038,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1043:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":502059,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1043},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2067,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1043:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":496093,"primary_aulc_ppm":495891,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1043},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2077,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1043:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":490234,"primary_aulc_ppm":494679,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1043},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1043:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":918136,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1043},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":322,"deterministic_run_identity":"b367e28e5c04e0d83aaa912253a4b036ae897ef196ae64bec38efdd1492bf6dd","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":843936,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1043},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2038,"deterministic_run_identity":"451bf467656907c5d47e3d06413a1f3888127944c2e6ec869c9fe2d8b0961ee5","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":502059,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1043},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":382,"deterministic_run_identity":"22cd683c06ad98970ca91c84a88effe57da7e68a0902a66534eff84495a83dae","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":807616,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1043},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1044:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946823,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":207,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1044:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":944506,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1044:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":939874,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1044:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":915819,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":205,"deterministic_run_identity":"e60afa6857f09cfc17cf2552423e04ae8a3f5b35428be02b8ef264f93e62e015","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946823,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":205,"deterministic_run_identity":"066bde0a889601160f8b11f646ccfbbaec36e603c5228067411c815bb06722e3","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946823,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":205,"deterministic_run_identity":"5a0223c00cd96922d5cb1b14e90b3e98a8b5b34fef699893382bc64ed77ffd24","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946823,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1044},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2075,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1045:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":489944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1045},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1045:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":949545,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1045},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":206,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1045:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":944912,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1045},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1045:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921142,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1045},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":222,"deterministic_run_identity":"85852e5b6237760bca19b29f4c77f5b5efbee366b708493a0686e0ba203c8bac","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":926382,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1045},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2075,"deterministic_run_identity":"13602066d23d51988750bc14462996adf2e1a8c2570d5f683dbe47cdd72b966d","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":489944,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1045},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":351,"deterministic_run_identity":"82633453641f17f6149aec4314a5a6f7d0dcb8cd9138a82187de5a3773c03717","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":823795,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1045},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2050,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1046:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":500075,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1046},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1991,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1046:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":535156,"primary_aulc_ppm":518544,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1046},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1046:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":941271,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1046},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1046:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":918476,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1046},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"deterministic_run_identity":"a7856333d1405a06e36622e62de8d5341676c67211e6b070ded530530c172483","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":899338,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1046},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2050,"deterministic_run_identity":"837d6cf886934ae5fcfeeff3fcd42321a820e8c613eca8bfa958fb20dfa43dea","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":500075,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1046},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":350,"deterministic_run_identity":"3d0fd9e22646bcc473d254ba4ea1bdd2ccf130c7dc387a33da7dcdc0261a5753","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":827130,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1046},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2067,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1047:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":483115,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1047},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2072,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1047:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":496093,"primary_aulc_ppm":490743,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1047},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2086,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1047:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":480468,"primary_aulc_ppm":496537,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1047},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1047:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":922380,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1047},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":343,"deterministic_run_identity":"9ebad8fe50175183cd16e1cb74f9eea432de0790ca7687b0829a3fcc2e55f35c","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":837728,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1047},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2067,"deterministic_run_identity":"4ce603428c1583dcda92ed6c472446371a9872d442c35bee75c462578ed0d9fe","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":483115,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1047},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":401,"deterministic_run_identity":"8088499c229abeff948842479e4130303d16504baf3089f0f14cf3b21f456978","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":803451,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1047},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":207,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1048:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":951142,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":209,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1048:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":948825,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1048:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":944193,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1048:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":922312,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"deterministic_run_identity":"2969db936ecbc947c03a3cbfa29aa94a9bea34f5809f555f8cf0f731a3dd6ee2","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":951142,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":207,"deterministic_run_identity":"d706b4e4f106879441fd22070467c94d86168df3e5ec243eff07f4ee6ca67a32","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":951142,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":207,"deterministic_run_identity":"948bd3ce14ec45890a38ac13c235df93feb685a24da1d130b56625eabbf27c51","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":951142,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1048},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2050,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1049:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":498718,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1049},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1049:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":937850,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1049},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1049:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":934375,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1049},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":255,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1049:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":908370,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1049},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":245,"deterministic_run_identity":"8e26827b5042f0430f0d231ec49357069bc60bf4d50c93201beae986bc0ea49b","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":918161,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1049},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2050,"deterministic_run_identity":"dafbf3f9c2aa79bbd2371a3f96037d57e428a342807791d71479d115637698e5","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":498718,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1049},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":369,"deterministic_run_identity":"af2179057718ea8a1496b0c81a401913e4460377c8a72f31aeaf8fc3bd038310","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":819209,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1049},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2062,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1050:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":466796,"primary_aulc_ppm":495387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1050},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2046,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1050:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":478515,"primary_aulc_ppm":497472,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1050},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1050:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":936934,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1050},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":248,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1050:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":913285,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1050},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":276,"deterministic_run_identity":"58fce6b6ee78d6322e54916a833246c3a1a29bc6bc9fa9139d568a08ffe27cc0","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":884641,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1050},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2062,"deterministic_run_identity":"8271f3b34b980cd852bd7e1a790e219064b572412e29cd853f99f18491ff677e","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":466796,"primary_aulc_ppm":495387,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1050},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":370,"deterministic_run_identity":"651df6891c7141f8f81e161c49a6c1b6e076e30323c04ceda9022fcb1d502c33","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":819754,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1050},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2082,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1051:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":493633,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1051},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2076,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1051:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":506314,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1051},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2022,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1051:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":515625,"primary_aulc_ppm":512553,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1051},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":247,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1051:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":915909,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1051},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":358,"deterministic_run_identity":"8ad2d5b298725089d84803200211edd2357b4cab5b76eec9b0e025cf1cb19a72","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":828654,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1051},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2082,"deterministic_run_identity":"8c85467e4f8082db7acc0f2e67f1b852099c5f0a0889c3bf90c80bb84902bbde","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":493633,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1051},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":388,"deterministic_run_identity":"96ead88f1393e08a0e35dc11247b5f14ccca746759fdf43cd2c95c75fa40e90d","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":812952,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1051},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":212,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1052:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1052:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":947875,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1052:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":943242,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1052:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":917887,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"deterministic_run_identity":"c54a2e69cd970b02db6f27fb76aa9326d3c6dfd23a07dd177310b36fd4b84f65","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":212,"deterministic_run_identity":"28feef4e938f55df7920d5d682d70da11a77bf325498471a6a5fc0ec71cc6de5","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":212,"deterministic_run_identity":"7c01853c0e4ed409a65d437887ab23441fffa4a69dd44043ecd44c2d32013b89","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1052},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2045,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1053:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":487537,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1053},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":214,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1053:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":946826,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1053},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":218,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1053:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":942194,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1053},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1053:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":919581,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1053},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":224,"deterministic_run_identity":"513c24374cb11fc86a3b6e4b9c164eabeec35bddbda9e1f8baec51956a34b025","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":935244,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1053},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2045,"deterministic_run_identity":"bf47854adf1cf7fd79e3f62fceedaf068dd216f851bc5799d8ceb386733b2c86","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":487537,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1053},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":365,"deterministic_run_identity":"723dd78c730a99545a7ff88dec72a2dae2d6f53a9ca658a2ed4eb36a3fc16a93","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":820355,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1053},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1054:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":502489,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1054},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1996,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1054:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":519173,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1054},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1054:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":941935,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1054},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1054:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":920246,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1054},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"deterministic_run_identity":"411b43fad58973f1059a392e0d1112dfc9cd54da35324d455751774623d150e4","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":899088,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1054},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2039,"deterministic_run_identity":"a1acfece5aab21291cb89da13065559ff6cb29a90df435d1cc65aa36c711b855","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":502489,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1054},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":354,"deterministic_run_identity":"0296336dbf7625e4337249faff785e635113f593240977a5dee326e5a5ae0a6c","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":822080,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1054},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1983,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1055:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":518358,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1055},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1994,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1055:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":503764,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1055},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2028,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1055:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":455078,"primary_aulc_ppm":515635,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1055},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1055:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":917774,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1055},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":330,"deterministic_run_identity":"c95218ce9230d93e135495e1a361ad5bfac526e34f91a61b54c320deba2549bb","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":843021,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1055},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1983,"deterministic_run_identity":"4c165e0ebf3655988e243df8eca8004949bf2d60690fb421737f48c00bbf44a9","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":518358,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1055},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":373,"deterministic_run_identity":"530ac03597910f8afd9fbeec15d44eaeddde6acb2681085ff5ab9bb63604b189","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":818393,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1055},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1056:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944957,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":207,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1056:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":942640,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1056:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":938008,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1056:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":913385,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":205,"deterministic_run_identity":"d64a5c3253bf109f9c6f8a79ad5231ebc793f9453df6f6d84fafd5ae4cb86209","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944957,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":205,"deterministic_run_identity":"df09a6efd81622b2c96d7d6c9bc57356d688e064e1f1b908fad30f7bf5e5551f","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944957,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":205,"deterministic_run_identity":"508f8d55885e5aafb8fa8fd2bd900d2b036108dbcbacfa07147a013783b5ac76","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944957,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1056},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2036,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1057:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":503273,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1057},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1057:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":950321,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1057},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1057:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":945688,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1057},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1057:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":920393,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1057},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":214,"deterministic_run_identity":"470d9271fc203fd970beaaea2450e06daa4d929968fd84e8c1d5d7191fbf4d7b","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":934106,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1057},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2036,"deterministic_run_identity":"a5aaa245da51b7daa36a91475164764cd225fdb67a6d676391bd64f5bd38f241","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":503273,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1057},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":352,"deterministic_run_identity":"66c426084a438db8e68fa3b97ec1e3093f2e92c9f14fdac9b36b7f41523006a7","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":822834,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1057},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2067,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1058:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":451171,"primary_aulc_ppm":500091,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1058},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2046,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1058:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":504431,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1058},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":203,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1058:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":946574,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1058},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1058:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":922033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1058},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":244,"deterministic_run_identity":"5f49cd84180989603111771cfeaab92acacd65528dc6d94875c1541d8d690b3b","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":904216,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1058},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2067,"deterministic_run_identity":"6999644775fe4b916cf22a5f397e730e17503111be77cea81ffbf5040d4a60d0","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":451171,"primary_aulc_ppm":500091,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1058},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":352,"deterministic_run_identity":"cb0285ff5b59f5c3a87ba9d5572588c29da790a9a31dc485949f0a3eaefaa180","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":823265,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1058},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2047,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1059:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":507990,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1059},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2019,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1059:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":512399,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1059},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1059:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":517578,"primary_aulc_ppm":515304,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1059},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1059:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917402,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1059},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":320,"deterministic_run_identity":"46b21546a0053caa0cb302895331b6d964a8ae95774cddea0eeb201dc3518a7e","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":854823,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1059},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2047,"deterministic_run_identity":"a0974820103c05e290ddc80f7e2e32956a24334359ed53995ad643c91100a561","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":507990,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1059},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":378,"deterministic_run_identity":"dcc52d44a1e22c731bcc8964f08f314e510cd6abf7e9cbbf10a38739c62a9b60","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":817322,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1059},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":229,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1060:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":941098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1060:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":938782,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1060:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":934149,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":258,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1060:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":910075,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":229,"deterministic_run_identity":"6b8ce9b983f6a78a958ff80774eab1372a839bf9e42ecffbbdcfbe0882a038ae","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":941098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":229,"deterministic_run_identity":"5461719a3940e9f85745d6356308dbbadf2d1a781a2a84f17739745eea8fa3e7","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":941098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":229,"deterministic_run_identity":"9e1203955e97de9196d18a5ea3560a4bc994a33911ca8e5bd85563456e20851b","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":941098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1060},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2029,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1061:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":503152,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1061},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":197,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1061:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":952184,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1061},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1061:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":948710,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1061},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":224,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1061:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":922501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1061},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"deterministic_run_identity":"ba849b1196d949219a8cf2c51153e88fd7ba54c5db94dc99080af0d13674411f","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":934812,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1061},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2029,"deterministic_run_identity":"6176cc7e404f819de21183d38a03b433c0a181240421982658accdd2aa56b65a","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":503152,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1061},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":332,"deterministic_run_identity":"f6be2e8cdea4a6356121990fbdf8d39d645a636412f57a30df42c6701c4b56ff","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":837664,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1061},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2048,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1062:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":497498,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1062},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2057,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1062:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":486328,"primary_aulc_ppm":492624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1062},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1062:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":935657,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1062},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1062:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":912801,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1062},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":274,"deterministic_run_identity":"d2ff11a550d70ede38fadd53bc886ebd4a16906ad28c20d86264aeb51e495c7a","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":886776,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1062},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2048,"deterministic_run_identity":"c93ece816a7db203b9c9af82a3a66162851ad7b5a0b04576f1be64f8348501f6","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":497498,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1062},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":367,"deterministic_run_identity":"b55b66cdc16dec0578e94952f0146b85f8a31f6a51903178a1b888eb5b22ad8a","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":819548,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1062},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2035,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1063:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":499295,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1063},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2056,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1063:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":500298,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1063},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2068,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1063:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":488281,"primary_aulc_ppm":496741,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1063},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":247,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1063:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":910948,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1063},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":319,"deterministic_run_identity":"9893ade8ce6228c72bd511785b994a39b35681839581bd6834851d72b2f85b8c","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":854000,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1063},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2035,"deterministic_run_identity":"0c65eebf052ed0383234683a739a3eb1f5914cd4e8b6268b5b9adefe2924c3b4","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":499295,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1063},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":388,"deterministic_run_identity":"5a856d7bfe510ef8df5d36bcea2f148b0db5aadb950a8a2637d367b8ef944cf2","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":809391,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1063},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":190,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1064:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":954462,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":191,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1064:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":953304,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":195,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1064:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":948671,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1064:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":925408,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":190,"deterministic_run_identity":"80c8812f0a9d65d48b34a80831e31033ddd91264d67f74fec7348646e53e7513","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":954462,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":190,"deterministic_run_identity":"2149b8360bed640054e9d553b251ec8c05792222f195a0945ea266f27c8880e8","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":954462,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":190,"deterministic_run_identity":"ec3432fddcf4a61c9898734a1656a34a475ca3a44745bff7c5d75078ac1d22b3","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":954462,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1064},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2030,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1065:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":521484,"primary_aulc_ppm":507214,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1065},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1065:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":942598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1065},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1065:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":939123,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1065},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1065:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":916817,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1065},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":230,"deterministic_run_identity":"8f8eb8b6a933f273c38630c7714a45d71c365617e5e034df25ad85989aa4bc90","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926383,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1065},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2030,"deterministic_run_identity":"83aa8443d516dece881596ee9129a839d3b2ee67aa46cb5391f54e1ef18e1a32","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":521484,"primary_aulc_ppm":507214,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1065},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":355,"deterministic_run_identity":"94eb08fb90c882ebf119b799f04f818839f45536ccf5c01475dcb476a43ee292","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":826476,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1065},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1968,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1066:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":542968,"primary_aulc_ppm":517757,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1066},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1976,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1066:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":542968,"primary_aulc_ppm":512141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1066},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1066:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":939964,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1066},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1066:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":915889,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1066},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":260,"deterministic_run_identity":"6ea08d8fede13cc07c17a57feec813fb8e8c05909eb54628ff1a6539e6bd058f","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":895048,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1066},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1968,"deterministic_run_identity":"1d9100c07483b0798b718b2a78bbb67617c4f81cc0d6dae7b82b55b064e4befe","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":542968,"primary_aulc_ppm":517757,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1066},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":354,"deterministic_run_identity":"551f88891711718e1af66e60a0f1c0242dbc3f7e8a27c1c6a831f7b46a7a32fe","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":828603,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1066},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2047,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1067:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":502373,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1067},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2114,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1067:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":517578,"primary_aulc_ppm":475240,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1067},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2003,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1067:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":527343,"primary_aulc_ppm":508696,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1067},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1067:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":922656,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1067},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":314,"deterministic_run_identity":"062b102dd3a29178a268c43611aa7470b642ce1f0dd5f3f384660126cd4e0a38","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":837711,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1067},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2047,"deterministic_run_identity":"ac8912e0966d908004c073b4fee74132b76cbb8b6ff647f8ae2d9b807f623660","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":502373,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1067},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":357,"deterministic_run_identity":"4057e80431da4db2b0ceb443a6dea8157b31de342c919b347fb138ccbeb03fbb","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":814857,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1067},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1068:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":950598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1068:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":948282,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1068:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":943649,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1068:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":922013,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":211,"deterministic_run_identity":"538d90f6c454e704458ba44f7a9d7fae058bb37d77a622fc78cd792b1efdc208","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":950598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":211,"deterministic_run_identity":"ac60a10626235da5715d6e9a84f36425482ebd76cfce42ba982adca6b933765a","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":950598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":211,"deterministic_run_identity":"f10eca5e50e530ca114348f9f0186913d6d120a11a01acd91a4dca1ea84aa2db","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":950598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1068},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2079,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1069:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":470703,"primary_aulc_ppm":491362,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1069},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":192,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1069:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":950877,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1069},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":196,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1069:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":946244,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1069},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1069:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921559,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1069},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":211,"deterministic_run_identity":"947193141af6d499eefe5e11104ff2e6fc808a797e8c228e6fc9ff76dcd1fc47","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":928872,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1069},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2079,"deterministic_run_identity":"ba1380f51b1c7b52a44b3ddfb398c3cb22a57f5008ad43ea6c468c84e2ad1855","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":470703,"primary_aulc_ppm":491362,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1069},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":354,"deterministic_run_identity":"290f4a2dd0233a7f6e67bb97934724c3896b904154e250d36a7c9867f342b7b9","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":815022,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1069},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2002,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1070:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":513164,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1070},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1070:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":521484,"primary_aulc_ppm":507005,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1070},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1070:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":943915,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1070},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":246,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1070:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":919474,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1070},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":271,"deterministic_run_identity":"8bebfbd0b44d15105a9af27b4ff3518c6ab3d158f88041f124a17ae019c6c68d","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":895281,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1070},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2002,"deterministic_run_identity":"092733dfd8e1f4b6360fe969f9c1ee04f67a3be70f47f46a90365d786078026b","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":513164,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1070},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":365,"deterministic_run_identity":"93da4b40b7dd36775bbea515c77a1d8b1401bd383c82c48a632c88727984a856","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":828429,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1070},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2048,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1071:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":515853,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1071},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2111,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1071:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":491163,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1071},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2061,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1071:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":533203,"primary_aulc_ppm":494448,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1071},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1071:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1071},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":327,"deterministic_run_identity":"d0472d9a5690c72a0c84406716d8a0a023f66fba452291b2ae352bb978ff14ed","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":849275,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1071},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2048,"deterministic_run_identity":"28bf0c0e3d1d71491f02fd0e3324fa88b82c8b1db40ddb6226caa29faf9be1d4","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":515853,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1071},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":373,"deterministic_run_identity":"548f492f2cf7516d2e2694b996ef1db83dd1c1971c3ae15c677b4d98d96430fc","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":824290,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1071},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1072:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950166,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1072:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":947849,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1072:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":944375,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1072:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":920015,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":200,"deterministic_run_identity":"faa56e290e8cd1696eb2ce5ccd640f258cb885b15a9e1773971690f24d3ae50e","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950166,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":200,"deterministic_run_identity":"396ff8fa6517362583595d04e1aaa2071fb8d83fdc3087fa96fd33f0300560d4","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950166,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":200,"deterministic_run_identity":"7c4989ec692bd8bd81034006f90d22016caba092db75b23a549d4c0d09af5947","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950166,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1072},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2085,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1073:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":451171,"primary_aulc_ppm":507066,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1073},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1073:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":948088,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1073},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1073:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":943456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1073},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1073:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":922186,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1073},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":222,"deterministic_run_identity":"6c1f7e8e1b1f8ae85fabe2770d5f14375ed37aa40e4172bbd3a98234048030b4","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":935349,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1073},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2085,"deterministic_run_identity":"119595570964808b7dc19d129c724d716c05e883b813d484efab4dc3fd5840b3","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":451171,"primary_aulc_ppm":507066,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1073},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":347,"deterministic_run_identity":"3d44f943a12b0c803ce5ee1db3d3f658b10ff987451cefaa17ff8152d393a5b1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":836060,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1073},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2004,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1074:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":505511,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1074},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2017,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1074:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":544921,"primary_aulc_ppm":502641,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1074},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1074:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":942117,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1074},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1074:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":918610,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1074},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"deterministic_run_identity":"33e96b4b5f0c5b0dad9c1b47ec5d1a5430e2b53613b7ff8d9f993c7b0f3db40b","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":894393,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1074},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2004,"deterministic_run_identity":"7bd686d8e0ea98d749f3ae5f3d1450b3a4bdf156db1d95fa43ce6b6a2dc994dd","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":505511,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1074},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":345,"deterministic_run_identity":"ab60cf28c50a2cfbf17188d60a031b7fb4f6494f3045756fadba7226273c3cb7","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":824920,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1074},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2061,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1075:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":496076,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1075},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2053,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1075:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":507081,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1075},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2062,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1075:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":498046,"primary_aulc_ppm":498011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1075},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1075:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":912458,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1075},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":330,"deterministic_run_identity":"1641da85c63cf3abe94399d32c5186be07ca8ca8c2dd6f5d43310a5bb3ba8060","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":839449,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1075},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2061,"deterministic_run_identity":"d12781681426ae3ee3c88563576622a647cee6cd03586c5c14de35112cbd8d9f","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":496076,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1075},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":384,"deterministic_run_identity":"f1ddd17ae77fa1e8e756905789d2bb8c407f6bd3812bbc87885a71745611d82e","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":809452,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1075},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1076:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944070,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1076:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":941753,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1076:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":937121,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":248,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1076:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":915240,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"deterministic_run_identity":"6029bcc1c5f64d60fe44d6adbac6709c4f7cbe92069c0419beae99d8d13b5045","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944070,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":221,"deterministic_run_identity":"c6310dc159a55b5c0f6511560a451e3eafdcbe6cb9c39b94036ba9e048ccd63e","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944070,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":221,"deterministic_run_identity":"9455013b2d0647a441f9ae5b27fab882201e33332d5442525257682a18bb836e","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944070,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1076},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2060,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1077:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":513671,"primary_aulc_ppm":496468,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1077},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":201,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1077:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":946309,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1077},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1077:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":941676,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1077},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1077:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918707,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1077},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"deterministic_run_identity":"b48ef916af8f2d8c19441f77bfc35a4c1d45e93532d5b21eb150fdac8a472b7b","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":928936,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1077},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2060,"deterministic_run_identity":"b042cf922ea0da5f765c979fafb662223401494369e2af452e822f6e1e8a9b4a","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":513671,"primary_aulc_ppm":496468,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1077},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":338,"deterministic_run_identity":"d1e0d406260db28eadce79c6c22fee2aceedbe7a3fcc6a87ab493fa9940646d6","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":831678,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1077},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2031,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1078:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":504715,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1078},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2084,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1078:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":499961,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1078},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1078:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":939000,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1078},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1078:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":914071,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1078},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":268,"deterministic_run_identity":"6a21d51df5d242ec2eb4168b4dada624da4b7fff4669bd84a5ae2323bd78b0bc","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":895239,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1078},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2031,"deterministic_run_identity":"858139a7a1926ef520b27a681361b4621150d78dbf05435518079726a7e9b045","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":504715,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1078},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":370,"deterministic_run_identity":"0af43021ff407d820d5a3518ca69ae0055c6f2d141e2bd630666e7a02f9931db","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":822308,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1078},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2023,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1079:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":492418,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1079},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2038,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1079:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":541015,"primary_aulc_ppm":479414,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1079},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2009,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1079:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":548828,"primary_aulc_ppm":497063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1079},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1079:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":912035,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1079},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":327,"deterministic_run_identity":"0db13022f23631f7cb2b97a5bb8f01dcc017650aa0d3f286f5acdc8de63819a0","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":841404,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1079},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2023,"deterministic_run_identity":"0bb90812fc045eb53ce4d38cfd84c2915ad916be30bfda268b723318f4080ba4","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":492418,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1079},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":383,"deterministic_run_identity":"f735bf654f90e680be431c09e3e5c4cfdd20a75b694fc03f792d7ec3d3344098","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":804362,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1079},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1080:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":943738,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1080:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":941422,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1080:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":937948,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1080:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":914602,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":211,"deterministic_run_identity":"4f7660348f8f5c3ed4e11a5ba64ff0447c29b6e0d3da7726f50e4c92f8eba410","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":943738,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":211,"deterministic_run_identity":"8e4873c89bd3cea40e3f83db2cc2b02615dc0e6290ffbe44d9df68cda4c7ee88","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":943738,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":211,"deterministic_run_identity":"2e9a1608a30f85b6cda332fcf7c4813c3d154abef7f72afcba113316dfd62b07","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":943738,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1080},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2051,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1081:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":496047,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1081},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":214,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1081:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":942482,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1081},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1081:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":939008,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1081},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1081:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":917372,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1081},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":233,"deterministic_run_identity":"51e4f8446a119e8e69961ca514a6cbe4d8ab3395337fda5f134af4dc722aaea3","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":920477,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1081},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2051,"deterministic_run_identity":"1cf7e97adcc4968772f56efea2d575ad3c62f7b92f82f28413c0742a58eb6da1","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":496047,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1081},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":360,"deterministic_run_identity":"7fb2ecf49e81149acb0471d851bfad826f0a6319e7f393a58522d4c2210a91cf","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":819820,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1081},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2053,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1082:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":495055,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1082},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2019,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1082:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":510425,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1082},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1082:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":944164,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1082},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1082:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":919968,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1082},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":281,"deterministic_run_identity":"4102e89024cf8d031fb98c92e17f86475d38527d24e4305285781d0a42b0b630","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":887911,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1082},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2053,"deterministic_run_identity":"8937d03bf2f794063157c36c8e0036411089dd69586e8399deadd574790fe0c8","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":495055,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1082},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":374,"deterministic_run_identity":"ad4f61af794a84eb6c3dcba6def03e973747ac6bf0fffcb948a95358215f623a","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":822319,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1082},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2052,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1083:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":491535,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1083},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2044,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1083:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":505859,"primary_aulc_ppm":491296,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1083},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2005,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1083:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":507812,"primary_aulc_ppm":500387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1083},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":224,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1083:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":919318,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1083},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":307,"deterministic_run_identity":"dc99b35fd465fbd775703b02fdc7d37fd5b49d30a94300fc52721cb5c13bc837","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":846330,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1083},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2052,"deterministic_run_identity":"d714209172fd2d3536c340ab85ffd82955a0e1eccdf9e30e613f8b84bde8474a","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":491535,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1083},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":389,"deterministic_run_identity":"e2275ba2aa7a5299ff55479876cb4d5d0e12d418014d5921ddfa6e4389fb3d96","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":795043,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1083},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1084:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949083,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1084:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":946767,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1084:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":944451,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1084:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":919482,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":200,"deterministic_run_identity":"bb5d2f2a5a033a2b62ae4afbf15ec76ee56d98975ca85b70004274c7cecc4064","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949083,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":200,"deterministic_run_identity":"07d791ccd58349557925586742a06428449c64f2a2784ab4cefd470364071429","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949083,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":200,"deterministic_run_identity":"5aba9cbb27ee60ab07fc79b3a6fbd6c399375fe0927fc7b37ec0234f5f7387ea","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949083,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1084},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2044,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1085:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":484621,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1085},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":195,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1085:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":947003,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1085},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":199,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1085:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942370,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1085},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":222,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1085:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918540,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1085},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"deterministic_run_identity":"65c7524e41a21e183c6bd270c596c0aef588b3ae2da1f42b43b82578fb8a70b9","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":922682,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1085},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2044,"deterministic_run_identity":"05eee73afacf01fbe46fe4d79c5693b92020b165a0cb60d1769f05c9d1dd5ca2","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":484621,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1085},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":348,"deterministic_run_identity":"4468da43c841d4f229e7536c5cbbd83057ce6a9e3a7fb3b832bee6fb0a10df38","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":819009,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1085},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2059,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1086:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":490049,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1086},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2037,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1086:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":490385,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1086},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1086:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":934432,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1086},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":253,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1086:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":933593,"primary_aulc_ppm":911027,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1086},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":274,"deterministic_run_identity":"9e3ff791bca12d5996a49c4b442f4321898d9593cac51a490169dc69ccf695ce","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":889513,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1086},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2059,"deterministic_run_identity":"719e13d6606e265e61792dff8a37c48b112b6b16a730aaccb220595a00b65612","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":490049,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1086},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":379,"deterministic_run_identity":"b60cb1b17d871c8675d0b950ea1fdc420b6a8afeb420ac359e8f040982d1e0fd","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":813522,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1086},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2002,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1087:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":519235,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1087},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2014,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1087:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":492187,"primary_aulc_ppm":500599,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1087},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2026,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1087:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":546875,"primary_aulc_ppm":490235,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1087},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1087:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921832,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1087},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":323,"deterministic_run_identity":"662c8194cb169af827fe15a9328e6514861d6ea0647fc1b9760661b7eafc4f81","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":843876,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1087},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2002,"deterministic_run_identity":"9c0d30baf764a9508e3cc50c419703ddfd4237917356fcf3841f3e775ae56707","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":519235,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1087},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":370,"deterministic_run_identity":"a247ce507b61c8799aeacf6359a4c75cf59021b398f791f26f87fa5a027548e9","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":813303,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1087},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1088:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946704,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1088:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":944387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1088:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":939755,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":243,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1088:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":915516,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":215,"deterministic_run_identity":"1e87e03b885e15b895f3a6eac3f663126ac2665c092e865264882e0b4cabef3f","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946704,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":215,"deterministic_run_identity":"86e45ce1d3f5583e558fc0d4aaca7062d22e5267ea4c7b3df841355781f48b1c","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946704,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":215,"deterministic_run_identity":"fd6dd22e0f42bcd6b5e50dc1f7fd415ea01a253b26d6a3e5ed549b5aaa0723a9","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946704,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1088},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2058,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1089:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":493933,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1089},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":199,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1089:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":946098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1089},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":202,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1089:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":942624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1089},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1089:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":921069,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1089},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":213,"deterministic_run_identity":"86434554eb5463fb64cad7ee93a75d64fc25ce8777a457320164540a0c30137a","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":929884,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1089},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2058,"deterministic_run_identity":"bcf256300e23ae2b103a6a1c46459cc1fa1169337456fe4fe5eb0d05a0cd5881","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":493933,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1089},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":351,"deterministic_run_identity":"bd5c7282550298250e2a56e81c073ef46699054853aca8551519d62ebf7e4890","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":818997,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1089},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2021,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1090:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":525058,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1090},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1090:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":508297,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1090},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1090:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":938961,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1090},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1090:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":920496,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1090},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":263,"deterministic_run_identity":"60c40591ec999852af36e7dd980932b32cb91e23473e1ebdf705ac495ed7c6b5","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":897520,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1090},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2021,"deterministic_run_identity":"72926c3287553e72dbeb01b44dab5426c16836129d3135e6b71cc7946aab4de0","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":525058,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1090},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":342,"deterministic_run_identity":"95900c9fd54c1bd8ce9eefeed18ba5adcce3724e46434982b5bc5fd2585f8b15","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":842368,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1090},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2048,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1091:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":508862,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1091},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2004,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1091:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":527343,"primary_aulc_ppm":504956,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1091},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2051,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1091:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":486328,"primary_aulc_ppm":505705,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1091},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":230,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1091:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":920393,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1091},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":319,"deterministic_run_identity":"d348bc6fc026843138486aba06130103d565b8188444bd9ce352ba746783b030","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":849623,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1091},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2048,"deterministic_run_identity":"f82234fa6cc971a0e9a80ede598412873074d5b6d6e8f8f0c7f08d3c3f7c955e","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":508862,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1091},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":373,"deterministic_run_identity":"5d51cc7aa03048df8f157ed930d46b2f91fadcf3f9e6b530aa4868cc8d47e25b","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":815174,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1091},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":226,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1092:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":944213,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":228,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1092:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":941896,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":232,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1092:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":937264,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":253,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1092:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":914651,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":226,"deterministic_run_identity":"0efd0618629754fcd4a73b550ef23106db5c9cbae30e02e9ce4d3f3545305529","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":944213,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":226,"deterministic_run_identity":"bace8cb9306d0ccb629bfa6f335e2b4dd3dba907052c81d078e85df9c7736c24","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":944213,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":226,"deterministic_run_identity":"c034414a0549c0ea30eced5f92d6c49b126b2b8aabc9b6f75e4b7dc35200d12d","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":935546,"primary_aulc_ppm":944213,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1092},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2014,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1093:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":521303,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1093},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1093:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":944082,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1093},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1093:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939450,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1093},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1093:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917022,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1093},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":228,"deterministic_run_identity":"3c00e1c730ac499bb23e11fbb0f09550e03835e51ec87097f96ffdfd3f9ba989","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":924394,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1093},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2014,"deterministic_run_identity":"5dcf7f44b36cdd424d39a946a28e6ee0c89ac6f8ab58fb89ca2462881b41a5a6","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":521303,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1093},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":347,"deterministic_run_identity":"db6ca1054ebec205a093eb071b910f14474fedc035d4fd60e8ccbdce2e4224b3","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":832208,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1093},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2071,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1094:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":491102,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1094},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2042,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1094:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":519531,"primary_aulc_ppm":497586,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1094},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1094:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":944592,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1094},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":222,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1094:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":920719,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1094},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":248,"deterministic_run_identity":"6af6a65c58a42104e9a8ba7a16e56f0dd8acb6551a2a23b260609616c5f5286f","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":893882,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1094},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2071,"deterministic_run_identity":"19760e7b48dec05a94a45c76aa3330892650483f26bead8b2295dbbc403af2a3","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":491102,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1094},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":348,"deterministic_run_identity":"3e537c822f7f51c5cc6c3b02f8ccd01e281abad0164c9e59eee7b8ce8ca86a7a","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":821518,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1094},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2087,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1095:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":490112,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1095},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2038,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1095:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":505859,"primary_aulc_ppm":498180,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1095},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2029,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1095:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":503906,"primary_aulc_ppm":499541,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1095},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1095:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917094,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1095},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":325,"deterministic_run_identity":"5b3ce2c7c96a82275d88b63dbd26019b294d66e216d933ce4f6b3ce6de129f0c","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":844675,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1095},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2087,"deterministic_run_identity":"aaa2fc0c3906aa9c5e1a127b354c07219563ea87fab5367a28ddb509c4a56e7f","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":490112,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1095},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":387,"deterministic_run_identity":"7bf1ba82acf7ccd74d864a83591da11c47a2c60305381da35e52c16d4d4be3a8","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":805555,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1095},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":207,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1096:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":948508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1096:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":947350,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":212,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1096:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":942717,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1096:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":918765,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"deterministic_run_identity":"1bc93962244a1524c42d1195003b4b89e23b64cbf71d086bfa83dbe51bfb7183","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":948508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":207,"deterministic_run_identity":"68567a36b01d95b16b33404c540417ff8383e2613303817f91649d053583041c","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":948508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":207,"deterministic_run_identity":"6e7f53aa3c58339003707e95f2f3090971075b3ae37f023cd2fcf72259d94ab4","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":948508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1096},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2048,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1097:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":489237,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1097},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":210,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1097:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":945531,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1097},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1097:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940898,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1097},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1097:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917760,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1097},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":223,"deterministic_run_identity":"1127010ea87d6f6543a2df1e7fa28c7bb7210703fcfddc66345dcd6d68bba312","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":930475,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1097},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2048,"deterministic_run_identity":"7bfdde880f4f20aee5539a103890f8fbe681b229ce2235790c2b9986b1257ff9","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":489237,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1097},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":356,"deterministic_run_identity":"ef46e3f88875e02710fac863f9c5ee9f152b3bd1040277fd12ec95de9ed5e3d4","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":824810,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1097},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2051,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1098:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":497910,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1098},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2067,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1098:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":497165,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1098},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1098:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":942501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1098},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1098:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":917653,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1098},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":256,"deterministic_run_identity":"4190eb7e11c088d5dadc7fafd145c85c2d72e19aca6e2f55124a3186a9651556","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":897764,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1098},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2051,"deterministic_run_identity":"cc919f4811b4967f62b47d02fc2f2d438708c848a9c92fd88146f9818f70f5e5","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":497910,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1098},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":364,"deterministic_run_identity":"e14764e5c8e355c6aed74be7e88a3c5a49ac8274a3d43a2047f81cd2981d4f66","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":820487,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1098},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2019,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1099:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":509076,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1099},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2021,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1099:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":516046,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1099},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2000,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1099:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":488281,"primary_aulc_ppm":519508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1099},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":220,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1099:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":916753,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1099},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":300,"deterministic_run_identity":"478dd1e28bc6682d7a326f41048c35fac37c984cb400384584e1686eea6bf1eb","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":850938,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1099},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2019,"deterministic_run_identity":"e19c52476f2fc652f57348171154d99797ba9abd84c6f25face38b6b46a4e7d8","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":509076,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1099},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":367,"deterministic_run_identity":"f625a51b30f2aee453226832652591b7f4e621a0806eb5b3cf4e5d38ee3cc260","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":807341,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1099},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":186,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1100:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":951677,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":188,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1100:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":949361,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":192,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1100:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":944728,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1100:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":921647,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":186,"deterministic_run_identity":"8f10ab36efe1cf7f34aa552b6d00d4cf6b22d263fb5ca2bd6bafa1a275b4d68a","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":951677,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":186,"deterministic_run_identity":"86e7838f835cb6c3ed7dcd05e3a6dc0b7d59ad6e971087d04eaa6697603c57c7","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":951677,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":186,"deterministic_run_identity":"448251e264e6a19349c9d1e529b21952383a0ef7c47541517010847e81ec64cb","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":951677,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1100},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2034,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1101:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":508702,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1101},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1101:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":949553,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1101},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1101:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":944920,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1101},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1101:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":919321,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1101},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":228,"deterministic_run_identity":"ceb4c57bf827cdaa0e3751f40630e93647ae53b5adf926cbccc585b34332b749","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":932180,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1101},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2034,"deterministic_run_identity":"841c3a0520244387b6d01f9561dd140a59c4ced7779788318ae1f690998bd7e6","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":508702,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1101},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":357,"deterministic_run_identity":"89654a236b4f58799a236f58f4cad2769fab0714b951db0b057bffbea9b8148a","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":830191,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1101},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2001,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1102:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":524371,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1102},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2031,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1102:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":488281,"primary_aulc_ppm":518910,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1102},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1102:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":943302,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1102},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":233,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1102:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":920854,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1102},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":248,"deterministic_run_identity":"79d330867ace874593a71aa0d198986b23dee89a02d3225117d6ee3895dc5eba","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":905454,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1102},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2001,"deterministic_run_identity":"b5a7621d340dc2847a81c7f3660bc977a00b55f1da930d02cb789819c03e204c","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":524371,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1102},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":341,"deterministic_run_identity":"604fa1f157d1f091f5544e68b970b11413c51ee2acba720409c639006fae1a1d","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":838674,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1102},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2042,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1103:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":525390,"primary_aulc_ppm":498342,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1103},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2064,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1103:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":439453,"primary_aulc_ppm":507916,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1103},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2009,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1103:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":447265,"primary_aulc_ppm":525282,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1103},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1103:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":921417,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1103},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":320,"deterministic_run_identity":"76449ab6ab9529faf4bf7a1547f5d6ef16e2c0b30a74382c1f3e6822b40081cf","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":850174,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1103},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2042,"deterministic_run_identity":"16c5122cb9cafe17e675d2f085c663ee3ffc717bba90fd40542ebb40c056b371","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":525390,"primary_aulc_ppm":498342,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1103},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":376,"deterministic_run_identity":"c688afb200a7e2c1a9ab2aa124c085373e741594af89c6f1f8d1ca7b2855164d","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":813116,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1103},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1104:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946331,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1104:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":944014,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1104:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939382,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1104:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":914452,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":215,"deterministic_run_identity":"95aaf16109d3e89de024b06367ff9b6b63e1a7ad6a6c1502fd980f0b80e51cb2","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946331,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":215,"deterministic_run_identity":"e970a7559dbbefa6b4fdebc6bd4ed719b5e4b41558aca4f436538e68d352983f","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946331,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":215,"deterministic_run_identity":"bafb336842bd5e3ffe96c52e5e0a69d9c34768f64620d29174a126bde7678e73","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946331,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1104},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2049,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1105:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":495250,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1105},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1105:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":945035,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1105},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1105:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":941804,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1105},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1105:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":916206,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1105},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":225,"deterministic_run_identity":"30e61235af8a796f5a18434f5024eb9454d5724535bbe7df2ab3824c6dbf9e65","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":925346,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1105},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2049,"deterministic_run_identity":"8ab8c610c22fef658d5ac8ce1fddc3ec1d5eaa541ec3b4d9f1a22509d0c47ba2","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":495250,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1105},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":364,"deterministic_run_identity":"0bc07cc7dbc11646325f5a4e39302c45d324692d2f9f7029348d1ceb4442e55f","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":814433,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1105},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2007,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1106:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":516254,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1106},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2042,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1106:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":508812,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1106},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":198,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1106:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":943929,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1106},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1106:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":920950,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1106},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"deterministic_run_identity":"428fc361ab5bdd7af20bab5bf1632ee3338f393f3fbb0129ecb0fd51cde3ba7e","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":903398,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1106},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2007,"deterministic_run_identity":"4e7c88e105b370e2fab722a5ca153cb1fac162f9583ae37d89c4c1e8cf848582","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":516254,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1106},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":332,"deterministic_run_identity":"3ab5bfcc293b5ed80d2b1a99f178bc6a4bd684c42cde5dd5dc7f00d739db029c","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":835307,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1106},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2046,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1107:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":460937,"primary_aulc_ppm":491619,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1107},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1107:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":488776,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1107},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2051,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1107:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":501953,"primary_aulc_ppm":498140,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1107},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1107:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":913057,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1107},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":307,"deterministic_run_identity":"6388c9595b8510c2cd1696f6d2e7664a2fb95d2fb4b2cdcae21b6f5ebc7e210a","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":855318,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1107},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2046,"deterministic_run_identity":"50501ed04fb5cdff2f688f5d2f1c7b41b5770387676ab446c5dbc265bff519dc","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":460937,"primary_aulc_ppm":491619,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1107},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":392,"deterministic_run_identity":"fa45c2ff8a37fd21e8c4c6ef455163bb6c9689bd363a42f541bb61ff58ca5d5c","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":800403,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1107},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1108:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948991,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":210,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1108:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":946675,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1108:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":943200,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1108:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":921198,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":208,"deterministic_run_identity":"fb770d85845b6ea72966509aabfaa1e3fb76bee8bcfacc42be3d898087450b70","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948991,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":208,"deterministic_run_identity":"caa52ef58fa4a7bdfbe20768876835f13746f2d9f6e76c8e44b398abc75b4666","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948991,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":208,"deterministic_run_identity":"d56bcad7e63693eaf658c2a902fdc6c2f4a0ce9c87f9979342b5f0e540bd7fb9","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948991,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1108},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2006,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1109:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":512369,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1109},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1109:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":945480,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1109},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1109:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":940848,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1109},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1109:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":917188,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1109},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":231,"deterministic_run_identity":"bda50899d0bd6b13bb38d972acce678f642fe3e3cda67f5129daacfcad1c2274","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":929266,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1109},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2006,"deterministic_run_identity":"31d55c3564478ef5e7aa72cf27ec8d219bf13d8d3218b5b685757b8e32aa1c65","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":512369,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1109},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":352,"deterministic_run_identity":"4ec3d42b78932454b75798de61ab7f13ab5812f77d7f3dcd5451f4959e76499b","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":833869,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1109},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2058,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1110:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":495965,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1110},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2004,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1110:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":496093,"primary_aulc_ppm":504282,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1110},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":194,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1110:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":945929,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1110},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1110:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921488,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1110},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":243,"deterministic_run_identity":"ffa7c7fa02f114ec420f80a561e97f2872e66e13a250085b7d97b655fea4c987","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":893573,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1110},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2058,"deterministic_run_identity":"77e3b3af0db72f806c7cddba3afe5087a7d3daf39a5b94b6e39037f5ef407604","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":495965,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1110},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":350,"deterministic_run_identity":"11050c9a8c2e3b38acf4c17b2ff99c37af276b3e9c183314c03bf571098f5ac6","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":816894,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1110},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2042,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1111:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":513738,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1111},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2019,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1111:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":521484,"primary_aulc_ppm":506482,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1111},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2027,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1111:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":529296,"primary_aulc_ppm":499585,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1111},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1111:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":922000,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1111},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":295,"deterministic_run_identity":"ce5a8c3303ddef7a6c53ad14d27ec2742f0ff2350e5c11956c01e6a772e84e4f","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":862231,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1111},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2042,"deterministic_run_identity":"944c75b280930a5cb29d7a713112053a59302132a4ccfbc89121a465dcc60401","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":513738,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1111},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":362,"deterministic_run_identity":"254271ba126b013a745e41866150e02b6ca9b42a5c47d2d341cc468fd98150ab","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":819353,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1111},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":216,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1112:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":949265,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1112:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":946948,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":222,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1112:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":942316,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1112:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":918870,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"deterministic_run_identity":"0044a73c9cbda5fa743ab6ca206aa256058ac60ec40f6f653585d9d5335f29eb","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":949265,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":216,"deterministic_run_identity":"78083821b0ffb932ceb098d2f1cd13826033c12a42a9683c0ed143b2eff0324c","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":949265,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":216,"deterministic_run_identity":"7b8aa9743d2634442a9210c9af03359efbd87c13c5b978e5bec1f62e65d377c0","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":949265,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1112},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2076,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1113:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":497921,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1113},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":211,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1113:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":946097,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1113},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1113:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":942622,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1113},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1113:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":918303,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1113},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":229,"deterministic_run_identity":"212bb489c89e853ad18601c768428227aea04af958b3e74937d39a44a811a7ec","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":925249,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1113},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2076,"deterministic_run_identity":"e23481312720662182c447a766af6b4b162f10bfe7494ac6a982f53ef3ec5ad3","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":497921,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1113},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":351,"deterministic_run_identity":"75db99829a073fd9e2601173c853d705e473c835babc74bedc6b90ec69c04e04","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":827820,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1113},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2050,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1114:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":514273,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1114},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2061,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1114:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":470703,"primary_aulc_ppm":509002,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1114},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1114:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":947019,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1114},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1114:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":923492,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1114},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":244,"deterministic_run_identity":"6123f99c00619a173390486527de8b9204ec9291ca125118d54b0e110d1abd55","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":910877,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1114},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2050,"deterministic_run_identity":"185c6bb11dd6656afad4750db889e87b46d6e7568d831c8d28ab47d1b0042d31","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":514273,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1114},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":345,"deterministic_run_identity":"24f44cc026b022f245797eec298d936f41485569cfda92b29657ade74d1de711","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":835068,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1114},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2048,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1115:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":499995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1115},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2023,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1115:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":498680,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1115},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2020,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1115:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":494140,"primary_aulc_ppm":497402,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1115},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1115:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":921550,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1115},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":307,"deterministic_run_identity":"60db8e567b20a1c5cc66f88ed9ce56f1e729b8d2d0c4eb263961a1ff8dcd3836","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":850751,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1115},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2048,"deterministic_run_identity":"f1ab42d5b426a52314d3e655d35e425e2a0dbd1a10150e176cea5961b383be97","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":499995,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1115},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":370,"deterministic_run_identity":"7c05264d27c4bb8150e94ae96ce772b6cb1f527fd34eb44ec9664f311e2d2b5b","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":810071,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1115},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":213,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1116:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":945624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1116:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":943307,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1116:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":938919,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1116:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":915392,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":213,"deterministic_run_identity":"7eb1c80ff8268c8704da3f06337dbaf1a3e1452900b900afa622130cc6aaf3cb","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":945624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":213,"deterministic_run_identity":"744e02c52a7454894f46a7fdd78512eb07a710014d594826f2b17ba0aa065ba4","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":945624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":213,"deterministic_run_identity":"26326ae1de8f4d187574ead835fef35cbd81a9e4aff9202728485e6105110b41","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":945624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1116},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2044,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1117:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":511000,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1117},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1117:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":944670,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1117},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1117:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":940037,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1117},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1117:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":915800,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1117},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":230,"deterministic_run_identity":"c888c52cc7e3fd1be22cf3823b66c4d2589c9a77392b137ce8ea447ecd923270","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":929613,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1117},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2044,"deterministic_run_identity":"0c0b6c33485105868d103feaa855cabf902d1f1d6a59ef725a60303696fd9e23","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":511000,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1117},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":345,"deterministic_run_identity":"a5b100f0e82c24bbb4f3af1c8f1cc07330734d0660815c23d9ec78006c659c56","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":839709,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1117},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2143,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1118:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":468645,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1118},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2127,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1118:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":462890,"primary_aulc_ppm":481982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1118},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1118:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":940865,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1118},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1118:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":916058,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1118},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":262,"deterministic_run_identity":"ab6e18268c61b7dca8dd24ef6aa4cd21acacb0c18d7b44a4ae4f50382e106a1a","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":895946,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1118},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2143,"deterministic_run_identity":"66fa336b4a5a96054fd98b05b2e87f610687ef566676d45224d80f63ac8e1724","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":468645,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1118},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":376,"deterministic_run_identity":"c63bf7b0bf4e2b94d65c8f10d847b56e143b0a62277676e900e3bf3b77861614","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":810732,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1118},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2088,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1119:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":491507,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1119},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2082,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1119:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":496598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1119},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2081,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1119:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":517578,"primary_aulc_ppm":487916,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1119},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":248,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1119:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":916691,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1119},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":341,"deterministic_run_identity":"99976feb977ae4480dbc5a8f4a68a57645b740011a6991a22ff0018294449580","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":838517,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1119},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2088,"deterministic_run_identity":"60d0e8c86cc8c9bc4971ae790515740adb51d5130232ff71fb3a8269804d574d","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":491507,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1119},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":388,"deterministic_run_identity":"baad447c3cdd045d6914c628ef4cdcddd74f24c31708d4c4728cea9359ef96bb","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":810902,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1119},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1120:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":948792,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1120:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":946475,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":225,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1120:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":941843,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":247,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1120:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":919252,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":219,"deterministic_run_identity":"c975051a3a68ce754ab92d32a433ec8e5fcdff2bc4efa94f78c5741754cfb114","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":948792,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":219,"deterministic_run_identity":"f3fa72f561a38c5c50fb24d2e19d25ffa40ec655d73fcdbab237f4d553453782","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":948792,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":219,"deterministic_run_identity":"8fa7788e32352f980d702d5abdb70cca8dcc8beda57d43b94b861a48ee540c56","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":948792,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1120},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2061,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1121:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":505753,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1121},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":205,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1121:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":945137,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1121},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1121:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":941662,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1121},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1121:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918805,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1121},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":224,"deterministic_run_identity":"3aff05dc8bc3bb69ffe4ce624019729b6cbcf5cdfb3def9e82edd82a78ca02d6","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":923131,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1121},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2061,"deterministic_run_identity":"036f977ff336db66fec55eba943f0e621e25a4ef702e4048cd23b6ede1246185","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":505753,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1121},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":352,"deterministic_run_identity":"84cdea8df996659972bde6ec5ba10eb07b9d38e6b0d4db877408b1bfd844b262","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":822464,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1121},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2054,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1122:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":497637,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1122},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2059,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1122:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":486328,"primary_aulc_ppm":495702,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1122},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1122:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":941841,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1122},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1122:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917665,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1122},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":257,"deterministic_run_identity":"8db5bd61033e695dd84948f06d51fed87f5df50f1786b688325dccdc243734e1","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":899179,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1122},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2054,"deterministic_run_identity":"e3576281afbbf7b2caf519973094e1d01c22956ad6e8d96bfe91686148bf7e82","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":497637,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1122},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":362,"deterministic_run_identity":"9c2d57849cf1a6e39975b7aaf6143f30c77eccb9207fca24e74c484f9e7569ff","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":821438,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1122},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2017,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1123:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":506336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1123},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1994,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1123:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":521484,"primary_aulc_ppm":503205,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1123},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2008,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1123:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":521484,"primary_aulc_ppm":499737,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1123},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1123:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":921887,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1123},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":319,"deterministic_run_identity":"11bb135f5c01831831879aeac624dc90d2ef5e7195fbb9ee75954b33f2adca2d","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":841904,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1123},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2017,"deterministic_run_identity":"ecd377546a720c9eda426469ac84a1e2366a79868acf1dc4e26cee68338ccd31","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":506336,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1123},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":370,"deterministic_run_identity":"b372da715a59e21911bc046d293066c796d9c4ec243ae27db377597168e7766d","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":812564,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1123},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":194,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1124:REACTIVE","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":954374,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":196,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1124:FIXED-H1","diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":952057,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":200,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1124:FIXED-H2","diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":947425,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1124:FIXED-H4","diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":923594,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":194,"deterministic_run_identity":"10549e91092a67c3799b831e331ea9a39a156543faee5a80a96c915b44f7fec0","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":954374,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":194,"deterministic_run_identity":"240bf9b7160496dddecc666e23e243a1cc2208bcc4dd3b29c43f01923993e9bc","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":954374,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":0,"condition":"FULL-PRIME","cumulative_regret":194,"deterministic_run_identity":"15f352695f37934fb4ad89f03ba16eb9d5833e73fb56997a8cee0c126e594910","diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":954374,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1124},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2070,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1125:REACTIVE","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":505428,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1125},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":208,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1125:FIXED-H1","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":944881,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1125},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":212,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1125:FIXED-H2","diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1125},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1125:FIXED-H4","diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":915685,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1125},{"accepted_repairs":1,"adaptation_latencies_episodes":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":222,"deterministic_run_identity":"a0c0bc24d2fb5e0a75187e1dc0db3d5529f7f9b3e95eb5b7731943c33393ebf9","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":928666,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1125},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2070,"deterministic_run_identity":"b109c35aa95d318699bba25e4a2f2c18f470a28483c698bda254c1c53fdefcd3","diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":505428,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1125},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":343,"deterministic_run_identity":"b2e0cc1fd84493ac00b060a2dbf7140d6685ee50f201a727b20129e8706e55cc","diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":833258,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1125},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2068,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1126:REACTIVE","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":504581,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1126},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2098,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1126:FIXED-H1","diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":483658,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1126},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":199,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1126:FIXED-H2","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":942192,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1126},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":221,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1126:FIXED-H4","diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918543,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1126},{"accepted_repairs":2,"adaptation_latencies_episodes":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":243,"deterministic_run_identity":"488e78856944e63fc3202e1cca3645be3a8466a9d88cc764905c81ecc11c33cc","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":896359,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1126},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2068,"deterministic_run_identity":"c70f0917626a3e38fc21a7a34cf3720dace0e733145b03e07293fac42e50ac69","diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":504581,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1126},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":339,"deterministic_run_identity":"2b4d338123445a1e40af3249874827474d6c702f7e4b027a15b358d6be515d52","diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":829123,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1126},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2025,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1127:REACTIVE","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":451171,"primary_aulc_ppm":512103,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1127},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2037,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1127:FIXED-H1","diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":449218,"primary_aulc_ppm":503024,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1127},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":1992,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1127:FIXED-H2","diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":494140,"primary_aulc_ppm":511400,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1127},{"accepted_repairs":0,"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":219,"deterministic_run_identity":"4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df:1127:FIXED-H4","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921664,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1127},{"accepted_repairs":3,"adaptation_latencies_episodes":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":304,"deterministic_run_identity":"ac026d3b1f7a0042b4af08e04b7f0c4bc08855116f76b4c9e010baa9f81a42ee","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":854364,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":1127},{"accepted_repairs":0,"adaptation_latencies_episodes":[],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2025,"deterministic_run_identity":"1c8af136eecee4baf44fe479fece5c1ee3b8838fb652a0136d58540a38ca43cb","diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":451171,"primary_aulc_ppm":512103,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1127},{"accepted_repairs":1,"adaptation_latencies_episodes":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME","cumulative_regret":361,"deterministic_run_identity":"281e9e8d953986d820a7cd3b69cdeb76bb6aa4ab0719eedcae7d398f4c6e2149","diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":817960,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":1127}],"status":"FROZEN_EVALUATION_COMPLETE","verifier_specific_full_vs_adaptive_no_verifier":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":-59091,"lower_sum_delta":-7563526,"observed_mean_delta_ppm":-52427,"observed_sum_delta":-6710566,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":-45713,"upper_sum_delta":-5851187},"claim":"NOT SUPPORTED"}} diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/FROZEN_EVALUATION_RESULT.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/FROZEN_EVALUATION_RESULT.sha256 new file mode 100644 index 0000000..70b908a --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/FROZEN_EVALUATION_RESULT.sha256 @@ -0,0 +1 @@ +b58a51857864e61837168dbb5e36ef69d26a600b5775aa2dcc3cb17651962388 FROZEN_EVALUATION_RESULT.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/HELD_OUT_RESULT.md b/experiments/prime_canonical_agent_benchmark_v1_1/HELD_OUT_RESULT.md new file mode 100644 index 0000000..f0d2b3e --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/HELD_OUT_RESULT.md @@ -0,0 +1,178 @@ +# PRIME Canonical Agent Benchmark v1.1 +## Frozen Held-Out Evaluation Result + +Status: COMPLETE + +Source commit: + + 8d2f03495bead25bedb31c6008e46d1ebb22b8ee + +Frozen hypothesis-bearing core SHA-256: + + b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f + +Evaluation worlds: + + 128 + +Frozen evaluation seeds: + + 1000 through 1127 inclusive + +Evaluation result SHA-256: + + b58a51857864e61837168dbb5e36ef69d26a600b5775aa2dcc3cb17651962388 + +All integrity checks passed. + +--- + +# Preregistered primary result + + NOT SUPPORTED + +FULL-PRIME did not outperform the development-selected FIXED-H4 comparator +on frozen held-out online-learning AULC. + +Mean primary AULC: + + REACTIVE 613189 + FIXED-H1 723884 + FIXED-H2 832090 + FIXED-H4 918420 + ADAPTIVE-NO-VERIFIER 905346 + VERIFIER-NO-REPAIR 613189 + FULL-PRIME 852920 + +FULL-PRIME minus FIXED-H4: + + mean paired delta: + -65501 ppm + + frozen deterministic bootstrap 95% interval: + [-74816, -55695] ppm + +The confidence interval lies entirely below zero. + +Therefore the preregistered primary performance claim is not supported. + +--- + +# Final performance + +Mean final-window reward: + + FIXED-H4 949096 + ADAPTIVE-NO-VERIFIER 949096 + FULL-PRIME 949096 + +FULL-PRIME therefore showed no final-window degradation relative to FIXED-H4. + +The performance deficit is an online adaptation-efficiency deficit rather than +a final-policy-quality deficit. + +--- + +# Verifier-specific result + +FULL-PRIME minus ADAPTIVE-NO-VERIFIER: + + mean paired AULC delta: + -52427 ppm + + frozen deterministic bootstrap 95% interval: + [-59091, -45713] ppm + +Verifier-specific performance claim: + + NOT SUPPORTED + +The frozen prospective verification process imposed more online-learning cost +than the ungated adaptive repair mechanism. + +--- + +# Representation-repair result + +Despite the negative primary performance result, FULL-PRIME recovered the +exact environment-required final representation depth in every held-out world: + + hidden d=0 -> final H0: 32/32 + hidden d=1 -> final H1: 32/32 + hidden d=2 -> final H2: 32/32 + hidden d=4 -> final H4: 32/32 + +Total: + + 128/128 exact final-depth recovery + +FULL-PRIME accepted: + + 96 repairs + +This equals exactly the number of held-out worlds requiring nonzero memory. + +No d=0 world underwent an accepted representation repair. + +ADAPTIVE-NO-VERIFIER accepted: + + 192 repairs + +This is consistent with incremental ladder traversal: + + d=1: H0 -> H1 + d=2: H0 -> H1 -> H2 + d=4: H0 -> H1 -> H2 -> H4 + +Thus verifier governance substantially improved repair targeting, but not +online-learning efficiency under the frozen four-episode prospective probe. + +--- + +# Mean cumulative regret + + FIXED-H4 234 + ADAPTIVE-NO-VERIFIER 251 + FULL-PRIME 322 + +Relative to FIXED-H4, FULL-PRIME incurred approximately 88 additional +incorrect decisions per held-out world. + +Relative to ungated adaptive repair, FULL-PRIME incurred approximately 71 +additional incorrect decisions per world. + +--- + +# Interpretation + +The held-out evidence supports the mechanistic observation that the frozen +verifier can identify and authorize the minimal sufficient representation with +very high reliability in this controlled benchmark. + +It does not support the stronger claim that the resulting verifier-governed +adaptive system improves online learning efficiency over the frozen maximum +history representation or over ungated adaptive growth. + +The principal observed bottleneck is verification latency. + +A successor experiment should therefore investigate whether verifier +sovereignty can be retained while reducing evidence-acquisition and +authorization latency. + +The v1.1 rules, thresholds, implementation, analysis plan, and negative primary +result must remain immutable. + +Any successor is a new explicitly linked experiment. + +--- + +# Claim boundary + +This is controlled benchmark evidence. + +It is not evidence of AGI, general POMDP superiority, universal adaptive +representation superiority, production security, or broad real-world +generality. + +The original frozen requirement for a learned-memory baseline remains necessary +before making a stronger public comparative performance claim. diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/LINEAGE.json b/experiments/prime_canonical_agent_benchmark_v1_1/LINEAGE.json new file mode 100644 index 0000000..a4ba4f8 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/LINEAGE.json @@ -0,0 +1,10 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.1", + "parent_benchmark": "prime-canonical-agent-benchmark-v1", + "parent_apparatus_commit": "23c326f", + "parent_contract_sha256": "91681a38971cf85eb3315a5b56ab9fd7064c65f1a4c2575ab390eba8be372a48", + "parent_apparatus_implementation_sha256": "4c93d3cda0a9d3dcab8e47ad890b93a3abfafcd480285da37913cb582b3232df", + "development_selected_fixed_baseline": "FIXED-H4", + "evaluation_seeds_inspected_before_successor_freeze": false, + "reason": "next-depth-only repair cannot honestly traverse information-neutral intermediate representations" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/LINEAGE.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/LINEAGE.sha256 new file mode 100644 index 0000000..f740159 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/LINEAGE.sha256 @@ -0,0 +1 @@ +9b1516271cf7a8873996239dff84aee579a09d86e828cd2b33659a04f073340f LINEAGE.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/__init__.py b/experiments/prime_canonical_agent_benchmark_v1_1/__init__.py new file mode 100644 index 0000000..a1b592c --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/__init__.py @@ -0,0 +1 @@ +"""PRIME Canonical Agent Benchmark v1.1 successor experiment.""" diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/adaptive_runner.py b/experiments/prime_canonical_agent_benchmark_v1_1/adaptive_runner.py new file mode 100644 index 0000000..6ff6d17 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/adaptive_runner.py @@ -0,0 +1,445 @@ +"""Adaptive conditions for PRIME Canonical Agent Benchmark v1.1.""" + +from dataclasses import dataclass +import hashlib +import json + +from experiments.prime_canonical_agent_benchmark_v1.baselines import ( + HistoryRepresentation, +) +from experiments.prime_canonical_agent_benchmark_v1.deterministic import ( + splitmix64, +) +from experiments.prime_canonical_agent_benchmark_v1.environment import ( + MemoryAliasPOMDP, +) +from experiments.prime_canonical_agent_benchmark_v1.learner import ( + BinaryTabularLearner, +) +from experiments.prime_canonical_agent_benchmark_v1.manifest import ( + DECISION_STEPS_PER_EPISODE, + EPISODES, + EVALUATION_SEEDS, + FINAL_WINDOW_EPISODES, + PPM, + WARMUP_STEPS, +) + +from .provenance import ( + frozen_identities, + implementation_sha256, + source_commit, + source_dirty, +) +from .receipts import ReceiptChain, canonical_bytes, verify_receipt_chain +from .verifier import ProbeEvent, evaluate_candidates + + +BENCHMARK_VERSION = "prime-canonical-agent-benchmark-v1.1" + +ADAPTIVE_CONDITIONS = ( + "ADAPTIVE-NO-VERIFIER", + "VERIFIER-NO-REPAIR", + "FULL-PRIME", +) + +PERMITTED_DEPTHS = (0, 1, 2, 4) +OBSTRUCTION_MIN_PER_TARGET = 8 +PROBE_EPISODES = 4 +MAX_ACCEPTED_REPAIRS = 3 + + +@dataclass(frozen=True) +class AdaptiveResult: + payload: dict + + def canonical_bytes(self) -> bytes: + return canonical_bytes(self.payload) + + def sha256(self) -> str: + return hashlib.sha256(self.canonical_bytes()).hexdigest() + + +def _primary_aulc_ppm(episode_rewards: list[int]) -> int: + cumulative = 0 + curve_sum = 0 + + for index, reward in enumerate(episode_rewards, start=1): + cumulative += reward + denominator = index * DECISION_STEPS_PER_EPISODE + curve_sum += (PPM * cumulative) // denominator + + return curve_sum // len(episode_rewards) + + +def _final_window_ppm(episode_rewards: list[int]) -> int: + window = episode_rewards[-FINAL_WINDOW_EPISODES:] + successes = sum(window) + trials = len(window) * DECISION_STEPS_PER_EPISODE + return (PPM * successes) // trials + + +def _candidate_depths(current_depth: int) -> tuple[int, ...]: + return tuple( + depth for depth in PERMITTED_DEPTHS + if depth > current_depth + ) + + +def _infer_target(action: int, reward: int) -> int: + if reward == 1: + return action + if reward == 0: + return 1 - action + raise RuntimeError("benchmark reward must be binary") + + +def _obstruction_exists( + evidence: dict[tuple[int, ...], list[int]], +) -> bool: + return any( + counts[0] >= OBSTRUCTION_MIN_PER_TARGET + and counts[1] >= OBSTRUCTION_MIN_PER_TARGET + for counts in evidence.values() + ) + + +def _promote_from_current_state( + current_state: tuple[int, ...], + new_depth: int, +) -> HistoryRepresentation: + representation = HistoryRepresentation(depth=new_depth) + + for bit in current_state: + representation.observe(bit) + + return representation + + +def run_adaptive_condition( + world_seed: int, + condition: str, + *, + permit_evaluation: bool = False, +) -> AdaptiveResult: + if condition not in ADAPTIVE_CONDITIONS: + raise ValueError(f"unknown adaptive condition: {condition}") + + if world_seed in EVALUATION_SEEDS and not permit_evaluation: + raise RuntimeError( + "frozen evaluation seed blocked during adaptive development" + ) + + frozen = frozen_identities() + + env = MemoryAliasPOMDP(world_seed) + current_depth = 0 + representation = HistoryRepresentation(depth=current_depth) + + learner_seed = splitmix64(world_seed ^ 0x8EBC6AF09C88C6E3) + learner = BinaryTabularLearner(seed=learner_seed) + + obstruction_evidence: dict[tuple[int, ...], list[int]] = {} + proposal_attempted_depths: set[int] = set() + + receipt_chain = ReceiptChain() + + proposed_repairs = 0 + accepted_repairs = 0 + rejected_repairs = 0 + verifier_supported_repairs = 0 + verifier_suppressed_repairs = 0 + + representation_change_episodes: list[int] = [] + adaptation_latencies_episodes: list[int] = [] + episode_rewards: list[int] = [] + + pending_probe: dict | None = None + + for episode in range(EPISODES): + representation.reset() + observation = env.reset(episode) + + probe_active = ( + pending_probe is not None + and episode >= pending_probe["start_episode"] + and pending_probe["episodes_collected"] < PROBE_EPISODES + ) + + if probe_active: + shadow_current = HistoryRepresentation(depth=current_depth) + shadow_candidates = { + depth: HistoryRepresentation(depth=depth) + for depth in pending_probe["candidate_depths"] + } + else: + shadow_current = None + shadow_candidates = {} + + scored_reward = 0 + total_steps = WARMUP_STEPS + DECISION_STEPS_PER_EPISODE + + for _step_index in range(total_steps): + state = representation.observe(observation) + + candidate_states: dict[int, tuple[int, ...]] = {} + + if probe_active: + shadow_state = shadow_current.observe(observation) + + if shadow_state != state: + raise RuntimeError( + "current-representation shadow mismatch" + ) + + candidate_states = { + depth: shadow_candidates[depth].observe(observation) + for depth in pending_probe["candidate_depths"] + } + + action = learner.choose(state) + result = env.step(action) + + if result.scored: + learner.update(state, action, result.reward) + scored_reward += result.reward + + target = _infer_target(action, result.reward) + + bucket = obstruction_evidence.setdefault( + state, + [0, 0], + ) + bucket[target] += 1 + + if probe_active: + pending_probe["events"].append( + ProbeEvent( + current_state=state, + candidate_states=candidate_states, + target=target, + ) + ) + + can_propose = ( + pending_probe is None + and current_depth not in proposal_attempted_depths + and accepted_repairs < MAX_ACCEPTED_REPAIRS + and bool(_candidate_depths(current_depth)) + ) + + if can_propose and _obstruction_exists( + obstruction_evidence + ): + candidates = _candidate_depths(current_depth) + proposal_attempted_depths.add(current_depth) + proposed_repairs += 1 + + if condition == "ADAPTIVE-NO-VERIFIER": + before = current_depth + authorized = candidates[0] + + receipt_chain.append( + { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "obstruction_episode": episode, + "resolution_episode": episode, + "canonical_depth_before": before, + "candidate_depths": list(candidates), + "verifier_evidence": [], + "supported_candidates": [], + "verifier_supported_depth": None, + "authorized_depth": authorized, + "canonical_depth_after": authorized, + "resolution": "UNGATED_ACCEPT", + } + ) + + current_depth = authorized + representation = _promote_from_current_state( + state, + current_depth, + ) + + accepted_repairs += 1 + representation_change_episodes.append(episode) + adaptation_latencies_episodes.append(0) + obstruction_evidence = {} + + else: + pending_probe = { + "obstruction_episode": episode, + "start_episode": episode + 1, + "current_depth": current_depth, + "candidate_depths": candidates, + "events": [], + "episodes_collected": 0, + } + + if result.done: + if result.next_observation is not None: + raise RuntimeError( + "terminal step exposed next observation" + ) + else: + if result.next_observation not in (0, 1): + raise RuntimeError("invalid next observation") + observation = result.next_observation + + episode_rewards.append(scored_reward) + + if probe_active: + pending_probe["episodes_collected"] += 1 + + if pending_probe["episodes_collected"] == PROBE_EPISODES: + summaries, supported = evaluate_candidates( + current_depth=pending_probe["current_depth"], + candidate_depths=pending_probe["candidate_depths"], + events=pending_probe["events"], + ) + + verifier_supported_depth = ( + min(supported) if supported else None + ) + + if verifier_supported_depth is not None: + verifier_supported_repairs += 1 + + before = current_depth + + if condition == "FULL-PRIME": + authorized = verifier_supported_depth + + if authorized is None: + after = before + resolution = "VERIFIER_REJECT" + rejected_repairs += 1 + else: + after = authorized + resolution = "VERIFIER_AUTHORIZE" + accepted_repairs += 1 + representation_change_episodes.append(episode + 1) + adaptation_latencies_episodes.append( + (episode + 1) + - pending_probe["obstruction_episode"] + ) + + elif condition == "VERIFIER-NO-REPAIR": + authorized = None + after = before + + if verifier_supported_depth is None: + resolution = "VERIFIER_REJECT" + rejected_repairs += 1 + else: + resolution = "VERIFIER_SUPPORTED_MUTATION_DISABLED" + verifier_suppressed_repairs += 1 + + else: + raise RuntimeError("unexpected adaptive condition") + + receipt_chain.append( + { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "obstruction_episode": pending_probe[ + "obstruction_episode" + ], + "resolution_episode": episode, + "canonical_depth_before": before, + "candidate_depths": list( + pending_probe["candidate_depths"] + ), + "verifier_evidence": summaries, + "supported_candidates": list(supported), + "verifier_supported_depth": ( + verifier_supported_depth + ), + "authorized_depth": authorized, + "canonical_depth_after": after, + "resolution": resolution, + } + ) + + if condition == "FULL-PRIME" and authorized is not None: + current_depth = authorized + representation = HistoryRepresentation( + depth=current_depth + ) + obstruction_evidence = {} + + pending_probe = None + + records = receipt_chain.records + + if not verify_receipt_chain(records): + raise RuntimeError("internal repair receipt-chain verification failed") + + total_reward = sum(episode_rewards) + total_trials = EPISODES * DECISION_STEPS_PER_EPISODE + + implementation_hash = implementation_sha256() + + run_identity_payload = { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "episodes": EPISODES, + "decision_steps_per_episode": DECISION_STEPS_PER_EPISODE, + "warmup_steps": WARMUP_STEPS, + "implementation_sha256": implementation_hash, + "frozen_identities": frozen, + } + + deterministic_run_identity = hashlib.sha256( + canonical_bytes(run_identity_payload) + ).hexdigest() + + payload = { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "episodes": EPISODES, + "decision_steps_per_episode": DECISION_STEPS_PER_EPISODE, + "warmup_steps": WARMUP_STEPS, + "episode_rewards": episode_rewards, + "primary_aulc_ppm": _primary_aulc_ppm(episode_rewards), + "final_window_reward_ppm": _final_window_ppm(episode_rewards), + "total_reward": total_reward, + "cumulative_regret": total_trials - total_reward, + "proposed_repairs": proposed_repairs, + "accepted_repairs": accepted_repairs, + "rejected_repairs": rejected_repairs, + "verifier_supported_repairs": verifier_supported_repairs, + "verifier_suppressed_repairs": verifier_suppressed_repairs, + "final_representation_depth": current_depth, + "representation_change_episodes": ( + representation_change_episodes + ), + "adaptation_latencies_episodes": ( + adaptation_latencies_episodes + ), + "mean_adaptation_latency_episodes": ( + sum(adaptation_latencies_episodes) + // len(adaptation_latencies_episodes) + if adaptation_latencies_episodes + else None + ), + "repair_receipts": records, + "canonical_receipt_count": len(records), + "repair_receipt_chain_tip": receipt_chain.tip, + "repair_receipt_chain_valid": True, + "deterministic_run_identity": deterministic_run_identity, + "integrity_failures": 0, + "frozen_identities": frozen, + "implementation_sha256": implementation_hash, + "source_commit": source_commit(), + "source_dirty": source_dirty(), + } + + return AdaptiveResult(payload=payload) diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/evaluation_tools/frozen_evaluation.py b/experiments/prime_canonical_agent_benchmark_v1_1/evaluation_tools/frozen_evaluation.py new file mode 100644 index 0000000..e41936e --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/evaluation_tools/frozen_evaluation.py @@ -0,0 +1,620 @@ +"""One-shot frozen evaluation harness for PRIME benchmark v1.1.""" + +import argparse +import hashlib +import json +import os +from pathlib import Path +import subprocess +import sys + +from experiments.prime_canonical_agent_benchmark_v1.deterministic import ( + splitmix64, +) +from experiments.prime_canonical_agent_benchmark_v1.manifest import ( + EVALUATION_SEEDS, +) +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) +from experiments.prime_canonical_agent_benchmark_v1_1.adaptive_runner import ( + ADAPTIVE_CONDITIONS, + run_adaptive_condition, +) +from experiments.prime_canonical_agent_benchmark_v1_1.provenance import ( + frozen_identities, + implementation_sha256, +) +from experiments.prime_canonical_agent_benchmark_v1_1.receipts import ( + verify_receipt_chain, +) + + +HERE = Path(__file__).resolve().parent +V11 = HERE.parent +REPO = V11.parent.parent + +FROZEN_CORE_IMPLEMENTATION_SHA256 = ( + "b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f" +) + +FIXED_CONDITIONS = ( + "REACTIVE", + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", +) + +BOOTSTRAP_REPLICATES = 16384 +BOOTSTRAP_SEED = 0x5052494D45563131 +BOOTSTRAP_LOWER_INDEX = 409 +BOOTSTRAP_UPPER_INDEX = 15974 + +UNLOCK_PHRASE = "RUN_FROZEN_EVALUATION_V1_1" + + +def canonical_bytes(value: object) -> bytes: + return ( + json.dumps( + value, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + +def sha256_file(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def verify_checksum( + target: Path, + checksum_file: Path, +) -> str: + expected = checksum_file.read_text( + encoding="utf-8" + ).split()[0] + + actual = sha256_file(target) + + if actual != expected: + raise RuntimeError( + f"checksum mismatch: {target}" + ) + + return actual + + +def git_status_clean() -> bool: + result = subprocess.run( + ["git", "-C", str(REPO), "status", "--porcelain"], + check=True, + capture_output=True, + text=True, + ) + return result.stdout.strip() == "" + + +def git_commit() -> str: + result = subprocess.run( + ["git", "-C", str(REPO), "rev-parse", "HEAD"], + check=True, + capture_output=True, + text=True, + ) + return result.stdout.strip() + + +def mean_floor(values: list[int]) -> int: + return sum(values) // len(values) + + +def paired_bootstrap(deltas: list[int]) -> dict: + n = len(deltas) + + if n != 128: + raise RuntimeError( + f"expected 128 paired deltas, got {n}" + ) + + replicate_sums = [] + + for replicate in range(BOOTSTRAP_REPLICATES): + total = 0 + + for draw in range(n): + value = splitmix64( + BOOTSTRAP_SEED + ^ splitmix64(replicate) + ^ splitmix64(draw) + ) + + total += deltas[value % n] + + replicate_sums.append(total) + + replicate_sums.sort() + + lower_sum = replicate_sums[ + BOOTSTRAP_LOWER_INDEX + ] + upper_sum = replicate_sums[ + BOOTSTRAP_UPPER_INDEX + ] + + return { + "replicates": BOOTSTRAP_REPLICATES, + "sample_size": n, + "seed_hex": hex(BOOTSTRAP_SEED), + "lower_index": BOOTSTRAP_LOWER_INDEX, + "upper_index": BOOTSTRAP_UPPER_INDEX, + "observed_sum_delta": sum(deltas), + "observed_mean_delta_ppm": ( + sum(deltas) // n + ), + "lower_sum_delta": lower_sum, + "lower_mean_delta_ppm": ( + lower_sum // n + ), + "upper_sum_delta": upper_sum, + "upper_mean_delta_ppm": ( + upper_sum // n + ), + } + + +def preflight() -> dict: + expected_seeds = tuple(range(1000, 1128)) + + if EVALUATION_SEEDS != expected_seeds: + raise RuntimeError( + "frozen evaluation seed set mismatch" + ) + + if not git_status_clean(): + raise RuntimeError( + "Git worktree must be clean before evaluation" + ) + + identities = frozen_identities() + + verify_checksum( + V11 / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json", + V11 / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256", + ) + + verify_checksum( + V11 / "EVALUATION_ANALYSIS_PLAN.md", + V11 / "EVALUATION_ANALYSIS_PLAN.sha256", + ) + + verify_checksum( + HERE / "frozen_evaluation.py", + HERE / "frozen_evaluation.sha256", + ) + + core_hash = implementation_sha256() + + if core_hash != FROZEN_CORE_IMPLEMENTATION_SHA256: + raise RuntimeError( + "core implementation differs from development freeze: " + f"{core_hash}" + ) + + return { + "source_commit": git_commit(), + "core_implementation_sha256": core_hash, + "frozen_identities": identities, + "analysis_plan_sha256": sha256_file( + V11 / "EVALUATION_ANALYSIS_PLAN.md" + ), + "evaluation_harness_sha256": sha256_file( + HERE / "frozen_evaluation.py" + ), + } + + +def build_report() -> dict: + preflight_record = preflight() + rows = [] + + for seed in EVALUATION_SEEDS: + diagnostic_depth = (0, 1, 2, 4)[seed % 4] + + for condition in FIXED_CONDITIONS: + result = run_fixed_condition( + seed, + condition, + ).payload + + if result["source_dirty"]: + raise RuntimeError( + "fixed result reports dirty source" + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": diagnostic_depth, + "condition": condition, + "primary_aulc_ppm": ( + result["primary_aulc_ppm"] + ), + "final_window_reward_ppm": ( + result["final_window_reward_ppm"] + ), + "cumulative_regret": ( + result["cumulative_regret"] + ), + "final_representation_depth": ( + result["representation_depth"] + ), + "proposed_repairs": 0, + "accepted_repairs": 0, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "canonical_receipt_count": 0, + "receipt_chain_valid": True, + "deterministic_run_identity": ( + result["implementation_sha256"] + + ":" + + str(seed) + + ":" + + condition + ), + } + ) + + for condition in ADAPTIVE_CONDITIONS: + result = run_adaptive_condition( + seed, + condition, + permit_evaluation=True, + ).payload + + if result["source_dirty"]: + raise RuntimeError( + "adaptive result reports dirty source" + ) + + if not verify_receipt_chain( + result["repair_receipts"] + ): + raise RuntimeError( + "adaptive receipt chain failed" + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": diagnostic_depth, + "condition": condition, + "primary_aulc_ppm": ( + result["primary_aulc_ppm"] + ), + "final_window_reward_ppm": ( + result["final_window_reward_ppm"] + ), + "cumulative_regret": ( + result["cumulative_regret"] + ), + "final_representation_depth": ( + result["final_representation_depth"] + ), + "proposed_repairs": ( + result["proposed_repairs"] + ), + "accepted_repairs": ( + result["accepted_repairs"] + ), + "rejected_repairs": ( + result["rejected_repairs"] + ), + "verifier_supported_repairs": ( + result["verifier_supported_repairs"] + ), + "canonical_receipt_count": ( + result["canonical_receipt_count"] + ), + "receipt_chain_valid": ( + result["repair_receipt_chain_valid"] + ), + "adaptation_latencies_episodes": ( + result["adaptation_latencies_episodes"] + ), + "deterministic_run_identity": ( + result["deterministic_run_identity"] + ), + } + ) + + by_condition = {} + + conditions = FIXED_CONDITIONS + ADAPTIVE_CONDITIONS + + for condition in conditions: + subset = [ + row + for row in rows + if row["condition"] == condition + ] + + by_condition[condition] = { + "world_count": len(subset), + "mean_primary_aulc_ppm": mean_floor( + [ + row["primary_aulc_ppm"] + for row in subset + ] + ), + "mean_final_window_reward_ppm": mean_floor( + [ + row["final_window_reward_ppm"] + for row in subset + ] + ), + "mean_cumulative_regret": mean_floor( + [ + row["cumulative_regret"] + for row in subset + ] + ), + "total_accepted_repairs": sum( + row["accepted_repairs"] + for row in subset + ), + "total_rejected_repairs": sum( + row["rejected_repairs"] + for row in subset + ), + "all_receipt_chains_valid": all( + row["receipt_chain_valid"] + for row in subset + ), + } + + def metric_map( + condition: str, + metric: str, + ) -> dict[int, int]: + return { + row["world_seed"]: row[metric] + for row in rows + if row["condition"] == condition + } + + full_primary = metric_map( + "FULL-PRIME", + "primary_aulc_ppm", + ) + fixed_primary = metric_map( + "FIXED-H4", + "primary_aulc_ppm", + ) + ungated_primary = metric_map( + "ADAPTIVE-NO-VERIFIER", + "primary_aulc_ppm", + ) + + full_final = metric_map( + "FULL-PRIME", + "final_window_reward_ppm", + ) + fixed_final = metric_map( + "FIXED-H4", + "final_window_reward_ppm", + ) + + primary_deltas = [ + full_primary[seed] - fixed_primary[seed] + for seed in EVALUATION_SEEDS + ] + + verifier_deltas = [ + full_primary[seed] - ungated_primary[seed] + for seed in EVALUATION_SEEDS + ] + + final_deltas = [ + full_final[seed] - fixed_final[seed] + for seed in EVALUATION_SEEDS + ] + + primary_bootstrap = paired_bootstrap( + primary_deltas + ) + verifier_bootstrap = paired_bootstrap( + verifier_deltas + ) + + primary_mean_positive = ( + sum(primary_deltas) > 0 + ) + + primary_ci_positive = ( + primary_bootstrap["lower_sum_delta"] > 0 + ) + + final_not_degraded = ( + sum(final_deltas) >= 0 + ) + + integrity_pass = ( + all( + summary["all_receipt_chains_valid"] + for summary in by_condition.values() + ) + and git_status_clean() + ) + + primary_supported = all( + ( + primary_mean_positive, + primary_ci_positive, + final_not_degraded, + integrity_pass, + ) + ) + + verifier_specific_supported = ( + sum(verifier_deltas) > 0 + and verifier_bootstrap["lower_sum_delta"] > 0 + ) + + depth_diagnostics = [] + + for depth in (0, 1, 2, 4): + subset = [ + row + for row in rows + if ( + row["condition"] == "FULL-PRIME" + and row["diagnostic_hidden_depth"] == depth + ) + ] + + counts = {} + + for row in subset: + key = str( + row["final_representation_depth"] + ) + counts[key] = counts.get(key, 0) + 1 + + depth_diagnostics.append( + { + "hidden_depth": depth, + "world_count": len(subset), + "final_depth_counts": counts, + "mean_primary_aulc_ppm": mean_floor( + [ + row["primary_aulc_ppm"] + for row in subset + ] + ), + } + ) + + report = { + "benchmark": ( + "prime-canonical-agent-benchmark-v1.1" + ), + "status": "FROZEN_EVALUATION_COMPLETE", + "evaluation_seed_count": len( + EVALUATION_SEEDS + ), + "evaluation_seeds": list( + EVALUATION_SEEDS + ), + "preflight": preflight_record, + "condition_summaries": by_condition, + "primary_comparison_full_vs_fixed_h4": { + "bootstrap": primary_bootstrap, + "mean_delta_positive": ( + primary_mean_positive + ), + "bootstrap_lower_positive": ( + primary_ci_positive + ), + "mean_final_delta_ppm": ( + sum(final_deltas) + // len(final_deltas) + ), + "final_not_degraded": ( + final_not_degraded + ), + "integrity_pass": integrity_pass, + "claim": ( + "SUPPORTED" + if primary_supported + else "NOT SUPPORTED" + ), + }, + "verifier_specific_full_vs_adaptive_no_verifier": { + "bootstrap": verifier_bootstrap, + "claim": ( + "SUPPORTED" + if verifier_specific_supported + else "NOT SUPPORTED" + ), + }, + "full_prime_depth_diagnostics": ( + depth_diagnostics + ), + "rows": rows, + } + + return report + + +def main() -> None: + parser = argparse.ArgumentParser() + + parser.add_argument( + "--unlock", + required=True, + ) + + parser.add_argument( + "--output", + required=True, + ) + + args = parser.parse_args() + + if args.unlock != UNLOCK_PHRASE: + raise SystemExit( + "frozen evaluation remains locked" + ) + + output = Path(args.output).resolve() + + try: + output.relative_to(REPO.resolve()) + except ValueError: + pass + else: + raise SystemExit( + "evaluation output must be outside Git worktree" + ) + + if output.exists(): + raise SystemExit( + f"refusing to overwrite existing output: {output}" + ) + + report = build_report() + + temporary = output.with_name( + output.name + ".partial" + ) + + temporary.write_bytes( + canonical_bytes(report) + ) + + os.replace( + temporary, + output, + ) + + print( + json.dumps( + { + "status": report["status"], + "claim": report[ + "primary_comparison_full_vs_fixed_h4" + ]["claim"], + "output": str(output), + "sha256": sha256_file(output), + }, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/evaluation_tools/frozen_evaluation.sha256 b/experiments/prime_canonical_agent_benchmark_v1_1/evaluation_tools/frozen_evaluation.sha256 new file mode 100644 index 0000000..67cceee --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/evaluation_tools/frozen_evaluation.sha256 @@ -0,0 +1 @@ +f7ca7f3fb90461a211d6f55ff5e48d7b3dc9e578ff6f9261bcd8f42b71cde1a8 frozen_evaluation.py diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/provenance.py b/experiments/prime_canonical_agent_benchmark_v1_1/provenance.py new file mode 100644 index 0000000..74206f9 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/provenance.py @@ -0,0 +1,144 @@ +"""Successor benchmark provenance and frozen-input verification.""" + +import hashlib +from pathlib import Path +import subprocess + + +HERE = Path(__file__).resolve().parent +V1 = HERE.parent / "prime_canonical_agent_benchmark_v1" +REPO = HERE.parent.parent + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _verify_sha_file( + directory: Path, + target_filename: str, + checksum_filename: str, +) -> str: + target = directory / target_filename + checksum_file = directory / checksum_filename + + expected = checksum_file.read_text( + encoding="utf-8" + ).split()[0] + + actual = _sha256(target) + + if actual != expected: + raise RuntimeError( + f"frozen hash mismatch: {target.name}" + ) + + return actual + + +def frozen_identities() -> dict: + return { + "v1_contract_sha256": _verify_sha_file( + V1, + "EXPERIMENT_CONTRACT.md", + "EXPERIMENT_CONTRACT.sha256", + ), + "v1_development_selection_sha256": _verify_sha_file( + V1, + "DEVELOPMENT_BASELINE_SELECTION.json", + "DEVELOPMENT_BASELINE_SELECTION.sha256", + ), + "v1_retirement_sha256": _verify_sha_file( + V1, + "RETIREMENT.md", + "RETIREMENT.sha256", + ), + "v1_1_contract_sha256": _verify_sha_file( + HERE, + "EXPERIMENT_CONTRACT.md", + "EXPERIMENT_CONTRACT.sha256", + ), + "v1_1_lineage_sha256": _verify_sha_file( + HERE, + "LINEAGE.json", + "LINEAGE.sha256", + ), + "v1_1_adaptive_rules_sha256": _verify_sha_file( + HERE, + "ADAPTIVE_RULES.md", + "ADAPTIVE_RULES.sha256", + ), + } + + +def implementation_sha256() -> str: + """Hash executable Python sources from parent apparatus + successor.""" + + digest = hashlib.sha256() + entries: list[tuple[str, Path]] = [] + + for prefix, directory in ( + ("v1", V1), + ("v1_1", HERE), + ): + for path in directory.glob("*.py"): + entries.append( + (f"{prefix}/{path.name}", path) + ) + + for relative, path in sorted(entries): + name = relative.encode("utf-8") + payload = path.read_bytes() + + digest.update( + len(name).to_bytes(8, "big") + ) + digest.update(name) + + digest.update( + len(payload).to_bytes(8, "big") + ) + digest.update(payload) + + return digest.hexdigest() + + +def source_commit() -> str: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "rev-parse", + "HEAD", + ], + check=True, + capture_output=True, + text=True, + ) + + commit = result.stdout.strip() + + if len(commit) != 40: + raise RuntimeError( + "unexpected git commit identity" + ) + + return commit + + +def source_dirty() -> bool: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "status", + "--porcelain", + ], + check=True, + capture_output=True, + text=True, + ) + + return bool(result.stdout.strip()) diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/receipts.py b/experiments/prime_canonical_agent_benchmark_v1_1/receipts.py new file mode 100644 index 0000000..b272f23 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/receipts.py @@ -0,0 +1,78 @@ +"""Deterministic hash-chained adaptive repair receipts.""" + +from copy import deepcopy +import hashlib +import json + + +GENESIS_HASH = "0" * 64 + + +def canonical_bytes(payload: dict) -> bytes: + return ( + json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + +def payload_hash(payload: dict) -> str: + return hashlib.sha256(canonical_bytes(payload)).hexdigest() + + +class ReceiptChain: + def __init__(self) -> None: + self._records: list[dict] = [] + + @property + def records(self) -> list[dict]: + return deepcopy(self._records) + + @property + def tip(self) -> str: + if not self._records: + return GENESIS_HASH + return self._records[-1]["receipt_hash"] + + def append(self, payload: dict) -> dict: + material = deepcopy(payload) + material["sequence"] = len(self._records) + 1 + material["previous_receipt_hash"] = self.tip + + receipt_hash = payload_hash(material) + + record = { + "payload": material, + "receipt_hash": receipt_hash, + } + + self._records.append(record) + return deepcopy(record) + + +def verify_receipt_chain(records: list[dict]) -> bool: + previous = GENESIS_HASH + + for expected_sequence, record in enumerate(records, start=1): + if set(record) != {"payload", "receipt_hash"}: + return False + + payload = record["payload"] + claimed_hash = record["receipt_hash"] + + if not isinstance(payload, dict): + return False + if payload.get("sequence") != expected_sequence: + return False + if payload.get("previous_receipt_hash") != previous: + return False + if payload_hash(payload) != claimed_hash: + return False + + previous = claimed_hash + + return True diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/run_adaptive_development.py b/experiments/prime_canonical_agent_benchmark_v1_1/run_adaptive_development.py new file mode 100644 index 0000000..5a8bf09 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/run_adaptive_development.py @@ -0,0 +1,227 @@ +"""Development-only adaptive diagnostic sweep for benchmark v1.1.""" + +import json + +from experiments.prime_canonical_agent_benchmark_v1.manifest import ( + DEVELOPMENT_SEEDS, +) +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from .adaptive_runner import ( + ADAPTIVE_CONDITIONS, + run_adaptive_condition, +) +from .provenance import ( + frozen_identities, + implementation_sha256, +) + + +def mean_int(values: list[int]) -> int: + return sum(values) // len(values) + + +def main() -> None: + expected = tuple(range(0, 32)) + + if DEVELOPMENT_SEEDS != expected: + raise RuntimeError( + "development seed set differs from frozen 0..31 range" + ) + + rows = [] + + for seed in DEVELOPMENT_SEEDS: + # This categorization is REPORTING ONLY. + # Adaptive agents never receive this value. + hidden_depth_for_diagnostics = (0, 1, 2, 4)[seed % 4] + + fixed_h4 = run_fixed_condition( + seed, + "FIXED-H4", + ).payload + + for condition in ADAPTIVE_CONDITIONS: + result = run_adaptive_condition( + seed, + condition, + ).payload + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": ( + hidden_depth_for_diagnostics + ), + "condition": condition, + "primary_aulc_ppm": ( + result["primary_aulc_ppm"] + ), + "final_window_reward_ppm": ( + result["final_window_reward_ppm"] + ), + "fixed_h4_primary_aulc_ppm": ( + fixed_h4["primary_aulc_ppm"] + ), + "proposed_repairs": ( + result["proposed_repairs"] + ), + "accepted_repairs": ( + result["accepted_repairs"] + ), + "rejected_repairs": ( + result["rejected_repairs"] + ), + "verifier_supported_repairs": ( + result["verifier_supported_repairs"] + ), + "verifier_suppressed_repairs": ( + result["verifier_suppressed_repairs"] + ), + "final_representation_depth": ( + result["final_representation_depth"] + ), + "representation_change_episodes": ( + result["representation_change_episodes"] + ), + "receipt_chain_valid": ( + result["repair_receipt_chain_valid"] + ), + } + ) + + summaries = [] + + for condition in ADAPTIVE_CONDITIONS: + condition_rows = [ + row + for row in rows + if row["condition"] == condition + ] + + summaries.append( + { + "condition": condition, + "mean_primary_aulc_ppm": mean_int( + [ + row["primary_aulc_ppm"] + for row in condition_rows + ] + ), + "mean_final_window_reward_ppm": mean_int( + [ + row["final_window_reward_ppm"] + for row in condition_rows + ] + ), + "total_proposed_repairs": sum( + row["proposed_repairs"] + for row in condition_rows + ), + "total_accepted_repairs": sum( + row["accepted_repairs"] + for row in condition_rows + ), + "total_rejected_repairs": sum( + row["rejected_repairs"] + for row in condition_rows + ), + "all_receipt_chains_valid": all( + row["receipt_chain_valid"] + for row in condition_rows + ), + } + ) + + by_depth = [] + + for depth in (0, 1, 2, 4): + for condition in ADAPTIVE_CONDITIONS: + subset = [ + row + for row in rows + if ( + row["diagnostic_hidden_depth"] == depth + and row["condition"] == condition + ) + ] + + final_depth_counts = {} + + for row in subset: + key = str( + row["final_representation_depth"] + ) + final_depth_counts[key] = ( + final_depth_counts.get(key, 0) + 1 + ) + + by_depth.append( + { + "diagnostic_hidden_depth": depth, + "condition": condition, + "world_count": len(subset), + "mean_primary_aulc_ppm": mean_int( + [ + row["primary_aulc_ppm"] + for row in subset + ] + ), + "mean_final_window_reward_ppm": mean_int( + [ + row["final_window_reward_ppm"] + for row in subset + ] + ), + "final_depth_counts": ( + final_depth_counts + ), + "accepted_repairs": sum( + row["accepted_repairs"] + for row in subset + ), + "rejected_repairs": sum( + row["rejected_repairs"] + for row in subset + ), + "verifier_supported_repairs": sum( + row["verifier_supported_repairs"] + for row in subset + ), + } + ) + + fixed_h4_metrics = [ + run_fixed_condition(seed, "FIXED-H4").payload[ + "primary_aulc_ppm" + ] + for seed in DEVELOPMENT_SEEDS + ] + + report = { + "status": "DEVELOPMENT_ONLY_NOT_EVALUATION", + "evaluation_seeds_run": False, + "frozen_identities": frozen_identities(), + "implementation_sha256": implementation_sha256(), + "development_seed_count": len(DEVELOPMENT_SEEDS), + "fixed_h4_mean_primary_aulc_ppm": mean_int( + fixed_h4_metrics + ), + "condition_summaries": summaries, + "by_hidden_depth_diagnostic": by_depth, + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/test_adaptive.py b/experiments/prime_canonical_agent_benchmark_v1_1/test_adaptive.py new file mode 100644 index 0000000..f786784 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/test_adaptive.py @@ -0,0 +1,195 @@ +"""Development-only invariant tests for adaptive benchmark v1.1.""" + +from copy import deepcopy +import unittest + +from .adaptive_runner import run_adaptive_condition +from .receipts import ReceiptChain, verify_receipt_chain +from .verifier import ProbeEvent, evaluate_candidates + + +def paired_events( + count: int, + *, + informative_depths: tuple[int, ...], +) -> list[ProbeEvent]: + events = [] + + # Each train event is followed by a matching validation event. + for pair_index in range(count // 2): + target = pair_index % 2 + + for _ in range(2): + candidates = {} + + for depth in (1, 2, 4): + if depth in informative_depths: + state = (target,) + (0,) * depth + else: + state = (0,) * (depth + 1) + + candidates[depth] = state + + events.append( + ProbeEvent( + current_state=(0,), + candidate_states=candidates, + target=target, + ) + ) + + return events + + +class VerifierTests(unittest.TestCase): + def test_smallest_supported_candidate_is_recoverable(self): + events = paired_events( + 160, + informative_depths=(1, 2, 4), + ) + + summaries, supported = evaluate_candidates( + current_depth=0, + candidate_depths=(1, 2, 4), + events=events, + ) + + self.assertTrue(supported) + self.assertEqual(min(supported), 1) + + by_depth = { + row["candidate_depth"]: row + for row in summaries + } + + self.assertTrue(by_depth[1]["supported"]) + + def test_complexity_can_reject_large_representation(self): + events = paired_events( + 80, + informative_depths=(4,), + ) + + summaries, supported = evaluate_candidates( + current_depth=0, + candidate_depths=(4,), + events=events, + ) + + row = summaries[0] + + self.assertEqual(row["candidate_depth"], 4) + self.assertFalse(row["supported"]) + self.assertEqual(supported, ()) + self.assertGreaterEqual( + row["complexity_cost"], + row["net_advantage"], + ) + + def test_clear_strong_h4_evidence_can_pass(self): + events = paired_events( + 200, + informative_depths=(4,), + ) + + summaries, supported = evaluate_candidates( + current_depth=0, + candidate_depths=(4,), + events=events, + ) + + self.assertEqual(supported, (4,)) + self.assertTrue(summaries[0]["supported"]) + + +class ReceiptTests(unittest.TestCase): + def test_receipt_chain_detects_tampering(self): + chain = ReceiptChain() + + chain.append( + { + "benchmark_version": "test", + "condition": "FULL-PRIME", + "world_seed": 0, + } + ) + + chain.append( + { + "benchmark_version": "test", + "condition": "FULL-PRIME", + "world_seed": 0, + } + ) + + records = chain.records + self.assertTrue(verify_receipt_chain(records)) + + tampered = deepcopy(records) + tampered[0]["payload"]["world_seed"] = 999 + + self.assertFalse(verify_receipt_chain(tampered)) + + +class AdaptiveRunnerTests(unittest.TestCase): + def test_evaluation_seed_is_blocked_by_default(self): + with self.assertRaises(RuntimeError): + run_adaptive_condition( + 1000, + "FULL-PRIME", + ) + + def test_development_run_is_byte_reproducible(self): + first = run_adaptive_condition( + 1, + "FULL-PRIME", + ) + second = run_adaptive_condition( + 1, + "FULL-PRIME", + ) + + self.assertEqual( + first.canonical_bytes(), + second.canonical_bytes(), + ) + self.assertEqual( + first.sha256(), + second.sha256(), + ) + + def test_result_has_valid_receipt_chain(self): + result = run_adaptive_condition( + 2, + "FULL-PRIME", + ) + + self.assertTrue( + verify_receipt_chain( + result.payload["repair_receipts"] + ) + ) + + def test_no_native_floats(self): + result = run_adaptive_condition( + 3, + "ADAPTIVE-NO-VERIFIER", + ).payload + + def walk(value): + self.assertNotIsInstance(value, float) + + if isinstance(value, dict): + for key, item in value.items(): + self.assertIsInstance(key, str) + walk(item) + + elif isinstance(value, list): + for item in value: + walk(item) + + walk(result) + + +if __name__ == "__main__": + unittest.main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_1/verifier.py b/experiments/prime_canonical_agent_benchmark_v1_1/verifier.py new file mode 100644 index 0000000..4d365ed --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_1/verifier.py @@ -0,0 +1,137 @@ +"""Independent representation verifier for benchmark v1.1.""" + +from dataclasses import dataclass +from math import comb + + +@dataclass(frozen=True) +class ProbeEvent: + current_state: tuple[int, ...] + candidate_states: dict[int, tuple[int, ...]] + target: int + + +def representation_complexity(depth: int) -> int: + return 2 ** (depth + 1) + + +def _fit_predictor( + events: list[ProbeEvent], + depth: int | None, +) -> dict[tuple[int, ...], int]: + counts: dict[tuple[int, ...], list[int]] = {} + + for index, event in enumerate(events): + if index % 2 != 0: + continue + + state = ( + event.current_state + if depth is None + else event.candidate_states[depth] + ) + + bucket = counts.setdefault(state, [0, 0]) + bucket[event.target] += 1 + + predictor: dict[tuple[int, ...], int] = {} + + for state, (count0, count1) in counts.items(): + predictor[state] = 1 if count1 > count0 else 0 + + return predictor + + +def _predict( + predictor: dict[tuple[int, ...], int], + state: tuple[int, ...], +) -> int: + return predictor.get(state, 0) + + +def evaluate_candidates( + *, + current_depth: int, + candidate_depths: tuple[int, ...], + events: list[ProbeEvent], +) -> tuple[list[dict], tuple[int, ...]]: + """Return deterministic evidence summaries and supported candidates.""" + + current_predictor = _fit_predictor(events, None) + summaries: list[dict] = [] + supported: list[int] = [] + + for depth in candidate_depths: + candidate_predictor = _fit_predictor(events, depth) + + wins = 0 + losses = 0 + validation_events = 0 + + for index, event in enumerate(events): + if index % 2 == 0: + continue + + validation_events += 1 + + current_prediction = _predict( + current_predictor, + event.current_state, + ) + candidate_prediction = _predict( + candidate_predictor, + event.candidate_states[depth], + ) + + current_correct = current_prediction == event.target + candidate_correct = candidate_prediction == event.target + + if candidate_correct and not current_correct: + wins += 1 + elif current_correct and not candidate_correct: + losses += 1 + + discordant = wins + losses + + if discordant == 0: + numerator = 1 + denominator = 1 + statistical_pass = False + else: + numerator = sum( + comb(discordant, k) + for k in range(wins, discordant + 1) + ) + denominator = 2 ** discordant + statistical_pass = 64 * numerator <= denominator + + complexity_cost = ( + representation_complexity(depth) + - representation_complexity(current_depth) + ) + + net_advantage = wins - losses + complexity_pass = net_advantage > complexity_cost + passes = statistical_pass and complexity_pass + + if passes: + supported.append(depth) + + summaries.append( + { + "candidate_depth": depth, + "validation_events": validation_events, + "wins": wins, + "losses": losses, + "discordant": discordant, + "sign_test_numerator": numerator, + "sign_test_denominator": denominator, + "statistical_pass": statistical_pass, + "complexity_cost": complexity_cost, + "net_advantage": net_advantage, + "complexity_pass": complexity_pass, + "supported": passes, + } + ) + + return summaries, tuple(sorted(supported)) diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/ADAPTIVE_RULES.md b/experiments/prime_canonical_agent_benchmark_v1_2/ADAPTIVE_RULES.md new file mode 100644 index 0000000..4d89c81 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/ADAPTIVE_RULES.md @@ -0,0 +1,754 @@ +# PRIME Canonical Agent Benchmark v1.2 +## Frozen Sequential Adaptive Repair Rules + +Status: FROZEN BEFORE v1.2 ADAPTIVE IMPLEMENTATION OR ADAPTIVE RESULTS + +These rules define the hypothesis-bearing v1.2 adaptive mechanism. + +They may not be tuned in response to development or evaluation performance. + +A substantive rule change requires a new explicitly linked benchmark version. + +--- + +# 1. Purpose + +v1.1 recovered the exact required representation depth in all 128 held-out +worlds but suffered a substantial online-learning penalty from its fixed +four-episode prospective verifier probe. + +v1.2 tests whether the verifier can retain: + +- independent authority; +- precise representation selection; +- explicit complexity cost; +- deterministic receipts; +- fail-closed canonical mutation; + +while reducing authorization latency through: + +- passive verifier evidence accumulated during normal interaction; +- prequential prediction; +- an anytime-valid sequential evidence process; +- immediate stopping once frozen support requirements are satisfied. + +--- + +# 2. Permitted policy representations + +Permitted representation depths are: + + H0 + H1 + H2 + H4 + +Hd consists of: + + current observation + plus the previous d observations + +The policy begins each run at: + + H0 + +Representation growth is monotone. + +Maximum accepted repairs: + + 3 + +No shrinking is permitted in v1.2. + +--- + +# 3. Policy/verifier separation + +The policy may act only through the currently authorized canonical +representation. + +The verifier is a separate evidence subsystem. + +The verifier may passively maintain bounded information required to construct +candidate representations. + +That information: + +- may not influence policy action selection; +- may not alter policy Q-values; +- may not change canonical representation; +- may not expose hidden dependency depth; +- may not inspect future observations; +- may not access evaluation labels; +- may not authorize its own proposal. + +Candidate evidence is epistemic evidence only. + +It is not policy authority. + +--- + +# 4. Passive observation memory + +The verifier may retain a rolling queue containing at most: + + 5 binary observations + +This is sufficient to construct H0, H1, H2 and H4 states. + +The queue is private to the verifier. + +The policy does not receive this queue unless a corresponding representation +has been canonically authorized. + +Representation histories reset at episode boundaries exactly as in the frozen +environment apparatus. + +Verifier predictive counts may persist across episodes within one canonical +representation epoch. + +--- + +# 5. Canonical representation epoch + +A representation epoch begins: + +- at the start of the run; or +- immediately after an authorized representation repair. + +Each epoch has one fixed current canonical depth. + +At the beginning of a new epoch the verifier clears: + +- obstruction counts; +- candidate predictor counts; +- current-representation verifier predictor counts; +- candidate evidence-process state; +- open proposal state. + +Evidence from a previous canonical representation epoch may not authorize a +later repair. + +--- + +# 6. Target reconstruction + +The action space and reward are binary. + +After each scored action, the verifier may infer the correct historical target: + + target = action + when reward == 1 + + target = 1 - action + when reward == 0 + +This uses only public action/reward feedback. + +The target must not be available before the action and reward occur. + +--- + +# 7. Prequential verifier predictors + +The verifier maintains one deterministic predictor for: + +- the current canonical representation; +- every strictly deeper permitted candidate representation. + +For every representation state, predictor evidence is stored as: + + count(target = 0) + count(target = 1) + +Prediction occurs BEFORE the target for the current event is revealed. + +Prediction rule: + + predict 0 if count0 >= count1 + predict 1 if count1 > count0 + +Therefore: + +- unseen states predict 0; +- exact ties predict 0. + +Only after: + +1. all verifier predictions are frozen for that event; +2. policy action is chosen; +3. reward is received; +4. target is reconstructed; + +may predictor counts be updated. + +This makes the verifier comparison prequential. + +No event may train a predictor before being scored by that predictor. + +--- + +# 8. Current-representation obstruction + +Obstruction detection remains structural. + +For every current canonical representation state s, maintain verified target +counts since the current representation epoch began: + + N(s, 0) + N(s, 1) + +An obstruction exists when at least one current state satisfies: + + N(s, 0) >= 8 + +and: + + N(s, 1) >= 8 + +The obstruction test uses only the current canonical representation. + +Candidate representations do not cause obstruction declaration. + +--- + +# 9. Proposal rule + +At the first obstruction of a canonical representation epoch, propose every +strictly deeper permitted representation. + +Examples: + + H0 -> {H1, H2, H4} + + H1 -> {H2, H4} + + H2 -> {H4} + +Candidate order is increasing representation depth. + +There is at most one proposal event per canonical representation epoch. + +The proposal remains open until: + +- a candidate is authorized; +- the run terminates without support; or +- mutation is deliberately disabled by the relevant ablation. + +Proposal is not authority. + +--- + +# 10. Paired prequential evidence + +For every scored event, before target revelation, the verifier obtains: + + prediction_current + +and: + + prediction_candidate(d) + +for each strictly deeper candidate d. + +After target revelation, candidate d receives a paired evidence update only +when: + + prediction_current != prediction_candidate(d) + +Because the target is binary, exactly one prediction is correct on such an +event. + +Define: + + WIN: + candidate correct + current wrong + + LOSS: + current correct + candidate wrong + +When both representations predict the same target: + + no paired evidence update + +Each candidate maintains cumulative counts: + + W_d + L_d + +from the beginning of the current canonical representation epoch. + +--- + +# 11. Anytime-valid evidence process + +For each candidate d define: + + M_d = + (3 / 2) ** W_d + * + (1 / 2) ** L_d + +Equivalently: + + M_d = + 3 ** W_d + / + 2 ** (W_d + L_d) + +No floating-point representation of M_d is required. + +Under the null that the candidate is not conditionally more likely than the +current representation to win a discordant prediction event, the fixed +one-half betting process is a nonnegative test supermartingale. + +Therefore Ville's inequality permits inspection after every event and stopping +when the threshold is crossed. + +--- + +# 12. Familywise sequential threshold + +Across a monotone run over: + + H0, H1, H2, H4 + +the maximum number of distinct deeper-candidate evidence streams is: + + 3 + 2 + 1 = 6 + +Each individual candidate uses the frozen threshold: + + M_d >= 384 + +which is evaluated exactly as: + + 3 ** W_d + >= + 384 * 2 ** (W_d + L_d) + +For one candidate, Ville's inequality bounds false threshold crossing by: + + 1 / 384 + +Using a union bound across the maximum six candidate streams yields a total +run-level bound of at most: + + 6 / 384 + = + 1 / 64 + +No p-value approximation is used. + +No threshold changes with sample size. + +No repeated-testing correction is added later. + +The anytime-valid threshold is frozen before adaptive results. + +--- + +# 13. Representation complexity + +Representation complexity remains: + + C(d) = 2 ** (d + 1) + +For current depth c and candidate depth d: + + complexity_cost(c, d) + = + C(d) - C(c) + +Candidate d must satisfy: + + W_d - L_d + > + complexity_cost(c, d) + +This is required in addition to the anytime-valid evidence threshold. + +Examples from H0: + + H1 cost: + 4 - 2 = 2 + + H2 cost: + 8 - 2 = 6 + + H4 cost: + 32 - 2 = 30 + +A statistically supported candidate that does not pay its frozen complexity +cost is not authorizable. + +--- + +# 14. Candidate support + +A candidate is verifier-supported only when BOTH are true: + +1. anytime-valid evidence: + + 3 ** W_d + >= + 384 * 2 ** (W_d + L_d) + +2. representation complexity: + + W_d - L_d + > + C(d) - C(current) + +Supported status is monotone only with respect to the current evidence state; +future losses may reduce M before authorization. + +However authorization is evaluated immediately after each complete scored +event. + +Once authorization occurs, the canonical epoch ends and no future event may +retroactively alter that decision. + +--- + +# 15. Sequential authorization + +Before obstruction: + + candidate evidence accumulates passively + +but: + + canonical representation cannot change + +At the event that first creates an obstruction: + +1. proposal candidate set is opened; +2. candidate support is evaluated using all valid prequential evidence + accumulated during the current canonical representation epoch. + +If one or more candidates already satisfy the frozen support rule: + + authorize immediately after the obstruction event + +and before the next policy action. + +If no candidate is supported: + + keep the proposal open + +and after every subsequent scored event: + +1. produce predictions before target; +2. receive target; +3. update paired evidence; +4. update predictor counts; +5. evaluate support. + +The first time support exists: + + authorize the smallest supported candidate depth + +No fixed probe duration is imposed. + +--- + +# 16. Authorization latency + +For every proposal record: + + obstruction_scored_event_index + +and: + + authorization_scored_event_index + +Define additional authorization latency: + + authorization_scored_event_index + - + obstruction_scored_event_index + +Therefore immediate authorization has latency: + + 0 + +Also report: + + paired discordant events already accumulated at obstruction + +and: + + additional paired discordant events after obstruction + +for the ultimately authorized candidate. + +This directly measures how much new evidence the verifier required after the +representation failure became detectable. + +--- + +# 17. Authorization effect + +When FULL-PRIME-V1.2 authorizes candidate depth d: + +- canonical policy representation becomes Hd; +- the mutation becomes effective before the next policy action; +- policy representation history begins under the newly authorized depth; +- canonical epoch evidence is closed; +- a deterministic authorization receipt is appended; +- a new representation epoch begins. + +Candidate-side passive history from the previous epoch may not become hidden +policy memory. + +At an episode boundary, normal representation reset applies. + +If authorization occurs mid-episode, the newly authorized policy +representation may be initialized only from observations legitimately present +in the current authorized policy state plus observations arriving after +authorization. + +The verifier's private deeper rolling queue may NOT be copied into policy +memory. + +This prevents verifier evidence storage from secretly becoming policy memory. + +--- + +# 18. End-of-run unresolved proposal + +If a proposal remains open when the final scored event of the run ends and no +candidate satisfies the frozen rule: + + resolution = VERIFIER_REJECT_END_OF_RUN + +Canonical representation remains unchanged. + +A deterministic rejection receipt is appended. + +The negative evidence is retained. + +--- + +# 19. FULL-PRIME-V1.2 + +FULL-PRIME-V1.2 uses: + +- structural obstruction detection; +- bounded passive candidate evidence; +- prequential prediction; +- anytime-valid paired evidence; +- explicit complexity cost; +- smallest-supported-candidate selection; +- explicit canonical authorization; +- hash-chained receipts. + +Only an authorized candidate changes policy representation. + +--- + +# 20. ADAPTIVE-NO-VERIFIER + +The ungated adaptive condition uses the same: + +- current representation; +- obstruction detector; +- proposal candidate set. + +It does not use verifier support for authority. + +At obstruction it immediately authorizes: + + the smallest strictly deeper proposed representation + +Thus: + + H0 -> H1 + +before: + + H1 -> H2 + +before: + + H2 -> H4 + +when later obstructions occur. + +This condition does not receive the verifier's passive deeper memory as policy +input. + +Its repair decisions remain receipted. + +--- + +# 21. VERIFIER-NO-REPAIR + +VERIFIER-NO-REPAIR uses the identical: + +- current-representation obstruction rule; +- passive verifier evidence; +- prequential predictors; +- sequential e-process; +- complexity rule; +- proposal set; +- smallest-supported selection. + +However canonical representation mutation is disabled. + +When a candidate becomes supported: + + record verifier support + +but: + + canonical policy depth remains unchanged + +The first supported resolution for the epoch is receipted. + +The same current depth is not repeatedly reproposed after that resolution. + +--- + +# 22. No hidden-depth access + +None of the following may access the environment's hidden dependency depth: + +- policy; +- proposal mechanism; +- verifier predictor; +- sequential evidence process; +- authorization logic. + +Hidden depth may be added to reports only after a run for diagnostic grouping. + +--- + +# 23. Determinism + +All adaptive decisions must be deterministic. + +No native JSON floats are permitted in canonical results. + +No wall-clock timestamps are permitted. + +No random UUIDs are permitted. + +No scheduler-dependent ordering is permitted. + +Identical: + + source + configuration + condition + world seed + +must yield byte-identical canonical evidence. + +--- + +# 24. Receipt requirements + +Every resolved proposal receipt contains at least: + +- benchmark version; +- condition; +- world seed; +- sequence number; +- previous receipt hash; +- canonical depth before; +- obstruction episode; +- obstruction scored-event index; +- candidate depths; +- W and L for every candidate at resolution; +- integer evidence-threshold operands; +- complexity costs; +- supported candidate depths; +- selected verifier depth or null; +- authorized depth or null; +- canonical depth after; +- authorization latency; +- resolution type. + +Receipts are: + +- canonical JSON; +- sorted keys; +- compact separators; +- UTF-8; +- newline terminated; +- SHA-256 hash chained. + +Tampering must fail closed. + +--- + +# 25. Evidence-process tamper tests + +The implementation test suite must reject or detect at least: + +- changed W count; +- changed L count; +- changed candidate depth; +- changed complexity cost; +- changed authorization depth; +- changed previous receipt hash; +- changed world seed; +- receipt deletion; +- receipt insertion; +- receipt reordering. + +--- + +# 26. Development seeds + +v1.2 adaptive development may use only: + + 100 through 131 inclusive + +No adaptive-development call may run: + + 2000 through 2127 inclusive + +without the separately frozen evaluation unlock. + +--- + +# 27. Frozen-rule discipline + +The following may not be modified because development results are poor: + +- obstruction threshold 8/8; +- candidate set; +- prequential predictor; +- prediction tie rule; +- one-half e-process bet; +- threshold 384; +- run-level familywise accounting; +- complexity definition; +- complexity inequality; +- smallest-supported rule; +- passive-memory bound; +- evidence reset at representation change. + +If these prove defective rather than merely unsuccessful, v1.2 is retired and +a successor version is created. + +--- + +# 28. Falsification + +A scientifically valid negative v1.2 outcome includes: + +- slower AULC than FIXED-H4; +- slower AULC than ungated adaptation; +- degraded exact-depth recovery; +- false unnecessary repairs; +- excessive sequential waiting; +- no measurable benefit from passive evidence; +- verifier support that arrives too late to matter. + +These outcomes must be retained rather than tuned away. diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/ADAPTIVE_RULES.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/ADAPTIVE_RULES.sha256 new file mode 100644 index 0000000..c1b0b53 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/ADAPTIVE_RULES.sha256 @@ -0,0 +1 @@ +0348e77297037a168499290cb50b8e9d29695e88f5875c4f81b7cc663153b1b5 ADAPTIVE_RULES.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json new file mode 100644 index 0000000..73f39fe --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json @@ -0,0 +1,2564 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.2", + "by_hidden_depth_diagnostic": [ + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 0, + "final_depth_counts": { + "0": 8 + }, + "max_authorization_latency_scored_events": null, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": null, + "mean_final_window_reward_ppm": 947509, + "mean_primary_aulc_ppm": 947505, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 0, + "final_depth_counts": { + "0": 8 + }, + "max_authorization_latency_scored_events": null, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": null, + "mean_final_window_reward_ppm": 947509, + "mean_primary_aulc_ppm": 947505, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME-V1.2", + "diagnostic_hidden_depth": 0, + "final_depth_counts": { + "0": 8 + }, + "max_authorization_latency_scored_events": null, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": null, + "mean_final_window_reward_ppm": 947509, + "mean_primary_aulc_ppm": 947505, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 1, + "final_depth_counts": { + "1": 8 + }, + "max_authorization_latency_scored_events": 0, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": 0, + "mean_final_window_reward_ppm": 953368, + "mean_primary_aulc_ppm": 929784, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 1, + "final_depth_counts": { + "0": 8 + }, + "max_authorization_latency_scored_events": 19, + "mean_additional_discordant_after_obstruction": 2, + "mean_authorization_latency_scored_events": 6, + "mean_final_window_reward_ppm": 491942, + "mean_primary_aulc_ppm": 498799, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.2", + "diagnostic_hidden_depth": 1, + "final_depth_counts": { + "1": 8 + }, + "max_authorization_latency_scored_events": 19, + "mean_additional_discordant_after_obstruction": 2, + "mean_authorization_latency_scored_events": 6, + "mean_final_window_reward_ppm": 953368, + "mean_primary_aulc_ppm": 926309, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 16, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 2, + "final_depth_counts": { + "2": 8 + }, + "max_authorization_latency_scored_events": 0, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": 0, + "mean_final_window_reward_ppm": 948730, + "mean_primary_aulc_ppm": 898051, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 2, + "final_depth_counts": { + "0": 8 + }, + "max_authorization_latency_scored_events": 20, + "mean_additional_discordant_after_obstruction": 2, + "mean_authorization_latency_scored_events": 7, + "mean_final_window_reward_ppm": 507323, + "mean_primary_aulc_ppm": 495505, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.2", + "diagnostic_hidden_depth": 2, + "final_depth_counts": { + "2": 8 + }, + "max_authorization_latency_scored_events": 20, + "mean_additional_discordant_after_obstruction": 2, + "mean_authorization_latency_scored_events": 7, + "mean_final_window_reward_ppm": 948730, + "mean_primary_aulc_ppm": 920249, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 24, + "condition": "ADAPTIVE-NO-VERIFIER", + "diagnostic_hidden_depth": 4, + "final_depth_counts": { + "4": 8 + }, + "max_authorization_latency_scored_events": 0, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": 0, + "mean_final_window_reward_ppm": 949706, + "mean_primary_aulc_ppm": 849967, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "VERIFIER-NO-REPAIR", + "diagnostic_hidden_depth": 4, + "final_depth_counts": { + "0": 8 + }, + "max_authorization_latency_scored_events": 78, + "mean_additional_discordant_after_obstruction": 28, + "mean_authorization_latency_scored_events": 57, + "mean_final_window_reward_ppm": 511718, + "mean_primary_aulc_ppm": 505484, + "rejected_repairs": 0, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.2", + "diagnostic_hidden_depth": 4, + "final_depth_counts": { + "4": 8 + }, + "max_authorization_latency_scored_events": 78, + "mean_additional_discordant_after_obstruction": 28, + "mean_authorization_latency_scored_events": 57, + "mean_final_window_reward_ppm": 949706, + "mean_primary_aulc_ppm": 880253, + "rejected_repairs": 0, + "world_count": 8 + } + ], + "condition_summaries": [ + { + "all_receipt_chains_valid": true, + "condition": "ADAPTIVE-NO-VERIFIER", + "immediate_authorizations": 48, + "max_authorization_latency_scored_events": 0, + "mean_additional_discordant_after_obstruction": null, + "mean_authorization_latency_scored_events": 0, + "mean_cumulative_regret": 249, + "mean_discordant_at_obstruction": null, + "mean_final_window_reward_ppm": 949828, + "mean_primary_aulc_ppm": 906327, + "total_accepted_repairs": 48, + "total_proposed_repairs": 48, + "total_rejected_repairs": 0, + "world_count": 32 + }, + { + "all_receipt_chains_valid": true, + "condition": "VERIFIER-NO-REPAIR", + "immediate_authorizations": 4, + "max_authorization_latency_scored_events": 78, + "mean_additional_discordant_after_obstruction": 11, + "mean_authorization_latency_scored_events": 23, + "mean_cumulative_regret": 1586, + "mean_discordant_at_obstruction": 13, + "mean_final_window_reward_ppm": 614623, + "mean_primary_aulc_ppm": 611823, + "total_accepted_repairs": 0, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0, + "world_count": 32 + }, + { + "all_receipt_chains_valid": true, + "condition": "FULL-PRIME-V1.2", + "immediate_authorizations": 4, + "max_authorization_latency_scored_events": 78, + "mean_additional_discordant_after_obstruction": 11, + "mean_authorization_latency_scored_events": 23, + "mean_cumulative_regret": 234, + "mean_discordant_at_obstruction": 13, + "mean_final_window_reward_ppm": 949828, + "mean_primary_aulc_ppm": 918579, + "total_accepted_repairs": 24, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0, + "world_count": 32 + } + ], + "development_seeds": [ + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131 + ], + "evaluation_seeds_run": false, + "fixed_h4_mean_primary_aulc_ppm": 917666, + "frozen_identities": { + "parent_v1_1_result_sha256": "b58a51857864e61837168dbb5e36ef69d26a600b5775aa2dcc3cb17651962388", + "v1_2_adaptive_rules_sha256": "0348e77297037a168499290cb50b8e9d29695e88f5875c4f81b7cc663153b1b5", + "v1_2_contract_sha256": "558be9ee12a67f19bc5319cc262e7fbc61cb9ef8efb6a03f09ae376afd8f96b4", + "v1_2_fixed_comparator_sha256": "ed37e0dd9321e3ddbd129d987bc9d0ea3ad341326e9b8356dd9b29d941ebcb01", + "v1_2_lineage_sha256": "0a285ca80e99c1c7f8aa2cb38371b2398ab016c52012bd37f3a54e177bf28b8e" + }, + "full_prime_exact_depth_recovery": 32, + "full_prime_exact_depth_total": 32, + "implementation_sha256": "bed64cbe558c928d3793c915e34260638c9c0ed3f7061c350695e769b5c3efc9", + "rows": [ + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 196, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 921601, + "primary_aulc_ppm": 951711, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 100 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 196, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 921601, + "primary_aulc_ppm": 951711, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 100 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 196, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 921601, + "primary_aulc_ppm": 951711, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 100 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 215, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 920934, + "primary_aulc_ppm": 929323, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 101 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 2 + ], + "authorization_latencies_scored_events": [ + 5 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2016, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 517578, + "fixed_h4_primary_aulc_ppm": 920934, + "primary_aulc_ppm": 507429, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 101 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 2 + ], + "authorization_latencies_scored_events": [ + 5 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 219, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 920934, + "primary_aulc_ppm": 924690, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 101 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 252, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 917569, + "primary_aulc_ppm": 893861, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 102 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 3 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2074, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 513671, + "fixed_h4_primary_aulc_ppm": 917569, + "primary_aulc_ppm": 482995, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 102 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 3 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 222, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 917569, + "primary_aulc_ppm": 923845, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 102 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 311, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 935546, + "fixed_h4_primary_aulc_ppm": 917575, + "primary_aulc_ppm": 852845, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 103 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 26 + ], + "authorization_latencies_scored_events": [ + 78 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2040, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 15 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 509765, + "fixed_h4_primary_aulc_ppm": 917575, + "primary_aulc_ppm": 508711, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 103 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 26 + ], + "authorization_latencies_scored_events": [ + 78 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 280, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 15 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 935546, + "fixed_h4_primary_aulc_ppm": 917575, + "primary_aulc_ppm": 880651, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 103 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 218, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 915712, + "primary_aulc_ppm": 945049, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 104 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 218, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 915712, + "primary_aulc_ppm": 945049, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 104 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 218, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 915712, + "primary_aulc_ppm": 945049, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 104 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 918875, + "primary_aulc_ppm": 930576, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 105 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 2 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2111, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 478515, + "fixed_h4_primary_aulc_ppm": 918875, + "primary_aulc_ppm": 494063, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 105 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 2 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 918875, + "primary_aulc_ppm": 929417, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 105 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 260, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 945312, + "fixed_h4_primary_aulc_ppm": 919816, + "primary_aulc_ppm": 890927, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 106 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2061, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 19 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 476562, + "fixed_h4_primary_aulc_ppm": 919816, + "primary_aulc_ppm": 499546, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 106 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 229, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 19 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 945312, + "fixed_h4_primary_aulc_ppm": 919816, + "primary_aulc_ppm": 921337, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 106 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 307, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 918515, + "primary_aulc_ppm": 849687, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 107 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 33 + ], + "authorization_latencies_scored_events": [ + 51 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2062, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 24 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 484375, + "fixed_h4_primary_aulc_ppm": 918515, + "primary_aulc_ppm": 501192, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 107 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 33 + ], + "authorization_latencies_scored_events": [ + 51 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 266, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 24 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 918515, + "primary_aulc_ppm": 879822, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 107 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 213, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 921983, + "primary_aulc_ppm": 952459, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 108 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 213, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 921983, + "primary_aulc_ppm": 952459, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 108 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 213, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 939453, + "fixed_h4_primary_aulc_ppm": 921983, + "primary_aulc_ppm": 952459, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 108 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 218, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 916801, + "primary_aulc_ppm": 930330, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 109 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2034, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 20 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 496093, + "fixed_h4_primary_aulc_ppm": 916801, + "primary_aulc_ppm": 506478, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 109 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 218, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 20 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 916801, + "primary_aulc_ppm": 930330, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 109 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 918309, + "primary_aulc_ppm": 907460, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 110 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2041, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 15 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 507812, + "fixed_h4_primary_aulc_ppm": 918309, + "primary_aulc_ppm": 489492, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 110 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 219, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 15 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 918309, + "primary_aulc_ppm": 924463, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 110 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 331, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 913179, + "primary_aulc_ppm": 844515, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 111 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 31 + ], + "authorization_latencies_scored_events": [ + 47 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2100, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 496093, + "fixed_h4_primary_aulc_ppm": 913179, + "primary_aulc_ppm": 491886, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 111 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 31 + ], + "authorization_latencies_scored_events": [ + 47 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 286, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 958984, + "fixed_h4_primary_aulc_ppm": 913179, + "primary_aulc_ppm": 878587, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 111 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 204, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 941406, + "fixed_h4_primary_aulc_ppm": 916665, + "primary_aulc_ppm": 948299, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 112 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 204, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 941406, + "fixed_h4_primary_aulc_ppm": 916665, + "primary_aulc_ppm": 948299, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 112 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 204, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 941406, + "fixed_h4_primary_aulc_ppm": 916665, + "primary_aulc_ppm": 948299, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 112 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 215, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 964843, + "fixed_h4_primary_aulc_ppm": 921595, + "primary_aulc_ppm": 925411, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 113 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 2 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2067, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 511718, + "fixed_h4_primary_aulc_ppm": 921595, + "primary_aulc_ppm": 480530, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 113 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 2 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 216, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 964843, + "fixed_h4_primary_aulc_ppm": 921595, + "primary_aulc_ppm": 924252, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 113 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 243, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917056, + "primary_aulc_ppm": 904885, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 114 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 7 + ], + "authorization_latencies_scored_events": [ + 17 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2065, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 8 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 525390, + "fixed_h4_primary_aulc_ppm": 917056, + "primary_aulc_ppm": 493053, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 114 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 7 + ], + "authorization_latencies_scored_events": [ + 17 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 227, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 8 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 917056, + "primary_aulc_ppm": 920486, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 114 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 335, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "fixed_h4_primary_aulc_ppm": 914872, + "primary_aulc_ppm": 844862, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 115 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 27 + ], + "authorization_latencies_scored_events": [ + 48 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2012, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 18 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 513671, + "fixed_h4_primary_aulc_ppm": 914872, + "primary_aulc_ppm": 518021, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 115 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 27 + ], + "authorization_latencies_scored_events": [ + 48 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 283, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 18 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "fixed_h4_primary_aulc_ppm": 914872, + "primary_aulc_ppm": 880751, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 115 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 917140, + "primary_aulc_ppm": 945544, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 116 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 917140, + "primary_aulc_ppm": 945544, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 116 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 917140, + "primary_aulc_ppm": 945544, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 116 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 215, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 960937, + "fixed_h4_primary_aulc_ppm": 917110, + "primary_aulc_ppm": 934479, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 117 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 8 + ], + "authorization_latencies_scored_events": [ + 19 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2047, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 7 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 480468, + "fixed_h4_primary_aulc_ppm": 917110, + "primary_aulc_ppm": 494765, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 117 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 8 + ], + "authorization_latencies_scored_events": [ + 19 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 224, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 7 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 960937, + "fixed_h4_primary_aulc_ppm": 917110, + "primary_aulc_ppm": 924056, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 117 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 272, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 914813, + "primary_aulc_ppm": 885739, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 118 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2059, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 16 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 496093, + "fixed_h4_primary_aulc_ppm": 914813, + "primary_aulc_ppm": 486445, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 118 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 0 + ], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 246, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 16 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "fixed_h4_primary_aulc_ppm": 914813, + "primary_aulc_ppm": 911335, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 118 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 297, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 919279, + "primary_aulc_ppm": 863481, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 119 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 31 + ], + "authorization_latencies_scored_events": [ + 64 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2013, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 2 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 523437, + "fixed_h4_primary_aulc_ppm": 919279, + "primary_aulc_ppm": 509634, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 119 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 31 + ], + "authorization_latencies_scored_events": [ + 64 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 267, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 2 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 919279, + "primary_aulc_ppm": 886194, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 119 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 190, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 920079, + "primary_aulc_ppm": 948401, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 120 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 190, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 920079, + "primary_aulc_ppm": 948401, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 120 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 190, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 920079, + "primary_aulc_ppm": 948401, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 120 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 219, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 916318, + "primary_aulc_ppm": 930376, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 121 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 4 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2043, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 496093, + "fixed_h4_primary_aulc_ppm": 916318, + "primary_aulc_ppm": 500087, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 121 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 1 + ], + "authorization_latencies_scored_events": [ + 4 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 14 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 953125, + "fixed_h4_primary_aulc_ppm": 916318, + "primary_aulc_ppm": 929218, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 121 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 263, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 914918, + "primary_aulc_ppm": 899743, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 122 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 2 + ], + "authorization_latencies_scored_events": [ + 6 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2089, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 500000, + "fixed_h4_primary_aulc_ppm": 914918, + "primary_aulc_ppm": 487125, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 122 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 2 + ], + "authorization_latencies_scored_events": [ + 6 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 240, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "fixed_h4_primary_aulc_ppm": 914918, + "primary_aulc_ppm": 921986, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 122 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 311, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 919847, + "primary_aulc_ppm": 853070, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 123 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 22 + ], + "authorization_latencies_scored_events": [ + 61 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2022, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 517578, + "fixed_h4_primary_aulc_ppm": 919847, + "primary_aulc_ppm": 508632, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 123 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 22 + ], + "authorization_latencies_scored_events": [ + 61 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 270, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 919847, + "primary_aulc_ppm": 883104, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 123 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 216, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 911081, + "primary_aulc_ppm": 941394, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 124 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 216, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 911081, + "primary_aulc_ppm": 941394, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 124 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 216, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 911081, + "primary_aulc_ppm": 941394, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 124 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 226, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 941406, + "fixed_h4_primary_aulc_ppm": 917639, + "primary_aulc_ppm": 934887, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 125 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 7 + ], + "authorization_latencies_scored_events": [ + 15 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2111, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 8 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 466796, + "fixed_h4_primary_aulc_ppm": 917639, + "primary_aulc_ppm": 504893, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 125 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 7 + ], + "authorization_latencies_scored_events": [ + 15 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 232, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 8 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 941406, + "fixed_h4_primary_aulc_ppm": 917639, + "primary_aulc_ppm": 927938, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 125 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 250, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 916824, + "primary_aulc_ppm": 892567, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 126 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 4 + ], + "authorization_latencies_scored_events": [ + 10 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 1999, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 11 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 546875, + "fixed_h4_primary_aulc_ppm": 916824, + "primary_aulc_ppm": 507930, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 126 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 4 + ], + "authorization_latencies_scored_events": [ + 10 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 11 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 957031, + "fixed_h4_primary_aulc_ppm": 916824, + "primary_aulc_ppm": 916151, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 126 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 317, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 962890, + "fixed_h4_primary_aulc_ppm": 918278, + "primary_aulc_ppm": 847314, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 127 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 24 + ], + "authorization_latencies_scored_events": [ + 48 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2001, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 9 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 544921, + "fixed_h4_primary_aulc_ppm": 918278, + "primary_aulc_ppm": 497064, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 127 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 24 + ], + "authorization_latencies_scored_events": [ + 48 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 268, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 9 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 962890, + "fixed_h4_primary_aulc_ppm": 918278, + "primary_aulc_ppm": 881103, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 127 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 206, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 918965, + "primary_aulc_ppm": 947187, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 128 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 206, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 918965, + "primary_aulc_ppm": 947187, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 128 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [], + "canonical_receipt_count": 0, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 206, + "diagnostic_hidden_depth": 0, + "discordant_at_obstruction": [], + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "fixed_h4_primary_aulc_ppm": 918965, + "primary_aulc_ppm": 947187, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 128 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0 + ], + "canonical_receipt_count": 1, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 235, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [], + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 914856, + "primary_aulc_ppm": 922891, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 129 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 2 + ], + "authorization_latencies_scored_events": [ + 4 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2043, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 488281, + "fixed_h4_primary_aulc_ppm": 914856, + "primary_aulc_ppm": 502148, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 129 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 2 + ], + "authorization_latencies_scored_events": [ + 4 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "discordant_at_obstruction": [ + 13 + ], + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "fixed_h4_primary_aulc_ppm": 914856, + "primary_aulc_ppm": 920575, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 129 + }, + { + "accepted_repairs": 2, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0 + ], + "canonical_receipt_count": 2, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 239, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [], + "final_representation_depth": 2, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 921661, + "primary_aulc_ppm": 909228, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 130 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 8 + ], + "authorization_latencies_scored_events": [ + 20 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 1993, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 10 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 492187, + "fixed_h4_primary_aulc_ppm": 921661, + "primary_aulc_ppm": 517461, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 130 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 8 + ], + "authorization_latencies_scored_events": [ + 20 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 2, + "discordant_at_obstruction": [ + 10 + ], + "final_representation_depth": 2, + "final_window_reward_ppm": 947265, + "fixed_h4_primary_aulc_ppm": 921661, + "primary_aulc_ppm": 922390, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 130 + }, + { + "accepted_repairs": 3, + "additional_discordant_after_obstruction": [], + "authorization_latencies_scored_events": [ + 0, + 0, + 0 + ], + "canonical_receipt_count": 3, + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 337, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [], + "final_representation_depth": 4, + "final_window_reward_ppm": 935546, + "fixed_h4_primary_aulc_ppm": 915447, + "primary_aulc_ppm": 843963, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "verifier_suppressed_repairs": 0, + "world_seed": 131 + }, + { + "accepted_repairs": 0, + "additional_discordant_after_obstruction": [ + 32 + ], + "authorization_latencies_scored_events": [ + 61 + ], + "canonical_receipt_count": 1, + "condition": "VERIFIER-NO-REPAIR", + "cumulative_regret": 2013, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 17 + ], + "final_representation_depth": 0, + "final_window_reward_ppm": 503906, + "fixed_h4_primary_aulc_ppm": 915447, + "primary_aulc_ppm": 508734, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 1, + "world_seed": 131 + }, + { + "accepted_repairs": 1, + "additional_discordant_after_obstruction": [ + 32 + ], + "authorization_latencies_scored_events": [ + 61 + ], + "canonical_receipt_count": 1, + "condition": "FULL-PRIME-V1.2", + "cumulative_regret": 298, + "diagnostic_hidden_depth": 4, + "discordant_at_obstruction": [ + 17 + ], + "final_representation_depth": 4, + "final_window_reward_ppm": 935546, + "fixed_h4_primary_aulc_ppm": 915447, + "primary_aulc_ppm": 871818, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "verifier_supported_repairs": 1, + "verifier_suppressed_repairs": 0, + "world_seed": 131 + } + ], + "status": "DEVELOPMENT_ONLY_NOT_EVALUATION" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 new file mode 100644 index 0000000..f196835 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 @@ -0,0 +1 @@ +a186cb3a338912500661f78019263d3c810d11686acb2b94d0790bb75b9aa779 DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_FIXED_COMPARATOR.json b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_FIXED_COMPARATOR.json new file mode 100644 index 0000000..adb3e2f --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_FIXED_COMPARATOR.json @@ -0,0 +1,61 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.2", + "development_seeds": [ + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131 + ], + "evaluation_seeds_run": false, + "rows": [ + { + "condition": "FIXED-H1", + "mean_primary_aulc_ppm": 722293, + "representation_depth": 1, + "world_count": 32 + }, + { + "condition": "FIXED-H2", + "mean_primary_aulc_ppm": 830512, + "representation_depth": 2, + "world_count": 32 + }, + { + "condition": "FIXED-H4", + "mean_primary_aulc_ppm": 917666, + "representation_depth": 4, + "world_count": 32 + } + ], + "selected_fixed_baseline": "FIXED-H4", + "selection_rule": "highest mean primary_aulc_ppm; ties select smaller representation", + "status": "DEVELOPMENT_FIXED_COMPARATOR_SELECTION" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_FIXED_COMPARATOR.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_FIXED_COMPARATOR.sha256 new file mode 100644 index 0000000..450d125 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/DEVELOPMENT_FIXED_COMPARATOR.sha256 @@ -0,0 +1 @@ +ed37e0dd9321e3ddbd129d987bc9d0ea3ad341326e9b8356dd9b29d941ebcb01 DEVELOPMENT_FIXED_COMPARATOR.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/EVALUATION_ANALYSIS_PLAN.md b/experiments/prime_canonical_agent_benchmark_v1_2/EVALUATION_ANALYSIS_PLAN.md new file mode 100644 index 0000000..d6ecc7e --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/EVALUATION_ANALYSIS_PLAN.md @@ -0,0 +1,242 @@ +# PRIME Canonical Agent Benchmark v1.2 +## Frozen Held-Out Evaluation Analysis Plan + +Status: FROZEN BEFORE ANY v1.2 EVALUATION SEED IS RUN + +Evaluation seeds: + + 2000 through 2127 inclusive + +Paired worlds: + + 128 + +Development-selected fixed comparator: + + FIXED-H4 + +The development result is not part of the held-out success criterion. + +--- + +# 1. Conditions + +Every held-out world is evaluated under: + + REACTIVE + FIXED-H1 + FIXED-H2 + FIXED-H4 + ADAPTIVE-NO-VERIFIER + VERIFIER-NO-REPAIR + FULL-PRIME-V1.2 + +All 128 worlds are retained. + +--- + +# 2. Primary comparison + +For each world i: + + D_i = + AULC(FULL-PRIME-V1.2, i) + - + AULC(FIXED-H4, i) + +Primary paired mean advantage: + + sum(D_i) / 128 + +The primary mean must be strictly positive. + +--- + +# 3. Deterministic paired bootstrap + +This protocol reuses the v1.1 bootstrap design without modification. + +Bootstrap replicates: + + 16384 + +Paired sample size: + + 128 + +Sampling: + + with replacement + +Generator seed: + + 0x5052494D45563131 + +For replicate r and draw j: + + index = + splitmix64( + BOOTSTRAP_SEED + XOR splitmix64(r) + XOR splitmix64(j) + ) + mod 128 + +Each replicate stores the SUM of 128 sampled paired deltas. + +Sorted zero-based interval indices: + + lower = 409 + upper = 15974 + +The primary confidence criterion is: + + bootstrap_sums[409] > 0 + +No normal approximation or post-evaluation interval choice is allowed. + +--- + +# 4. Final-performance criterion + +For each paired world: + + F_i = + final_window(FULL-PRIME-V1.2, i) + - + final_window(FIXED-H4, i) + +The conservative zero-margin interpretation remains frozen: + + sum(F_i) >= 0 + +No degradation allowance is introduced. + +--- + +# 5. Primary claim + +The preregistered primary claim is SUPPORTED only when all are true: + +1. paired mean AULC delta FULL-PRIME-V1.2 minus FIXED-H4 > 0; +2. deterministic paired-bootstrap lower bound > 0; +3. mean final-window delta >= 0; +4. all frozen-input, receipt, deterministic and source-integrity checks pass. + +Otherwise: + + NOT SUPPORTED + +--- + +# 6. Verifier-specific comparison + +For every world: + + V_i = + AULC(FULL-PRIME-V1.2, i) + - + AULC(ADAPTIVE-NO-VERIFIER, i) + +Use the identical 16384-replicate paired bootstrap. + +Verifier-specific performance is SUPPORTED only when: + + sum(V_i) > 0 + +and: + + bootstrap lower bound > 0 + +and integrity checks pass. + +Otherwise: + + NOT SUPPORTED + +--- + +# 7. Structural diagnostics + +Report for FULL-PRIME-V1.2: + +- final representation depth; +- exact required-depth recovery; +- accepted repair count; +- rejected repair count; +- proposal count; +- verifier-supported repair count; +- canonical receipt count; +- receipt-chain validity. + +The hidden dependency depth may be used only after execution for diagnostic +grouping. + +It is never available to policy, proposal or verifier logic. + +Exact-depth recovery is not substituted for the primary AULC criterion. + +--- + +# 8. Authorization-latency diagnostics + +For resolved FULL-PRIME-V1.2 repairs report: + +- authorization latency in scored events; +- maximum authorization latency; +- immediate-authorization count; +- discordant evidence already accumulated at obstruction; +- additional discordant evidence required after obstruction; +- breakdown by hidden dependency depth. + +Historical v1.1 reference: + + fixed prospective evidence duration: + 4 complete episodes + + equivalent prospective scored evidence events: + 256 + +This historical quantity is descriptive only because v1.1 and v1.2 use +different held-out worlds. + +No inferential cross-version latency claim is preregistered. + +--- + +# 9. Integrity + +Before evaluation: + +- Git worktree must be clean; +- frozen v1.2 hashes must verify; +- frozen v1.1 parent result hash must verify; +- selected comparator must remain FIXED-H4; +- core v1.2 implementation SHA-256 must equal: + + bed64cbe558c928d3793c915e34260638c9c0ed3f7061c350695e769b5c3efc9 + +During evaluation: + +- every adaptive result must report source_dirty=false; +- every adaptive result must report the frozen implementation hash; +- every receipt chain must verify against its count and tip anchors; +- every condition must produce exactly 128 worlds. + +Evaluation output must be written outside the Git worktree. + +--- + +# 10. Claim boundary + +Even a positive result is controlled mechanistic benchmark evidence. + +It is not evidence of: + +- AGI; +- universal POMDP superiority; +- universal superiority over recurrent learned memory; +- production security; +- broad real-world generality. + +The frozen learned-memory-baseline boundary remains in force. diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/EVALUATION_ANALYSIS_PLAN.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/EVALUATION_ANALYSIS_PLAN.sha256 new file mode 100644 index 0000000..627d760 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/EVALUATION_ANALYSIS_PLAN.sha256 @@ -0,0 +1 @@ +4e68ebcf250dd826fc46299815e8becbf1025d52a7c237f7726b8ad6851c7031 EVALUATION_ANALYSIS_PLAN.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/EXPERIMENT_CONTRACT.md b/experiments/prime_canonical_agent_benchmark_v1_2/EXPERIMENT_CONTRACT.md new file mode 100644 index 0000000..4c73998 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/EXPERIMENT_CONTRACT.md @@ -0,0 +1,363 @@ +# PRIME Canonical Agent Benchmark v1.2 +## Frozen Experimental Contract + +Status: FROZEN BEFORE v1.2 IMPLEMENTATION OR v1.2 RESULT INSPECTION + +v1.2 is a successor experiment to the completed v1.1 benchmark. + +v1.1 remains immutable. + +--- + +# 1. Parent result + +PRIME Canonical Agent Benchmark v1.1 produced: + + preregistered primary claim: + NOT SUPPORTED + + exact final representation recovery: + 128 / 128 + + FULL-PRIME mean AULC: + 852920 ppm + + FIXED-H4 mean AULC: + 918420 ppm + + ADAPTIVE-NO-VERIFIER mean AULC: + 905346 ppm + + FULL-PRIME minus FIXED-H4: + -65501 ppm + + frozen 95% bootstrap interval: + [-74816, -55695] ppm + + FULL-PRIME minus ADAPTIVE-NO-VERIFIER: + -52427 ppm + +The v1.1 evidence therefore indicates that representation selection succeeded +while verifier latency reduced online learning efficiency. + +--- + +# 2. v1.2 research question + +Can verifier sovereignty and precise representation repair be retained while +reducing evidence-acquisition and authorization latency enough to improve +online learning efficiency? + +The intended architectural change is not a weaker verifier. + +The intended change is to eliminate unnecessary waiting by allowing the +independent verifier to reuse bounded evidence that naturally arises during +ordinary agent interaction. + +--- + +# 3. Reused frozen substrate + +v1.2 reuses the v1.1 task family and common learning apparatus: + + MemoryAlias-POMDP + binary observation/action interface + permitted representation depths {0, 1, 2, 4} + deterministic SplitMix64 generators + common BinaryTabularLearner + 64 episodes + 64 scored decisions per episode + 4 warmup observations per episode + deterministic exploration period 10 + integer-only canonical metrics + +The environment semantics are not modified to make v1.2 easier. + +--- + +# 4. Fresh development and evaluation worlds + +v1.1 evaluation seeds are permanently burned and may not be reused as +held-out v1.2 evidence. + +v1.2 development seeds: + + 100 through 131 inclusive + +Count: + + 32 + +v1.2 frozen evaluation seeds: + + 2000 through 2127 inclusive + +Count: + + 128 + +All four hidden dependency depths are balanced in both sets. + +The evaluation seeds may not be inspected until the v1.2 implementation, +adaptive rules, statistical analysis plan, and evaluation harness are frozen. + +--- + +# 5. Conditions + +v1.2 must evaluate at least: + + REACTIVE + FIXED-H1 + FIXED-H2 + FIXED-H4 + ADAPTIVE-NO-VERIFIER + VERIFIER-NO-REPAIR + FULL-PRIME-V1.2 + +The common learner must remain the same wherever technically applicable. + +Representation management remains the experimental independent variable. + +--- + +# 6. Representation authority + +FULL-PRIME-V1.2 begins with policy representation: + + H0 + +The policy may act only through the currently authorized canonical +representation. + +A deeper candidate representation may never control policy before +authorization. + +Proposal is not authority. + +Verifier support is not canonical mutation. + +Only an explicit authorization event may change the policy representation. + +--- + +# 7. v1.2 evidence principle + +The verifier may maintain bounded, passive candidate-side evidence derived +from observations and action/reward feedback that the system legitimately +receives during ordinary interaction. + +Such passive evidence: + +- may not influence policy action selection; +- may not expose hidden environment depth; +- may not mutate canonical policy representation; +- may not receive future observations; +- may not access evaluation labels; +- must remain deterministic and provenance-bound. + +This is intended to distinguish: + + policy representation capacity + +from: + + verifier evidence collection + +The adaptive rules governing this evidence are frozen separately before +implementation. + +--- + +# 8. Sequential authorization principle + +v1.2 may replace the fixed four-complete-episode prospective verification delay +used in v1.1 with a deterministic sequential evidence rule. + +The verifier must authorize only when the frozen evidence criterion is +satisfied. + +It may stop collecting evidence as soon as support is sufficient. + +Failure to obtain sufficient support must leave canonical representation +unchanged. + +No threshold may be tuned after adaptive development results are observed. + +--- + +# 9. Development comparator selection + +FIXED-H1, FIXED-H2 and FIXED-H4 are run on every v1.2 development seed. + +The fixed comparator is the condition with greatest mean primary AULC. + +Ties select the smaller representation. + +This selection is frozen before v1.2 evaluation. + +--- + +# 10. Primary metric + +Primary metric: + + area under the online learning curve + +represented canonically in integer ppm. + +The exact calculation remains the same as v1.1. + +Every evaluation world is retained. + +--- + +# 11. Primary v1.2 performance claim + +The primary claim is supported only if FULL-PRIME-V1.2 has: + +1. positive paired mean primary-AULC advantage over the development-selected + fixed representation; + +2. a preregistered paired-bootstrap 95% lower bound strictly greater than zero; + +3. no degradation in mean final-window reward under the frozen conservative + zero-margin interpretation; + +4. all integrity and deterministic replay checks passing. + +A negative result is retained. + +--- + +# 12. Verifier-specific claim + +FULL-PRIME-V1.2 is separately compared with ADAPTIVE-NO-VERIFIER. + +Verifier-governed adaptation has a positive performance contribution only if: + + mean paired AULC delta > 0 + +and the frozen paired-bootstrap 95% lower bound is: + + > 0 + +Failure is reported explicitly. + +--- + +# 13. Mechanistic representation-repair result + +v1.2 reports: + +- final representation depth; +- hidden-depth diagnostic after execution; +- exact-depth recovery rate; +- proposal count; +- accepted repair count; +- rejected repair count; +- verifier-supported repair count; +- authorization latency; +- canonical receipt count; +- receipt-chain integrity. + +Exact-depth recovery is not substituted for the primary AULC criterion. + +--- + +# 14. Latency result + +v1.2 must explicitly compare representation authorization latency with v1.1. + +The benchmark should distinguish: + + evidence already available at obstruction + +from: + + additional evidence required after obstruction + +and report both where applicable. + +The purpose is to test whether v1.1's observed performance deficit can be +localized to evidence-acquisition latency. + +--- + +# 15. Determinism and receipts + +All authoritative v1.2 adaptive decisions must remain: + +- deterministic; +- canonical; +- hash-chained; +- provenance-bound; +- replayable; +- fail-closed; +- free of timestamps and random UUIDs; +- free of native JSON floats. + +Receipt tampering must be detected. + +--- + +# 16. Development restriction + +Development seeds may be used to: + +- debug implementation defects; +- verify invariants; +- confirm implementation matches frozen rules; +- select the frozen fixed-history comparator. + +They may not be used to tune the frozen verifier rule after adaptive +performance is observed. + +A substantive rule change requires a successor version. + +--- + +# 17. Evaluation restriction + +Seeds 2000 through 2127 must remain inaccessible to ordinary development +execution. + +Evaluation requires an explicit frozen-evaluation unlock path. + +Before that unlock: + +- adaptive rules must be frozen; +- implementation must be committed; +- tests must pass; +- worktree must be clean; +- implementation hash must be frozen; +- evaluation-analysis plan must be frozen; +- evaluation harness must be frozen. + +--- + +# 18. Learned-memory baseline boundary + +v1.2 remains a controlled mechanistic benchmark unless a learned-memory +baseline such as a recurrent model is added under a separately frozen protocol. + +A positive v1.2 result alone must not be generalized into universal superiority +over learned recurrent agents. + +--- + +# 19. Falsification + +The experiment is successful scientifically even if the performance hypothesis +fails. + +In particular, retain and report outcomes where: + +- verifier latency remains too expensive; +- ungated adaptation remains superior; +- fixed H4 remains superior; +- sequential evidence increases false repair; +- exact-depth recovery degrades; +- added verifier state produces no measurable benefit. + +No mechanism is protected from falsification. diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/EXPERIMENT_CONTRACT.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/EXPERIMENT_CONTRACT.sha256 new file mode 100644 index 0000000..0cd36e0 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/EXPERIMENT_CONTRACT.sha256 @@ -0,0 +1 @@ +558be9ee12a67f19bc5319cc262e7fbc61cb9ef8efb6a03f09ae376afd8f96b4 EXPERIMENT_CONTRACT.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/FROZEN_EVALUATION_RESULT.json b/experiments/prime_canonical_agent_benchmark_v1_2/FROZEN_EVALUATION_RESULT.json new file mode 100644 index 0000000..7b5148d --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/FROZEN_EVALUATION_RESULT.json @@ -0,0 +1 @@ +{"benchmark":"prime-canonical-agent-benchmark-v1.2","condition_summaries":{"ADAPTIVE-NO-VERIFIER":{"all_receipt_chains_valid":true,"mean_cumulative_regret":250,"mean_final_window_reward_ppm":949233,"mean_primary_aulc_ppm":905651,"total_accepted_repairs":192,"total_proposed_repairs":192,"total_rejected_repairs":0,"world_count":128},"FIXED-H1":{"all_receipt_chains_valid":true,"mean_cumulative_regret":1129,"mean_final_window_reward_ppm":725570,"mean_primary_aulc_ppm":722486,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"world_count":128},"FIXED-H2":{"all_receipt_chains_valid":true,"mean_cumulative_regret":671,"mean_final_window_reward_ppm":835738,"mean_primary_aulc_ppm":831241,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"world_count":128},"FIXED-H4":{"all_receipt_chains_valid":true,"mean_cumulative_regret":234,"mean_final_window_reward_ppm":949233,"mean_primary_aulc_ppm":918084,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"world_count":128},"FULL-PRIME-V1.2":{"all_receipt_chains_valid":true,"mean_cumulative_regret":234,"mean_final_window_reward_ppm":949233,"mean_primary_aulc_ppm":918754,"total_accepted_repairs":96,"total_proposed_repairs":96,"total_rejected_repairs":0,"world_count":128},"REACTIVE":{"all_receipt_chains_valid":true,"mean_cumulative_regret":1589,"mean_final_window_reward_ppm":612411,"mean_primary_aulc_ppm":611477,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"world_count":128},"VERIFIER-NO-REPAIR":{"all_receipt_chains_valid":true,"mean_cumulative_regret":1589,"mean_final_window_reward_ppm":612411,"mean_primary_aulc_ppm":611477,"total_accepted_repairs":0,"total_proposed_repairs":96,"total_rejected_repairs":0,"world_count":128}},"evaluation_seed_count":128,"evaluation_seeds":[2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047,2048,2049,2050,2051,2052,2053,2054,2055,2056,2057,2058,2059,2060,2061,2062,2063,2064,2065,2066,2067,2068,2069,2070,2071,2072,2073,2074,2075,2076,2077,2078,2079,2080,2081,2082,2083,2084,2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097,2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,2110,2111,2112,2113,2114,2115,2116,2117,2118,2119,2120,2121,2122,2123,2124,2125,2126,2127],"full_prime_depth_diagnostics":[{"final_depth_counts":{"0":32},"hidden_depth":0,"max_authorization_latency_scored_events":null,"mean_additional_discordant_after_obstruction":null,"mean_authorization_latency_scored_events":null,"mean_primary_aulc_ppm":948187,"world_count":32},{"final_depth_counts":{"1":32},"hidden_depth":1,"max_authorization_latency_scored_events":13,"mean_additional_discordant_after_obstruction":1,"mean_authorization_latency_scored_events":2,"mean_primary_aulc_ppm":927407,"world_count":32},{"final_depth_counts":{"2":32},"hidden_depth":2,"max_authorization_latency_scored_events":22,"mean_additional_discordant_after_obstruction":3,"mean_authorization_latency_scored_events":8,"mean_primary_aulc_ppm":920440,"world_count":32},{"final_depth_counts":{"4":32},"hidden_depth":4,"max_authorization_latency_scored_events":100,"mean_additional_discordant_after_obstruction":29,"mean_authorization_latency_scored_events":64,"mean_primary_aulc_ppm":878982,"world_count":32}],"full_prime_exact_depth_recovery":128,"full_prime_exact_depth_total":128,"full_prime_latency":{"accepted_repairs":96,"immediate_authorizations":24,"max_authorization_latency_scored_events":100,"mean_additional_discordant_after_obstruction":11,"mean_authorization_latency_scored_events":25,"mean_discordant_at_obstruction":13,"v1_1_historical_fixed_prospective_scored_events":256},"preflight":{"analysis_plan_sha256":"4e68ebcf250dd826fc46299815e8becbf1025d52a7c237f7726b8ad6851c7031","core_implementation_sha256":"bed64cbe558c928d3793c915e34260638c9c0ed3f7061c350695e769b5c3efc9","evaluation_harness_sha256":"84793d28f7bc62051af7472b22a99cfd77315219c0940166958d87bdfb0a1da4","frozen_identities":{"parent_v1_1_result_sha256":"b58a51857864e61837168dbb5e36ef69d26a600b5775aa2dcc3cb17651962388","v1_2_adaptive_rules_sha256":"0348e77297037a168499290cb50b8e9d29695e88f5875c4f81b7cc663153b1b5","v1_2_contract_sha256":"558be9ee12a67f19bc5319cc262e7fbc61cb9ef8efb6a03f09ae376afd8f96b4","v1_2_fixed_comparator_sha256":"ed37e0dd9321e3ddbd129d987bc9d0ea3ad341326e9b8356dd9b29d941ebcb01","v1_2_lineage_sha256":"0a285ca80e99c1c7f8aa2cb38371b2398ab016c52012bd37f3a54e177bf28b8e"},"selected_fixed_comparator":"FIXED-H4","source_commit":"96c719622951e64fd2c6e3aea911e49927385ccb"},"primary_full_vs_fixed_h4":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":-3644,"lower_sum_delta":-466345,"observed_mean_delta_ppm":669,"observed_sum_delta":85754,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":4983,"upper_sum_delta":637911},"bootstrap_lower_positive":false,"claim":"NOT SUPPORTED","final_not_degraded":true,"integrity_pass":true,"mean_delta_positive":true,"mean_final_delta_ppm":0},"rows":[{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":962890,"primary_aulc_ppm":948727,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":962890,"primary_aulc_ppm":947569,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":942936,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":917581,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":962890,"primary_aulc_ppm":948727,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":962890,"primary_aulc_ppm":948727,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":962890,"primary_aulc_ppm":948727,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2000},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2076,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":483250,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2001},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":942583,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2001},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":939108,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2001},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":915419,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2001},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":922894,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2001},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[4],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2076,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":483250,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2001},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[4],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":239,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[13],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":920577,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2001},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2085,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":492603,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2002},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2128,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":494140,"primary_aulc_ppm":480997,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2002},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":942699,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2002},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":917100,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2002},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":258,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":897658,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2002},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[12],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2085,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":492603,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2002},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[12],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":232,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":923254,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2002},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2009,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":512256,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2003},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2011,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":510527,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2003},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2047,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":507812,"primary_aulc_ppm":497346,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2003},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":917193,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2003},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":319,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":843499,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2003},{"accepted_repairs":0,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[69],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2009,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":512256,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2003},{"accepted_repairs":1,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[69],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":280,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[15],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":869763,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2003},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944949,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":943791,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":939158,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":915387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944949,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944949,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":944949,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2004},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2015,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":508674,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2005},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":229,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":943011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2005},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":232,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":939537,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2005},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":253,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":917901,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2005},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":241,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":929113,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2005},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2015,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":508674,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2005},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":241,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":929113,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2005},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2038,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":499946,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2006},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2042,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":486328,"primary_aulc_ppm":502825,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2006},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":941436,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2006},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":919067,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2006},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":250,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":900051,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2006},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[14],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2038,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":499946,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2006},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[14],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":231,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":918272,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2006},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1994,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":507426,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2007},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2025,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":529296,"primary_aulc_ppm":485526,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2007},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2054,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":527343,"primary_aulc_ppm":482160,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2007},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":915944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2007},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":318,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":841413,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2007},{"accepted_repairs":0,"additional_discordant_after_obstruction":[20],"authorization_latencies_scored_events":[50],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1994,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[19],"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":507426,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2007},{"accepted_repairs":1,"additional_discordant_after_obstruction":[20],"authorization_latencies_scored_events":[50],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":272,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[19],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":878100,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2007},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":192,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":952676,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":194,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":950359,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":198,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":945727,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921530,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":192,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":952676,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":192,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":952676,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":192,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":952676,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2008},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2042,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":500758,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2009},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":204,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":946627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2009},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":941994,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2009},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":917269,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2009},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":925780,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2009},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2042,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":500758,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2009},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":925780,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2009},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2096,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":501264,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2010},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2018,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":500097,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2010},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":216,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":942689,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2010},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":919109,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2010},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":257,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":900819,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2010},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2096,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":501264,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2010},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":229,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[15],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":927877,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2010},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2087,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":449218,"primary_aulc_ppm":496479,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2011},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2040,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":508189,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2011},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2013,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":511718,"primary_aulc_ppm":513588,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2011},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":914859,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2011},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":335,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":844089,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2011},{"accepted_repairs":0,"additional_discordant_after_obstruction":[24],"authorization_latencies_scored_events":[57],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2087,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":449218,"primary_aulc_ppm":496479,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2011},{"accepted_repairs":1,"additional_discordant_after_obstruction":[24],"authorization_latencies_scored_events":[57],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":297,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[15],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":869825,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2011},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948579,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":206,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":947421,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":210,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942788,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":919587,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948579,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948579,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948579,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2012},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2027,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":513233,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2013},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":207,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":964843,"primary_aulc_ppm":944800,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2013},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":964843,"primary_aulc_ppm":940167,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2013},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":917007,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2013},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":964843,"primary_aulc_ppm":929744,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2013},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2027,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[18],"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":513233,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2013},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[18],"final_representation_depth":1,"final_window_reward_ppm":964843,"primary_aulc_ppm":929744,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2013},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2034,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":500305,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2014},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2041,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":521484,"primary_aulc_ppm":506682,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2014},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":218,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":941820,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2014},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":919148,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2014},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":263,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":896172,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2014},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2034,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":500305,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2014},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":235,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":922131,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2014},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2008,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":516291,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2015},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2018,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":502213,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2015},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":1985,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":531250,"primary_aulc_ppm":514909,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2015},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":216,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":922427,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2015},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":304,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":850838,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2015},{"accepted_repairs":0,"additional_discordant_after_obstruction":[26],"authorization_latencies_scored_events":[63],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2008,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[5],"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":516291,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2015},{"accepted_repairs":1,"additional_discordant_after_obstruction":[26],"authorization_latencies_scored_events":[63],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":259,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[5],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":884181,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2015},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":966796,"primary_aulc_ppm":950496,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":966796,"primary_aulc_ppm":948179,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":206,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":966796,"primary_aulc_ppm":943547,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":919128,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":966796,"primary_aulc_ppm":950496,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":966796,"primary_aulc_ppm":950496,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":966796,"primary_aulc_ppm":950496,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2016},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2071,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":495814,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2017},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":209,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":944956,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2017},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":941481,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2017},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":915150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2017},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":924109,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2017},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2071,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":495814,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2017},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":227,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":924109,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2017},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1995,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":503684,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2018},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1972,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":513910,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2018},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":194,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":947023,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2018},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":218,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":921994,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2018},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":234,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":904603,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2018},{"accepted_repairs":0,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[6],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1995,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[18],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":503684,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2018},{"accepted_repairs":1,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[6],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":215,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[18],"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":922702,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2018},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2117,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":470703,"primary_aulc_ppm":493533,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2019},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2086,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":482865,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2019},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2061,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":496093,"primary_aulc_ppm":503878,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2019},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":920588,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2019},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":323,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":845029,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2019},{"accepted_repairs":0,"additional_discordant_after_obstruction":[33],"authorization_latencies_scored_events":[56],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2117,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[24],"final_representation_depth":0,"final_window_reward_ppm":470703,"primary_aulc_ppm":493533,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2019},{"accepted_repairs":1,"additional_discordant_after_obstruction":[33],"authorization_latencies_scored_events":[56],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":276,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[24],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":880087,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2019},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":944185,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":939552,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":247,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":915293,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2020},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2079,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":489691,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2021},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":944090,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2021},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940615,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2021},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":915686,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2021},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":929033,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2021},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2079,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":489691,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2021},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":929033,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2021},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2072,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":506042,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2022},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2045,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":517578,"primary_aulc_ppm":505459,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2022},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":943235,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2022},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918062,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2022},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":245,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":904959,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2022},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2072,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":506042,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2022},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":224,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":926106,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2022},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2073,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":498206,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2023},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2103,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":492243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2023},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2072,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":525390,"primary_aulc_ppm":501151,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2023},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":914710,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2023},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":315,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":843188,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2023},{"accepted_repairs":0,"additional_discordant_after_obstruction":[39],"authorization_latencies_scored_events":[72],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2073,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[6],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":498206,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2023},{"accepted_repairs":1,"additional_discordant_after_obstruction":[39],"authorization_latencies_scored_events":[72],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":270,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[6],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":880304,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2023},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949479,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":214,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":947163,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":218,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":942530,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":916931,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949479,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949479,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949479,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2024},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2101,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":493057,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2025},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":946199,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2025},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":941566,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2025},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918155,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2025},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":230,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932301,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2025},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2101,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":493057,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2025},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":230,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932301,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2025},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2040,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":497803,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2026},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2065,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":527343,"primary_aulc_ppm":491846,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2026},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":941842,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2026},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":917705,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2026},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":254,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":899666,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2026},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2040,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":497803,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2026},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":231,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":922397,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2026},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2066,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":488754,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2027},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2118,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":472309,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2027},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2106,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":474609,"primary_aulc_ppm":485451,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2027},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":915851,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2027},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":319,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":854589,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2027},{"accepted_repairs":0,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[56],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2066,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[20],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":488754,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2027},{"accepted_repairs":1,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[56],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":286,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[20],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":878905,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2027},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":226,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944742,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":228,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":942426,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":232,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":937793,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":255,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":913231,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":226,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944742,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":226,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944742,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":226,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944742,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2028},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2044,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":464843,"primary_aulc_ppm":505833,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2029},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":944954,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2029},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":940321,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2029},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":248,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":914478,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2029},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":236,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":926423,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2029},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2044,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":464843,"primary_aulc_ppm":505833,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2029},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":236,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":926423,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2029},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2089,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":499648,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2030},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2075,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":496110,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2030},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":939879,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2030},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":919401,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2030},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":257,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":900144,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2030},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[7],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2089,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":499648,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2030},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[7],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":234,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[12],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":920679,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2030},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2023,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":499366,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2031},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2051,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":504057,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2031},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2054,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":478515,"primary_aulc_ppm":499379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2031},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":922537,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2031},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":331,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":839911,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2031},{"accepted_repairs":0,"additional_discordant_after_obstruction":[34],"authorization_latencies_scored_events":[67],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2023,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":499366,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2031},{"accepted_repairs":1,"additional_discordant_after_obstruction":[34],"authorization_latencies_scored_events":[67],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":280,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[11],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":875655,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2031},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":216,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946638,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":944321,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":940847,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":920369,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946638,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":216,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946638,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":216,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946638,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2032},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2122,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":462890,"primary_aulc_ppm":480384,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2033},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":943182,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2033},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":939707,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2033},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":244,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":913254,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2033},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":230,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":928125,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2033},{"accepted_repairs":0,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[5],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2122,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":462890,"primary_aulc_ppm":480384,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2033},{"accepted_repairs":1,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[12],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":926967,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2033},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2038,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":498519,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2034},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2054,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":535156,"primary_aulc_ppm":494106,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2034},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":194,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":948198,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2034},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":217,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":923513,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2034},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":903523,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2034},{"accepted_repairs":0,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[8],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2038,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":498519,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2034},{"accepted_repairs":1,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[8],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":215,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":924121,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2034},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2117,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":487889,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2035},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2086,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":490234,"primary_aulc_ppm":490694,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2035},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2041,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":498046,"primary_aulc_ppm":497805,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2035},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":915428,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2035},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":329,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":843830,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2035},{"accepted_repairs":0,"additional_discordant_after_obstruction":[27],"authorization_latencies_scored_events":[58],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2117,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[4],"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":487889,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2035},{"accepted_repairs":1,"additional_discordant_after_obstruction":[27],"authorization_latencies_scored_events":[58],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":283,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[4],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":879437,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2035},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946499,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":213,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":945341,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":940708,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":916349,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946499,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946499,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":946499,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2036},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2044,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":490106,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2037},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":202,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":949111,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2037},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":945637,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2037},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":227,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":922558,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2037},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":937530,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2037},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[11],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2044,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[9],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":490106,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2037},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[11],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":217,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[9],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":931739,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2037},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2074,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":493375,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2038},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2043,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":521484,"primary_aulc_ppm":502589,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2038},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":203,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":941505,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2038},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":224,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":918770,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2038},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":236,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":906947,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2038},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[21],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2074,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":493375,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2038},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[21],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":916513,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2038},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2032,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":501187,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2039},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2002,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":508501,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2039},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2034,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":513671,"primary_aulc_ppm":500050,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2039},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916068,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2039},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":330,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":838964,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2039},{"accepted_repairs":0,"additional_discordant_after_obstruction":[37],"authorization_latencies_scored_events":[65],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2032,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":501187,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2039},{"accepted_repairs":1,"additional_discordant_after_obstruction":[37],"authorization_latencies_scored_events":[65],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":283,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":873298,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2039},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947732,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":210,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":945416,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":940783,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":916220,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947732,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947732,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947732,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2040},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2090,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":489264,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2041},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":215,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":947102,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2041},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":942469,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2041},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":918332,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2041},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":235,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":923938,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2041},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2090,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":489264,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2041},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":235,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":923938,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2041},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2066,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":495873,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2042},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2098,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":478515,"primary_aulc_ppm":488823,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2042},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":216,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":938631,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2042},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":915408,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2042},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":267,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":885179,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2042},{"accepted_repairs":0,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[1],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2066,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":495873,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2042},{"accepted_repairs":1,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[1],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":233,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[17],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":919186,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2042},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2087,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":464843,"primary_aulc_ppm":487902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2043},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2079,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":468750,"primary_aulc_ppm":496781,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2043},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2053,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":484375,"primary_aulc_ppm":500461,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2043},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917182,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2043},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":322,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":847444,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2043},{"accepted_repairs":0,"additional_discordant_after_obstruction":[27],"authorization_latencies_scored_events":[60],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2087,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":464843,"primary_aulc_ppm":487902,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2043},{"accepted_repairs":1,"additional_discordant_after_obstruction":[27],"authorization_latencies_scored_events":[60],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":280,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":878306,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2043},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":946779,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":942146,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":917950,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":949095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2044},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2083,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":477759,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2045},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":942977,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2045},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":938344,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2045},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":913781,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2045},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":235,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":923288,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2045},{"accepted_repairs":0,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[1],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2083,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[14],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":477759,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2045},{"accepted_repairs":1,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[1],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":235,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[14],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":923288,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2045},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2096,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":476637,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2046},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2084,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":483373,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2046},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":938402,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2046},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":915627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2046},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":263,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":885376,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2046},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2096,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":476637,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2046},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":234,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":914080,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2046},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2006,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":502990,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2047},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":529296,"primary_aulc_ppm":496307,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2047},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":1994,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":533203,"primary_aulc_ppm":497970,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2047},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":919028,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2047},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":302,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":856419,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2047},{"accepted_repairs":0,"additional_discordant_after_obstruction":[26],"authorization_latencies_scored_events":[62],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2006,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":502990,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2047},{"accepted_repairs":1,"additional_discordant_after_obstruction":[26],"authorization_latencies_scored_events":[62],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":264,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[13],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":884031,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2047},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950856,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":948539,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":943907,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":922271,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950856,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950856,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":950856,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2048},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2057,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":491443,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2049},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":219,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":946876,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2049},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":942488,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2049},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":247,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":916156,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2049},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":235,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":928345,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2049},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2057,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":491443,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2049},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":235,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":928345,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2049},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2047,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":505552,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2050},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2061,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":507812,"primary_aulc_ppm":500884,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2050},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":943863,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2050},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":919911,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2050},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":247,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":902600,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2050},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[12],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2047,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[9],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":505552,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2050},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[12],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":229,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[9],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":919786,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2050},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":501909,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2051},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2035,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":519531,"primary_aulc_ppm":494564,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2051},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2068,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":455078,"primary_aulc_ppm":495322,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2051},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":914775,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2051},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":320,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":845661,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2051},{"accepted_repairs":0,"additional_discordant_after_obstruction":[24],"authorization_latencies_scored_events":[60],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":501909,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2051},{"accepted_repairs":1,"additional_discordant_after_obstruction":[24],"authorization_latencies_scored_events":[60],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":276,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[11],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":877280,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2051},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":188,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":952944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":190,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":950628,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":194,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":945995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":217,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":921188,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":188,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":952944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":188,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":952944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":188,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":952944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2052},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2047,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":515625,"primary_aulc_ppm":494878,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2053},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":195,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":951296,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2053},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":199,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":946663,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2053},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":921247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2053},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":211,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932765,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2053},{"accepted_repairs":0,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[5],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2047,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":515625,"primary_aulc_ppm":494878,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2053},{"accepted_repairs":1,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":213,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[12],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":930448,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2053},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2056,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":509472,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2054},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2064,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":501881,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2054},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":941724,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2054},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":249,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":915941,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2054},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":266,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":898815,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2054},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[10],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2056,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":509472,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2054},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[10],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":247,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":917891,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2054},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2040,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":499817,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2055},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2065,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":490638,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2055},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2076,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":468750,"primary_aulc_ppm":503669,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2055},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":915798,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2055},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":329,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":836838,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2055},{"accepted_repairs":0,"additional_discordant_after_obstruction":[29],"authorization_latencies_scored_events":[58],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2040,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":499817,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2055},{"accepted_repairs":1,"additional_discordant_after_obstruction":[29],"authorization_latencies_scored_events":[58],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":274,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":879643,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2055},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945194,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":942877,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939403,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":247,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":914596,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945194,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945194,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945194,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2056},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2012,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":546875,"primary_aulc_ppm":504422,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2057},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":214,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":942740,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2057},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":216,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940423,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2057},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917019,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2057},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":228,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926525,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2057},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2012,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":546875,"primary_aulc_ppm":504422,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2057},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":228,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926525,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2057},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2024,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":500858,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2058},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2032,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":499335,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2058},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":946127,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2058},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":921768,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2058},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":252,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":900964,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2058},{"accepted_repairs":0,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[1],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2024,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":500858,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2058},{"accepted_repairs":1,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[1],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[17],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":926682,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2058},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2022,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":519041,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2059},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2045,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":515524,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2059},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2042,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":490234,"primary_aulc_ppm":518691,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2059},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":924270,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2059},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":316,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":848796,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2059},{"accepted_repairs":0,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[91],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2022,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[6],"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":519041,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2059},{"accepted_repairs":1,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[91],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":270,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[6],"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":885405,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2059},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":195,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952351,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":196,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":951193,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":946560,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":921387,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":195,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952351,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":195,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952351,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":195,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":952351,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2060},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2097,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":473773,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2061},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":216,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":943597,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2061},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":938964,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2061},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":241,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":915985,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2061},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":232,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":925066,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2061},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2097,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":473773,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2061},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":232,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":925066,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2061},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1983,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":512996,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2062},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":1994,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":529296,"primary_aulc_ppm":506466,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2062},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":942348,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2062},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918455,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2062},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":260,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":894687,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2062},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1983,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":512996,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2062},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":232,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":921745,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2062},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2059,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":494207,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2063},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2010,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":494140,"primary_aulc_ppm":515969,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2063},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2069,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":449218,"primary_aulc_ppm":506263,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2063},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":245,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":915636,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2063},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":307,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":862140,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2063},{"accepted_repairs":0,"additional_discordant_after_obstruction":[42],"authorization_latencies_scored_events":[100],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2059,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[9],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":494207,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2063},{"accepted_repairs":1,"additional_discordant_after_obstruction":[42],"authorization_latencies_scored_events":[100],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":305,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[9],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":861364,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2063},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":215,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945014,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":942698,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":938065,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916266,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":215,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945014,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":215,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945014,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":215,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945014,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2064},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2042,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":510154,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2065},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":204,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":946165,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2065},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942690,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2065},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":919345,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2065},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":218,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":929950,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2065},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2042,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":510154,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2065},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":218,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":929950,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2065},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2071,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":541015,"primary_aulc_ppm":482661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2066},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2076,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":541015,"primary_aulc_ppm":487155,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2066},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":202,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":943385,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2066},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918578,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2066},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":250,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":892431,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2066},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2071,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[18],"final_representation_depth":0,"final_window_reward_ppm":541015,"primary_aulc_ppm":482661,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2066},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":219,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[18],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":923696,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2066},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2095,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":481856,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2067},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2082,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":492187,"primary_aulc_ppm":494041,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2067},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2040,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":472656,"primary_aulc_ppm":512795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2067},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":917429,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2067},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":314,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":851589,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2067},{"accepted_repairs":0,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[66],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2095,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":481856,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2067},{"accepted_repairs":1,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[66],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":280,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[13],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":875017,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2067},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":933593,"primary_aulc_ppm":940407,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":230,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":933593,"primary_aulc_ppm":939249,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":234,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":933593,"primary_aulc_ppm":934616,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":257,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":933593,"primary_aulc_ppm":909158,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":933593,"primary_aulc_ppm":940407,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":933593,"primary_aulc_ppm":940407,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":933593,"primary_aulc_ppm":940407,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2068},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2074,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":497202,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2069},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":205,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":946177,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2069},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":941544,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2069},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918261,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2069},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":927646,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2069},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[5],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2074,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":497202,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2069},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[5],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[13],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":925329,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2069},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2005,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":502515,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2070},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2028,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":468750,"primary_aulc_ppm":505890,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2070},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":182,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":946190,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2070},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":205,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":922603,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2070},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":900539,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2070},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2005,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":502515,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2070},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":201,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":924673,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2070},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2072,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":501194,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2071},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2059,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":486328,"primary_aulc_ppm":491978,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2071},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2061,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":478515,"primary_aulc_ppm":491326,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2071},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":221,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":918670,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2071},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":317,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":839602,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2071},{"accepted_repairs":0,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[44],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2072,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":501194,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2071},{"accepted_repairs":1,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[44],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":262,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":880788,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2071},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":193,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947004,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":194,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":945846,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":197,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":942372,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":915918,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":193,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947004,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":193,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947004,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":193,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947004,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2072},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2060,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":491779,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2073},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":211,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":966796,"primary_aulc_ppm":943937,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2073},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":966796,"primary_aulc_ppm":939305,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2073},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":966796,"primary_aulc_ppm":914701,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2073},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":230,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":966796,"primary_aulc_ppm":921932,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2073},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2060,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":491779,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2073},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":230,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[15],"final_representation_depth":1,"final_window_reward_ppm":966796,"primary_aulc_ppm":921932,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2073},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2035,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":511899,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2074},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2046,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":523437,"primary_aulc_ppm":500057,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2074},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942597,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2074},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918401,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2074},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":908709,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2074},{"accepted_repairs":0,"additional_discordant_after_obstruction":[8],"authorization_latencies_scored_events":[14],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2035,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[10],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":511899,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2074},{"accepted_repairs":1,"additional_discordant_after_obstruction":[8],"authorization_latencies_scored_events":[14],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[10],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":919678,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2074},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2047,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":458984,"primary_aulc_ppm":505172,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2075},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2077,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":464843,"primary_aulc_ppm":492690,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2075},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2094,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":460937,"primary_aulc_ppm":483447,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2075},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":920096,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2075},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":321,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":851633,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2075},{"accepted_repairs":0,"additional_discordant_after_obstruction":[27],"authorization_latencies_scored_events":[56],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2047,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[4],"final_representation_depth":0,"final_window_reward_ppm":458984,"primary_aulc_ppm":505172,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2075},{"accepted_repairs":1,"additional_discordant_after_obstruction":[27],"authorization_latencies_scored_events":[56],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":276,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[4],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":887679,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2075},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":214,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":945311,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":218,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940678,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":921603,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2076},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2065,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":490944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2077},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":211,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":946356,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2077},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":941723,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2077},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918441,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2077},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":224,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":931300,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2077},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[13],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2065,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[9],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":490944,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2077},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[13],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":228,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[9],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":926667,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2077},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2022,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":505630,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2078},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2022,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":504193,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2078},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":202,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":944889,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2078},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":920022,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2078},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":254,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":889791,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2078},{"accepted_repairs":0,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[9],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2022,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":505630,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2078},{"accepted_repairs":1,"additional_discordant_after_obstruction":[3],"authorization_latencies_scored_events":[9],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[15],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":917337,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2078},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2038,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":458984,"primary_aulc_ppm":511606,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2079},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2044,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":517822,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2079},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2067,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":486328,"primary_aulc_ppm":504270,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2079},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":921389,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2079},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":305,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":854983,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2079},{"accepted_repairs":0,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[65],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2038,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":458984,"primary_aulc_ppm":511606,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2079},{"accepted_repairs":1,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[65],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":263,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":886110,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2079},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":191,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":952088,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":193,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":949772,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":197,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":945139,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":218,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":922241,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":191,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":952088,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":191,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":952088,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":191,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":952088,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2080},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1988,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":507846,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2081},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":195,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":945984,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2081},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":199,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":941351,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2081},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":219,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":920629,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2081},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":205,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":934402,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2081},{"accepted_repairs":0,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[10],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1988,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[10],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":507846,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2081},{"accepted_repairs":1,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[10],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":210,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[10],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":928611,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2081},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2023,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":507493,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2082},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2039,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":523437,"primary_aulc_ppm":489559,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2082},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":203,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":942297,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2082},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":919137,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2082},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":243,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":900487,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2082},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[13],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2023,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":507493,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2082},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[13],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":222,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":920780,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2082},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2123,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":475588,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2083},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2060,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":505536,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2083},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2071,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":464843,"primary_aulc_ppm":503726,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2083},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":919661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2083},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":321,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":848618,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2083},{"accepted_repairs":0,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[57],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2123,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":475588,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2083},{"accepted_repairs":1,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[57],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":286,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":872939,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2083},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":205,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":943019,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939545,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917846,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":945336,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2084},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2117,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":482852,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2085},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":215,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":942602,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2085},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":219,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":937970,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2085},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":916515,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2085},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":225,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":931021,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2085},{"accepted_repairs":0,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2117,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[14],"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":482852,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2085},{"accepted_repairs":1,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":226,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[14],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":929862,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2085},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2082,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":492597,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2086},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2035,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":498911,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2086},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940101,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2086},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":917551,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2086},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":902739,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2086},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[17],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2082,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":492597,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2086},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[17],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":241,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":909319,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2086},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2021,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":500437,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2087},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2010,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":509168,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2087},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":523437,"primary_aulc_ppm":498310,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2087},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":915527,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2087},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":321,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":850459,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2087},{"accepted_repairs":0,"additional_discordant_after_obstruction":[29],"authorization_latencies_scored_events":[55],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2021,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[14],"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":500437,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2087},{"accepted_repairs":1,"additional_discordant_after_obstruction":[29],"authorization_latencies_scored_events":[55],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":278,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[14],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":880131,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2087},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":948523,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":206,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":946207,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":210,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":941574,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":916980,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":948523,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":948523,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":948523,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2088},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2043,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":505774,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2089},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":212,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":944150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2089},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":216,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939518,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2089},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917537,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2089},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":932569,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2089},{"accepted_repairs":0,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[13],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2043,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[10],"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":505774,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2089},{"accepted_repairs":1,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[13],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":227,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[10],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":926778,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2089},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2090,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":483631,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2090},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2052,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":496093,"primary_aulc_ppm":486394,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2090},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":941516,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2090},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":920794,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2090},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":898914,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2090},{"accepted_repairs":0,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[18],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2090,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[8],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":483631,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2090},{"accepted_repairs":1,"additional_discordant_after_obstruction":[7],"authorization_latencies_scored_events":[18],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":234,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[8],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":911648,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2090},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2007,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":542968,"primary_aulc_ppm":512269,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2091},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2026,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":542968,"primary_aulc_ppm":505180,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2091},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2094,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":474609,"primary_aulc_ppm":486048,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2091},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":252,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":913397,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2091},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":328,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":853623,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2091},{"accepted_repairs":0,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[62],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2007,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[1],"final_representation_depth":0,"final_window_reward_ppm":542968,"primary_aulc_ppm":512269,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2091},{"accepted_repairs":1,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[62],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":291,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[1],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":879377,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2091},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":197,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":953347,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":198,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":952189,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":947556,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":224,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":923541,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":197,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":953347,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":197,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":953347,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":197,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":953347,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2092},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2052,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":489440,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2093},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":212,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":945563,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2093},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":215,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":942088,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2093},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":920086,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2093},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":932823,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2093},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[4],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2052,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":489440,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2093},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[4],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":225,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[13],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":930506,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2093},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2079,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":499343,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2094},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2084,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":497558,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2094},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":229,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":936536,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2094},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":251,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":913010,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2094},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":271,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":893020,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2094},{"accepted_repairs":0,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[18],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2079,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":499343,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2094},{"accepted_repairs":1,"additional_discordant_after_obstruction":[5],"authorization_latencies_scored_events":[18],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":248,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":914775,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2094},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1994,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":515625,"primary_aulc_ppm":505287,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2095},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2069,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":497483,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2095},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2005,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":507812,"primary_aulc_ppm":511575,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2095},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":915745,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2095},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":348,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":817545,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2095},{"accepted_repairs":0,"additional_discordant_after_obstruction":[33],"authorization_latencies_scored_events":[52],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1994,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":515625,"primary_aulc_ppm":505287,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2095},{"accepted_repairs":1,"additional_discordant_after_obstruction":[33],"authorization_latencies_scored_events":[52],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":269,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[16],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":876645,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2095},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":198,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":949937,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":200,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":947621,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":943232,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":920458,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":198,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":949937,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":198,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":949937,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":198,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":949937,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2096},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2063,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":495662,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2097},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":217,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":943977,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2097},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":939344,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2097},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":916731,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2097},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":233,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":925446,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2097},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2063,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":495662,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2097},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":233,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[17],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":925446,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2097},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2083,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":477533,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2098},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2104,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":472927,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2098},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":936641,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2098},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":248,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":911833,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2098},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":274,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":885017,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2098},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[4],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2083,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":477533,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2098},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[4],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":249,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[16],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":909088,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2098},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2020,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":504447,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2099},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2019,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":501848,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2099},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2069,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":484375,"primary_aulc_ppm":492946,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2099},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":917694,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2099},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":322,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":851277,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2099},{"accepted_repairs":0,"additional_discordant_after_obstruction":[38],"authorization_latencies_scored_events":[78],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2020,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":504447,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2099},{"accepted_repairs":1,"additional_discordant_after_obstruction":[38],"authorization_latencies_scored_events":[78],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":284,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[15],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":879187,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2099},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":949943,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":948785,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":944152,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":919101,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":949943,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":949943,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":949943,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2100},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2050,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":521484,"primary_aulc_ppm":484686,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2101},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":183,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":952666,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2101},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":187,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":948033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2101},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":209,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":924506,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2101},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":924869,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2101},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2050,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":521484,"primary_aulc_ppm":484686,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2101},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":207,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":924869,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2101},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2055,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":499968,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2102},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2037,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":501631,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2102},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":204,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":944104,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2102},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":920333,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2102},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":248,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":897539,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2102},{"accepted_repairs":0,"additional_discordant_after_obstruction":[4],"authorization_latencies_scored_events":[10],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2055,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":499968,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2102},{"accepted_repairs":1,"additional_discordant_after_obstruction":[4],"authorization_latencies_scored_events":[10],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":224,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":920941,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2102},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2008,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":506075,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2103},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":507812,"primary_aulc_ppm":506260,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2103},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2022,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":513671,"primary_aulc_ppm":492999,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2103},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":916702,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2103},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":330,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":839692,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2103},{"accepted_repairs":0,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[64],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2008,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":506075,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2103},{"accepted_repairs":1,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[64],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":279,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[12],"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":876223,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2103},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949498,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":947182,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":943707,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":228,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":922356,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949498,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949498,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":949498,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2104},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2049,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":509422,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2105},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":219,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":942935,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2105},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":939461,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2105},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":917560,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2105},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":929037,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2105},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2049,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":509422,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2105},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":231,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":929037,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2105},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2013,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":511098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2106},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2018,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":492187,"primary_aulc_ppm":506975,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2106},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":941552,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2106},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":916157,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2106},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":251,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":896696,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2106},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2013,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":511098,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2106},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":920279,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2106},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2040,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":504633,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2107},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2017,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":539062,"primary_aulc_ppm":508752,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2107},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2004,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":525390,"primary_aulc_ppm":502166,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2107},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":222,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":921596,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2107},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":321,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":839822,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2107},{"accepted_repairs":0,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[61],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2040,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[19],"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":504633,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2107},{"accepted_repairs":1,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[61],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":266,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[19],"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":882232,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2107},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":950750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":204,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":948433,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":208,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":943801,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":920722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":950750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":950750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":202,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":950750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2108},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2071,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":475792,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2109},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":194,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":951400,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2109},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":198,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":946767,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2109},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":220,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":922630,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2109},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":213,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":929395,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2109},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2071,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":475792,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2109},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":213,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":929395,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2109},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2037,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":501353,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2110},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2075,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":476562,"primary_aulc_ppm":493497,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2110},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":203,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":944001,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2110},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":920433,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2110},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":245,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":899874,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2110},{"accepted_repairs":0,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2037,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":501353,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2110},{"accepted_repairs":1,"additional_discordant_after_obstruction":[2],"authorization_latencies_scored_events":[3],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":222,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[13],"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":922239,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2110},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2096,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":504589,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2111},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":462890,"primary_aulc_ppm":520220,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2111},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2067,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":513671,"primary_aulc_ppm":497433,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2111},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":919421,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2111},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":318,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":858294,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2111},{"accepted_repairs":0,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[82],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2096,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[14],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":504589,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2111},{"accepted_repairs":1,"additional_discordant_after_obstruction":[31],"authorization_latencies_scored_events":[82],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":278,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[14],"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":886197,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2111},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":940449,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":214,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":938132,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":218,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":933500,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":910887,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":940449,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":940449,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":212,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":940449,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2112},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2033,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":508322,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2113},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":946400,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2113},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":227,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":941767,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2113},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":251,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":917022,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2113},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":930185,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2113},{"accepted_repairs":0,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2033,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[14],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":508322,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2113},{"accepted_repairs":1,"additional_discordant_after_obstruction":[1],"authorization_latencies_scored_events":[2],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":238,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[14],"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":929027,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2113},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2007,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":511933,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2114},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2017,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":531250,"primary_aulc_ppm":504774,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2114},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":229,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":934757,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2114},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":253,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":910256,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2114},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":264,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":898127,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2114},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[18],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2007,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[12],"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":511933,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2114},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[18],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":247,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[12],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":914398,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2114},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":505508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2115},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2051,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":490234,"primary_aulc_ppm":495125,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2115},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2077,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":468750,"primary_aulc_ppm":498362,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2115},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":915998,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2115},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":330,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":848936,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2115},{"accepted_repairs":0,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[80],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2028,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[5],"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":505508,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2115},{"accepted_repairs":1,"additional_discordant_after_obstruction":[30],"authorization_latencies_scored_events":[80],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":291,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[5],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":876604,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2115},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947461,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":209,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":945145,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940512,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":918022,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947461,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947461,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":947461,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2116},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":1999,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":512599,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2117},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":206,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":946268,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2117},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":210,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":941635,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2117},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918597,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2117},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":926579,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2117},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":1999,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":533203,"primary_aulc_ppm":512599,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2117},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":223,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":926579,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2117},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2031,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":522996,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2118},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2033,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":458984,"primary_aulc_ppm":520728,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2118},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":193,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":950753,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2118},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":216,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":927899,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2118},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":915951,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2118},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[22],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2031,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[9],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":522996,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2118},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[22],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":211,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[9],"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":930394,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2118},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2010,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":514141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2119},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2089,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":484862,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2119},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2125,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":503906,"primary_aulc_ppm":470001,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2119},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":916129,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2119},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":332,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":842373,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2119},{"accepted_repairs":0,"additional_discordant_after_obstruction":[28],"authorization_latencies_scored_events":[66],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2010,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[17],"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":514141,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2119},{"accepted_repairs":1,"additional_discordant_after_obstruction":[28],"authorization_latencies_scored_events":[66],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":278,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[17],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":883580,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2119},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":947016,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":221,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":944700,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":941225,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":918024,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":947016,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":947016,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":219,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":947016,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2120},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2014,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":522024,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2121},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":195,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":947292,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2121},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":199,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":942659,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2121},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":222,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":919073,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2121},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":204,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":936868,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2121},{"accepted_repairs":0,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[9],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2014,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[9],"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":522024,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2121},{"accepted_repairs":1,"additional_discordant_after_obstruction":[6],"authorization_latencies_scored_events":[9],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":210,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[9],"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":929919,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2121},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2057,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":511757,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2122},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2086,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":478515,"primary_aulc_ppm":501622,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2122},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":943346,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2122},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":920430,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2122},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":905803,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2122},{"accepted_repairs":0,"additional_discordant_after_obstruction":[4],"authorization_latencies_scored_events":[9],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2057,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":511757,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2122},{"accepted_repairs":1,"additional_discordant_after_obstruction":[4],"authorization_latencies_scored_events":[9],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[11],"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":928290,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2122},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2012,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":531250,"primary_aulc_ppm":510433,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2123},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2035,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":531250,"primary_aulc_ppm":498871,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2123},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2014,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":500000,"primary_aulc_ppm":502043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2123},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":915001,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2123},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":297,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":861226,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2123},{"accepted_repairs":0,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[77],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2012,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":531250,"primary_aulc_ppm":510433,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2123},{"accepted_repairs":1,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[77],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":271,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[16],"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":880902,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2123},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950146,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":203,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":947829,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":943197,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":919670,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950146,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950146,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FULL-PRIME-V1.2","cumulative_regret":201,"diagnostic_hidden_depth":0,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":950146,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2124},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2052,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":494383,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2125},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":210,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":947095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2125},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":942463,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2125},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":918956,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2125},{"accepted_repairs":1,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":225,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":929723,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2125},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2052,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":494383,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2125},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":225,"diagnostic_hidden_depth":1,"discordant_at_obstruction":[16],"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":929723,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2125},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2035,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":499006,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2126},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2082,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":486328,"primary_aulc_ppm":488622,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2126},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":940502,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2126},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":918500,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2126},{"accepted_repairs":2,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0],"canonical_receipt_count":2,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":240,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":903384,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2126},{"accepted_repairs":0,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2035,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[15],"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":499006,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2126},{"accepted_repairs":1,"additional_discordant_after_obstruction":[0],"authorization_latencies_scored_events":[0],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":220,"diagnostic_hidden_depth":2,"discordant_at_obstruction":[15],"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":923130,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2126},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"REACTIVE","cumulative_regret":2084,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":489383,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2127},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H1","cumulative_regret":2022,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":1,"final_window_reward_ppm":529296,"primary_aulc_ppm":504218,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2127},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H2","cumulative_regret":2017,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":2,"final_window_reward_ppm":509765,"primary_aulc_ppm":513714,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2127},{"accepted_repairs":0,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[],"canonical_receipt_count":0,"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":919369,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2127},{"accepted_repairs":3,"additional_discordant_after_obstruction":[],"authorization_latencies_scored_events":[0,0,0],"canonical_receipt_count":3,"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":322,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":839152,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":0,"world_seed":2127},{"accepted_repairs":0,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[70],"canonical_receipt_count":1,"condition":"VERIFIER-NO-REPAIR","cumulative_regret":2084,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[16],"final_representation_depth":0,"final_window_reward_ppm":476562,"primary_aulc_ppm":489383,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2127},{"accepted_repairs":1,"additional_discordant_after_obstruction":[25],"authorization_latencies_scored_events":[70],"canonical_receipt_count":1,"condition":"FULL-PRIME-V1.2","cumulative_regret":262,"diagnostic_hidden_depth":4,"discordant_at_obstruction":[16],"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":888254,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"verifier_supported_repairs":1,"world_seed":2127}],"status":"FROZEN_EVALUATION_COMPLETE","verifier_specific_full_vs_ungated":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":10414,"lower_sum_delta":1333109,"observed_mean_delta_ppm":13102,"observed_sum_delta":1677182,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":15817,"upper_sum_delta":2024691},"claim":"SUPPORTED","integrity_pass":true}} diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/FROZEN_EVALUATION_RESULT.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/FROZEN_EVALUATION_RESULT.sha256 new file mode 100644 index 0000000..f7b06d1 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/FROZEN_EVALUATION_RESULT.sha256 @@ -0,0 +1 @@ +6ce64dc7aa0bcc44ce1453788162a007ea79429d0283e69d6ba4e8c9e91028f0 FROZEN_EVALUATION_RESULT.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/HELD_OUT_RESULT.md b/experiments/prime_canonical_agent_benchmark_v1_2/HELD_OUT_RESULT.md new file mode 100644 index 0000000..06ee497 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/HELD_OUT_RESULT.md @@ -0,0 +1,253 @@ +# PRIME Canonical Agent Benchmark v1.2 +## Frozen Held-Out Evaluation Result + +Status: + + COMPLETE + +Evaluation protocol commit: + + 96c719622951e64fd2c6e3aea911e49927385ccb + +Frozen hypothesis-bearing implementation SHA-256: + + bed64cbe558c928d3793c915e34260638c9c0ed3f7061c350695e769b5c3efc9 + +Evaluation result SHA-256: + + 6ce64dc7aa0bcc44ce1453788162a007ea79429d0283e69d6ba4e8c9e91028f + +Evaluation worlds: + + 128 + +Evaluation seeds: + + 2000 through 2127 inclusive + +All integrity checks passed. + +--- + +# Preregistered primary result + + NOT SUPPORTED + +Mean primary AULC: + + REACTIVE 611477 + FIXED-H1 722486 + FIXED-H2 831241 + FIXED-H4 918084 + ADAPTIVE-NO-VERIFIER 905651 + VERIFIER-NO-REPAIR 611477 + FULL-PRIME-V1.2 918754 + +Paired FULL-PRIME-v1.2 minus FIXED-H4: + + observed mean delta: + +669 ppm + + frozen deterministic bootstrap 95% interval: + [-3644, +4983] ppm + +The paired mean was positive, but the frozen lower confidence bound was not +strictly greater than zero. + +Therefore the preregistered primary superiority claim is: + + NOT SUPPORTED + +--- + +# Final-window performance + +Mean final-window reward: + + FIXED-H4 949233 + ADAPTIVE-NO-VERIFIER 949233 + FULL-PRIME-V1.2 949233 + +FULL-PRIME-v1.2 therefore showed no final-window degradation. + +Mean cumulative regret: + + FIXED-H4 234 + ADAPTIVE-NO-VERIFIER 250 + FULL-PRIME-V1.2 234 + +--- + +# Verifier-specific held-out result + +FULL-PRIME-v1.2 minus ADAPTIVE-NO-VERIFIER: + + observed mean paired AULC delta: + +13102 ppm + + frozen deterministic bootstrap 95% interval: + [+10414, +15817] ppm + +The complete frozen interval lies above zero. + +Verifier-specific claim: + + SUPPORTED + +Within this controlled benchmark, verifier-governed representation selection +therefore improved online-learning AULC relative to the frozen ungated +adaptive representation-growth condition. + +--- + +# Representation discovery + +FULL-PRIME-v1.2 recovered the exact required final representation in every +held-out world: + + hidden d=0 -> H0: 32/32 + hidden d=1 -> H1: 32/32 + hidden d=2 -> H2: 32/32 + hidden d=4 -> H4: 32/32 + +Total: + + 128/128 exact final-depth recovery + +FULL-PRIME-v1.2: + + proposals: + 96 + + accepted repairs: + 96 + + rejected repairs: + 0 + +ADAPTIVE-NO-VERIFIER: + + proposals: + 192 + + accepted repairs: + 192 + + rejected repairs: + 0 + +Thus FULL-PRIME-v1.2 used exactly one authorized representation repair in each +of the 96 worlds requiring nonzero memory, while ungated adaptation traversed +the incremental representation ladder. + +--- + +# Authorization latency + +Across the 96 accepted FULL-PRIME-v1.2 repairs: + + mean authorization latency: + 25 scored events + + maximum authorization latency: + 100 scored events + + immediate authorizations: + 24 + + mean discordant evidence already available at obstruction: + 13 + + mean additional discordant evidence required after obstruction: + 11 + +Historical v1.1 fixed prospective evidence duration: + + 256 scored events + +The v1.2 architecture therefore substantially reduced the evidence-acquisition +delay associated with verifier authorization. + +This historical comparison is descriptive rather than a paired cross-version +inferential test. + +--- + +# Latency by required representation + +For d=1: + + mean latency: + 2 scored events + + maximum: + 13 + +For d=2: + + mean latency: + 8 scored events + + maximum: + 22 + +For d=4: + + mean latency: + 64 scored events + + maximum: + 100 + +The deepest H4 repair remains the dominant authorization-latency regime. + +--- + +# Scientific interpretation + +v1.1 established that verifier-governed representation selection could recover +the exact required representation but incurred a large online-learning cost +from fixed prospective evidence collection. + +v1.2 attacked that measured failure mode through passive prequential evidence +and anytime-valid sequential authorization. + +The held-out v1.2 result shows: + +1. exact representation recovery remained 128/128; + +2. authorization latency fell substantially relative to the historical v1.1 + prospective evidence regime; + +3. verifier-governed adaptation significantly outperformed ungated adaptive + growth under the frozen verifier-specific comparison; + +4. the large v1.1 deficit relative to FIXED-H4 was eliminated at the point + estimate; + +5. superiority over FIXED-H4 itself was not statistically established under the + preregistered paired bootstrap criterion. + +The primary claim must therefore remain negative. + +The verifier-specific claim is supported. + +--- + +# Claim boundary + +This constitutes controlled mechanistic benchmark evidence that verifier +governance can improve adaptive representation-growth performance relative to +the frozen ungated alternative while preserving exact minimal representation +selection. + +It does not establish: + +- universal superiority over fixed representations; +- superiority over learned recurrent-memory agents; +- general POMDP superiority; +- AGI; +- production security; +- broad real-world generality. + +The requirement for a separately frozen learned-memory comparator remains. diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/LINEAGE.json b/experiments/prime_canonical_agent_benchmark_v1_2/LINEAGE.json new file mode 100644 index 0000000..6aae11a --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/LINEAGE.json @@ -0,0 +1,13 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.2", + "parent_benchmark": "prime-canonical-agent-benchmark-v1.1", + "parent_final_commit": "95325f6", + "parent_evaluation_result_sha256": "b58a51857864e61837168dbb5e36ef69d26a600b5775aa2dcc3cb17651962388", + "parent_core_implementation_sha256": "b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f", + "parent_primary_claim": "NOT SUPPORTED", + "parent_exact_final_depth_recovery": "128/128", + "parent_identified_bottleneck": "prospective verifier evidence-acquisition latency", + "v1_2_development_seeds": "100..131", + "v1_2_evaluation_seeds": "2000..2127", + "v1_1_evaluation_seeds_reused_as_held_out": false +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/LINEAGE.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/LINEAGE.sha256 new file mode 100644 index 0000000..cb04a30 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/LINEAGE.sha256 @@ -0,0 +1 @@ +0a285ca80e99c1c7f8aa2cb38371b2398ab016c52012bd37f3a54e177bf28b8e LINEAGE.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/__init__.py b/experiments/prime_canonical_agent_benchmark_v1_2/__init__.py new file mode 100644 index 0000000..1e7f96e --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/__init__.py @@ -0,0 +1 @@ +"""PRIME Canonical Agent Benchmark v1.2.""" diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/adaptive_runner.py b/experiments/prime_canonical_agent_benchmark_v1_2/adaptive_runner.py new file mode 100644 index 0000000..9a2e1ab --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/adaptive_runner.py @@ -0,0 +1,742 @@ +"""Adaptive v1.2 runner with passive anytime-valid verification.""" + +from dataclasses import dataclass +import hashlib + +from experiments.prime_canonical_agent_benchmark_v1.baselines import ( + HistoryRepresentation, +) +from experiments.prime_canonical_agent_benchmark_v1.deterministic import ( + splitmix64, +) +from experiments.prime_canonical_agent_benchmark_v1.environment import ( + MemoryAliasPOMDP, +) +from experiments.prime_canonical_agent_benchmark_v1.learner import ( + BinaryTabularLearner, +) +from experiments.prime_canonical_agent_benchmark_v1.manifest import ( + DECISION_STEPS_PER_EPISODE, + EPISODES, + FINAL_WINDOW_EPISODES, + PPM, + WARMUP_STEPS, +) + +from .manifest import ( + ADAPTIVE_CONDITIONS, + BENCHMARK_VERSION, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, +) +from .provenance import ( + frozen_identities, + implementation_sha256, + source_commit, + source_dirty, +) +from .receipts import ( + ReceiptChain, + canonical_bytes, + verify_receipt_chain, +) +from .verifier import ( + SequentialVerifierEpoch, + deeper_depths, +) + + +MAX_ACCEPTED_REPAIRS = 3 +OBSTRUCTION_MIN_PER_TARGET = 8 + + +@dataclass(frozen=True) +class AdaptiveResult: + payload: dict + + def canonical_bytes(self) -> bytes: + return canonical_bytes(self.payload) + + def sha256(self) -> str: + return hashlib.sha256( + self.canonical_bytes() + ).hexdigest() + + +def _infer_target( + action: int, + reward: int, +) -> int: + if reward == 1: + return action + if reward == 0: + return 1 - action + + raise RuntimeError( + "benchmark reward must be binary" + ) + + +def _primary_aulc_ppm( + episode_rewards: list[int], +) -> int: + cumulative = 0 + curve_sum = 0 + + for index, reward in enumerate( + episode_rewards, + start=1, + ): + cumulative += reward + denominator = ( + index + * DECISION_STEPS_PER_EPISODE + ) + + curve_sum += ( + PPM * cumulative + ) // denominator + + return curve_sum // len(episode_rewards) + + +def _final_window_ppm( + episode_rewards: list[int], +) -> int: + window = episode_rewards[ + -FINAL_WINDOW_EPISODES: + ] + + return ( + PPM * sum(window) + ) // ( + len(window) + * DECISION_STEPS_PER_EPISODE + ) + + +def _promote_policy( + current_state: tuple[int, ...], + new_depth: int, +) -> HistoryRepresentation: + representation = HistoryRepresentation( + depth=new_depth + ) + + for bit in current_state: + representation.observe(bit) + + return representation + + +def _obstruction_exists( + evidence: dict[ + tuple[int, ...], + list[int], + ], +) -> bool: + return any( + counts[0] >= OBSTRUCTION_MIN_PER_TARGET + and counts[1] >= OBSTRUCTION_MIN_PER_TARGET + for counts in evidence.values() + ) + + +def _guard_seed( + world_seed: int, + permit_evaluation: bool, +) -> None: + if permit_evaluation: + if world_seed not in EVALUATION_SEEDS: + raise RuntimeError( + "evaluation mode accepts only frozen " + "v1.2 evaluation seeds" + ) + else: + if world_seed not in DEVELOPMENT_SEEDS: + raise RuntimeError( + "development mode accepts only frozen " + "v1.2 development seeds" + ) + + +def _resolution_payload( + *, + condition: str, + world_seed: int, + verifier: SequentialVerifierEpoch, + resolution_episode: int, + resolution_event_index: int, + authorized_depth: int | None, + canonical_depth_after: int, + resolution: str, +) -> dict: + supported = verifier.supported_depths() + + verifier_selected = ( + min(supported) + if supported + else None + ) + + latency = None + + if ( + verifier.obstruction_event_index + is not None + and verifier_selected is not None + ): + latency = ( + resolution_event_index + - verifier.obstruction_event_index + ) + + selected_discordant_at_obstruction = None + selected_additional_discordant = None + + if verifier_selected is not None: + selected_discordant_at_obstruction = ( + verifier.discordant_at_obstruction.get( + verifier_selected + ) + ) + + selected_additional_discordant = ( + verifier.additional_discordant_after_obstruction( + verifier_selected + ) + ) + + return { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "canonical_depth_before": ( + verifier.current_depth + ), + "obstruction_episode": ( + verifier.obstruction_episode + ), + "obstruction_scored_event_index": ( + verifier.obstruction_event_index + ), + "resolution_episode": resolution_episode, + "resolution_scored_event_index": ( + resolution_event_index + ), + "candidate_depths": list( + verifier.candidate_depths + ), + "verifier_evidence": ( + verifier.evidence_summaries() + ), + "supported_candidates": list(supported), + "verifier_selected_depth": ( + verifier_selected + ), + "authorized_depth": authorized_depth, + "canonical_depth_after": ( + canonical_depth_after + ), + "authorization_latency_scored_events": ( + latency + ), + "selected_discordant_at_obstruction": ( + selected_discordant_at_obstruction + ), + "selected_additional_discordant_after_obstruction": ( + selected_additional_discordant + ), + "resolution": resolution, + } + + +def run_adaptive_condition( + world_seed: int, + condition: str, + *, + permit_evaluation: bool = False, +) -> AdaptiveResult: + if condition not in ADAPTIVE_CONDITIONS: + raise ValueError( + f"unknown v1.2 adaptive condition: {condition}" + ) + + _guard_seed( + world_seed, + permit_evaluation, + ) + + frozen = frozen_identities() + + env = MemoryAliasPOMDP(world_seed) + + current_depth = 0 + policy = HistoryRepresentation( + depth=current_depth + ) + + learner_seed = splitmix64( + world_seed + ^ 0x8EBC6AF09C88C6E3 + ) + + learner = BinaryTabularLearner( + seed=learner_seed + ) + + use_verifier = condition in ( + "VERIFIER-NO-REPAIR", + "FULL-PRIME-V1.2", + ) + + verifier = ( + SequentialVerifierEpoch( + current_depth=current_depth + ) + if use_verifier + else None + ) + + ungated_obstruction: dict[ + tuple[int, ...], + list[int], + ] = {} + + ungated_epoch_resolved = False + + receipts = ReceiptChain() + + episode_rewards: list[int] = [] + + proposed_repairs = 0 + accepted_repairs = 0 + rejected_repairs = 0 + verifier_supported_repairs = 0 + verifier_suppressed_repairs = 0 + + representation_change_episodes: list[int] = [] + authorization_latencies: list[int] = [] + + global_scored_event_index = -1 + + for episode in range(EPISODES): + policy.reset() + + if verifier is not None: + verifier.reset_episode() + + observation = env.reset(episode) + + scored_reward = 0 + + total_steps = ( + WARMUP_STEPS + + DECISION_STEPS_PER_EPISODE + ) + + for _step_index in range(total_steps): + state = policy.observe( + observation + ) + + frozen_prediction = None + + if verifier is not None: + frozen_prediction = ( + verifier.freeze_prediction( + observation, + state, + ) + ) + + action = learner.choose(state) + result = env.step(action) + + if result.scored: + global_scored_event_index += 1 + + learner.update( + state, + action, + result.reward, + ) + + scored_reward += result.reward + + target = _infer_target( + action, + result.reward, + ) + + if condition == "ADAPTIVE-NO-VERIFIER": + bucket = ( + ungated_obstruction.setdefault( + state, + [0, 0], + ) + ) + bucket[target] += 1 + + candidates = deeper_depths( + current_depth + ) + + can_propose = ( + not ungated_epoch_resolved + and accepted_repairs + < MAX_ACCEPTED_REPAIRS + and bool(candidates) + and _obstruction_exists( + ungated_obstruction + ) + ) + + if can_propose: + proposed_repairs += 1 + + authorized = candidates[0] + before = current_depth + + receipts.append( + { + "benchmark_version": ( + BENCHMARK_VERSION + ), + "condition": condition, + "world_seed": world_seed, + "canonical_depth_before": ( + before + ), + "obstruction_episode": ( + episode + ), + "obstruction_scored_event_index": ( + global_scored_event_index + ), + "resolution_episode": ( + episode + ), + "resolution_scored_event_index": ( + global_scored_event_index + ), + "candidate_depths": list( + candidates + ), + "verifier_evidence": [], + "supported_candidates": [], + "verifier_selected_depth": ( + None + ), + "authorized_depth": ( + authorized + ), + "canonical_depth_after": ( + authorized + ), + "authorization_latency_scored_events": ( + 0 + ), + "selected_discordant_at_obstruction": ( + None + ), + "selected_additional_discordant_after_obstruction": ( + None + ), + "resolution": ( + "UNGATED_ACCEPT" + ), + } + ) + + current_depth = authorized + + policy = _promote_policy( + state, + authorized, + ) + + accepted_repairs += 1 + representation_change_episodes.append( + episode + ) + authorization_latencies.append(0) + + ungated_obstruction = {} + ungated_epoch_resolved = False + + else: + if frozen_prediction is None: + raise RuntimeError( + "verifier prediction missing" + ) + + outcome = verifier.finalize_event( + frozen_prediction, + target=target, + episode=episode, + scored_event_index=( + global_scored_event_index + ), + ) + + if outcome.proposal_opened: + proposed_repairs += 1 + + if outcome.supported_depths: + selected = min( + outcome.supported_depths + ) + + if condition == "FULL-PRIME-V1.2": + before = current_depth + + payload = _resolution_payload( + condition=condition, + world_seed=world_seed, + verifier=verifier, + resolution_episode=episode, + resolution_event_index=( + global_scored_event_index + ), + authorized_depth=selected, + canonical_depth_after=selected, + resolution=( + "VERIFIER_AUTHORIZE" + ), + ) + + receipts.append(payload) + + latency = ( + payload[ + "authorization_latency_scored_events" + ] + ) + + if latency is None: + raise RuntimeError( + "authorized repair " + "missing latency" + ) + + authorization_latencies.append( + latency + ) + + accepted_repairs += 1 + verifier_supported_repairs += 1 + + representation_change_episodes.append( + episode + ) + + current_depth = selected + + # Policy gains only memory legitimately + # present in its old authorized state. + policy = _promote_policy( + state, + current_depth, + ) + + # New canonical epoch. Verifier is seeded + # only from old policy state, never its + # private deeper queue. + verifier = SequentialVerifierEpoch( + current_depth=current_depth + ) + verifier.seed_mid_episode( + state + ) + + elif condition == "VERIFIER-NO-REPAIR": + payload = _resolution_payload( + condition=condition, + world_seed=world_seed, + verifier=verifier, + resolution_episode=episode, + resolution_event_index=( + global_scored_event_index + ), + authorized_depth=None, + canonical_depth_after=( + current_depth + ), + resolution=( + "VERIFIER_SUPPORTED_" + "MUTATION_DISABLED" + ), + ) + + receipts.append(payload) + + verifier_supported_repairs += 1 + verifier_suppressed_repairs += 1 + + verifier.mark_resolved() + + else: + raise RuntimeError( + "unexpected condition" + ) + + if result.done: + if result.next_observation is not None: + raise RuntimeError( + "terminal step exposed observation" + ) + else: + if result.next_observation not in (0, 1): + raise RuntimeError( + "invalid next observation" + ) + + observation = ( + result.next_observation + ) + + episode_rewards.append( + scored_reward + ) + + # Explicit end-of-run rejection for an unresolved sequential + # proposal. + if ( + verifier is not None + and verifier.proposal_open + and not verifier.proposal_resolved + ): + proposed_depths = ( + verifier.candidate_depths + ) + + if proposed_depths: + payload = _resolution_payload( + condition=condition, + world_seed=world_seed, + verifier=verifier, + resolution_episode=EPISODES - 1, + resolution_event_index=( + global_scored_event_index + ), + authorized_depth=None, + canonical_depth_after=current_depth, + resolution=( + "VERIFIER_REJECT_END_OF_RUN" + ), + ) + + receipts.append(payload) + rejected_repairs += 1 + verifier.mark_resolved() + + records = receipts.records + + if not verify_receipt_chain( + records, + expected_count=receipts.count, + expected_tip=receipts.tip, + ): + raise RuntimeError( + "internal receipt chain verification failed" + ) + + total_reward = sum(episode_rewards) + + total_trials = ( + EPISODES + * DECISION_STEPS_PER_EPISODE + ) + + implementation_hash = ( + implementation_sha256() + ) + + run_identity_payload = { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "implementation_sha256": ( + implementation_hash + ), + "frozen_identities": frozen, + } + + deterministic_run_identity = ( + hashlib.sha256( + canonical_bytes( + run_identity_payload + ) + ).hexdigest() + ) + + payload = { + "benchmark_version": BENCHMARK_VERSION, + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "episodes": EPISODES, + "decision_steps_per_episode": ( + DECISION_STEPS_PER_EPISODE + ), + "warmup_steps": WARMUP_STEPS, + "episode_rewards": episode_rewards, + "primary_aulc_ppm": ( + _primary_aulc_ppm( + episode_rewards + ) + ), + "final_window_reward_ppm": ( + _final_window_ppm( + episode_rewards + ) + ), + "total_reward": total_reward, + "cumulative_regret": ( + total_trials - total_reward + ), + "proposed_repairs": proposed_repairs, + "accepted_repairs": accepted_repairs, + "rejected_repairs": rejected_repairs, + "verifier_supported_repairs": ( + verifier_supported_repairs + ), + "verifier_suppressed_repairs": ( + verifier_suppressed_repairs + ), + "final_representation_depth": ( + current_depth + ), + "representation_change_episodes": ( + representation_change_episodes + ), + "authorization_latencies_scored_events": ( + authorization_latencies + ), + "mean_authorization_latency_scored_events": ( + sum(authorization_latencies) + // len(authorization_latencies) + if authorization_latencies + else None + ), + "repair_receipts": records, + "canonical_receipt_count": receipts.count, + "repair_receipt_chain_tip": receipts.tip, + "repair_receipt_chain_valid": True, + "deterministic_run_identity": ( + deterministic_run_identity + ), + "integrity_failures": 0, + "frozen_identities": frozen, + "implementation_sha256": ( + implementation_hash + ), + "source_commit": source_commit(), + "source_dirty": source_dirty(), + } + + return AdaptiveResult( + payload=payload + ) diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/evaluation_tools/frozen_evaluation.py b/experiments/prime_canonical_agent_benchmark_v1_2/evaluation_tools/frozen_evaluation.py new file mode 100644 index 0000000..a15a646 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/evaluation_tools/frozen_evaluation.py @@ -0,0 +1,899 @@ +"""Frozen held-out evaluator for PRIME Canonical Agent Benchmark v1.2.""" + +import argparse +import hashlib +import json +import os +from pathlib import Path +import subprocess + +from experiments.prime_canonical_agent_benchmark_v1.deterministic import ( + splitmix64, +) +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from experiments.prime_canonical_agent_benchmark_v1_2.adaptive_runner import ( + run_adaptive_condition, +) +from experiments.prime_canonical_agent_benchmark_v1_2.manifest import ( + ADAPTIVE_CONDITIONS, + EVALUATION_SEEDS, +) +from experiments.prime_canonical_agent_benchmark_v1_2.provenance import ( + frozen_identities, + implementation_sha256, +) +from experiments.prime_canonical_agent_benchmark_v1_2.receipts import ( + verify_receipt_chain, +) + + +HERE = Path(__file__).resolve().parent +V12 = HERE.parent +REPO = V12.parent.parent + +FROZEN_CORE_SHA256 = ( + "bed64cbe558c928d3793c915e34260638c9c0ed3f7061c350695e769b5c3efc9" +) + +FIXED_CONDITIONS = ( + "REACTIVE", + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", +) + +BOOTSTRAP_REPLICATES = 16384 +BOOTSTRAP_SEED = 0x5052494D45563131 +BOOTSTRAP_LOWER_INDEX = 409 +BOOTSTRAP_UPPER_INDEX = 15974 + +UNLOCK = "RUN_FROZEN_EVALUATION_V1_2" + + +def canonical_bytes(value: object) -> bytes: + return ( + json.dumps( + value, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + +def sha256_file(path: Path) -> str: + return hashlib.sha256( + path.read_bytes() + ).hexdigest() + + +def verify_checksum( + target: Path, + checksum: Path, +) -> str: + expected = checksum.read_text( + encoding="utf-8" + ).split()[0] + + actual = sha256_file(target) + + if actual != expected: + raise RuntimeError( + f"checksum mismatch: {target}" + ) + + return actual + + +def git_clean() -> bool: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "status", + "--porcelain", + ], + check=True, + capture_output=True, + text=True, + ) + + return result.stdout.strip() == "" + + +def git_commit() -> str: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "rev-parse", + "HEAD", + ], + check=True, + capture_output=True, + text=True, + ) + + return result.stdout.strip() + + +def mean_floor(values: list[int]) -> int: + return sum(values) // len(values) + + +def paired_bootstrap( + deltas: list[int], +) -> dict: + if len(deltas) != 128: + raise RuntimeError( + "paired bootstrap requires exactly 128 worlds" + ) + + sums = [] + + for replicate in range( + BOOTSTRAP_REPLICATES + ): + total = 0 + + for draw in range(128): + value = splitmix64( + BOOTSTRAP_SEED + ^ splitmix64(replicate) + ^ splitmix64(draw) + ) + + total += deltas[value % 128] + + sums.append(total) + + sums.sort() + + lower = sums[BOOTSTRAP_LOWER_INDEX] + upper = sums[BOOTSTRAP_UPPER_INDEX] + + return { + "replicates": BOOTSTRAP_REPLICATES, + "sample_size": 128, + "seed_hex": hex(BOOTSTRAP_SEED), + "lower_index": BOOTSTRAP_LOWER_INDEX, + "upper_index": BOOTSTRAP_UPPER_INDEX, + "observed_sum_delta": sum(deltas), + "observed_mean_delta_ppm": ( + sum(deltas) // 128 + ), + "lower_sum_delta": lower, + "lower_mean_delta_ppm": ( + lower // 128 + ), + "upper_sum_delta": upper, + "upper_mean_delta_ppm": ( + upper // 128 + ), + } + + +def preflight() -> dict: + if EVALUATION_SEEDS != tuple( + range(2000, 2128) + ): + raise RuntimeError( + "frozen v1.2 evaluation seed set mismatch" + ) + + if not git_clean(): + raise RuntimeError( + "Git worktree must be clean" + ) + + identities = frozen_identities() + + verify_checksum( + V12 / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json", + V12 / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256", + ) + + verify_checksum( + V12 / "EVALUATION_ANALYSIS_PLAN.md", + V12 / "EVALUATION_ANALYSIS_PLAN.sha256", + ) + + verify_checksum( + HERE / "frozen_evaluation.py", + HERE / "frozen_evaluation.sha256", + ) + + comparator = json.loads( + ( + V12 / "DEVELOPMENT_FIXED_COMPARATOR.json" + ).read_text() + ) + + if ( + comparator["selected_fixed_baseline"] + != "FIXED-H4" + ): + raise RuntimeError( + "frozen comparator is not FIXED-H4" + ) + + core_hash = implementation_sha256() + + if core_hash != FROZEN_CORE_SHA256: + raise RuntimeError( + "v1.2 core implementation hash mismatch: " + + core_hash + ) + + return { + "source_commit": git_commit(), + "core_implementation_sha256": ( + core_hash + ), + "frozen_identities": identities, + "selected_fixed_comparator": ( + "FIXED-H4" + ), + "analysis_plan_sha256": sha256_file( + V12 / "EVALUATION_ANALYSIS_PLAN.md" + ), + "evaluation_harness_sha256": sha256_file( + HERE / "frozen_evaluation.py" + ), + } + + +def receipt_diagnostics( + result: dict, +) -> dict: + latencies = [] + at_obstruction = [] + additional = [] + + for record in result["repair_receipts"]: + payload = record["payload"] + + latency = payload.get( + "authorization_latency_scored_events" + ) + + if latency is not None: + latencies.append(latency) + + before = payload.get( + "selected_discordant_at_obstruction" + ) + + after = payload.get( + "selected_additional_discordant_after_obstruction" + ) + + if before is not None: + at_obstruction.append(before) + + if after is not None: + additional.append(after) + + return { + "latencies": latencies, + "discordant_at_obstruction": ( + at_obstruction + ), + "additional_discordant": additional, + } + + +def build_report() -> dict: + preflight_record = preflight() + + rows = [] + + for seed in EVALUATION_SEEDS: + hidden_depth = ( + (0, 1, 2, 4)[seed % 4] + ) + + for condition in FIXED_CONDITIONS: + result = run_fixed_condition( + seed, + condition, + ).payload + + if result["source_dirty"]: + raise RuntimeError( + "fixed condition reported dirty source" + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": ( + hidden_depth + ), + "condition": condition, + "primary_aulc_ppm": ( + result["primary_aulc_ppm"] + ), + "final_window_reward_ppm": ( + result[ + "final_window_reward_ppm" + ] + ), + "cumulative_regret": ( + result["cumulative_regret"] + ), + "final_representation_depth": ( + result["representation_depth"] + ), + "proposed_repairs": 0, + "accepted_repairs": 0, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "canonical_receipt_count": 0, + "receipt_chain_valid": True, + "authorization_latencies_scored_events": [], + "discordant_at_obstruction": [], + "additional_discordant_after_obstruction": [], + } + ) + + for condition in ADAPTIVE_CONDITIONS: + result = run_adaptive_condition( + seed, + condition, + permit_evaluation=True, + ).payload + + if result["source_dirty"]: + raise RuntimeError( + "adaptive condition reported dirty source" + ) + + if ( + result["implementation_sha256"] + != FROZEN_CORE_SHA256 + ): + raise RuntimeError( + "adaptive result core hash mismatch" + ) + + receipt_ok = verify_receipt_chain( + result["repair_receipts"], + expected_count=( + result["canonical_receipt_count"] + ), + expected_tip=( + result["repair_receipt_chain_tip"] + ), + ) + + if not receipt_ok: + raise RuntimeError( + "adaptive receipt-chain failure" + ) + + diag = receipt_diagnostics( + result + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": ( + hidden_depth + ), + "condition": condition, + "primary_aulc_ppm": ( + result["primary_aulc_ppm"] + ), + "final_window_reward_ppm": ( + result[ + "final_window_reward_ppm" + ] + ), + "cumulative_regret": ( + result["cumulative_regret"] + ), + "final_representation_depth": ( + result[ + "final_representation_depth" + ] + ), + "proposed_repairs": ( + result["proposed_repairs"] + ), + "accepted_repairs": ( + result["accepted_repairs"] + ), + "rejected_repairs": ( + result["rejected_repairs"] + ), + "verifier_supported_repairs": ( + result[ + "verifier_supported_repairs" + ] + ), + "canonical_receipt_count": ( + result[ + "canonical_receipt_count" + ] + ), + "receipt_chain_valid": receipt_ok, + "authorization_latencies_scored_events": ( + diag["latencies"] + ), + "discordant_at_obstruction": ( + diag[ + "discordant_at_obstruction" + ] + ), + "additional_discordant_after_obstruction": ( + diag["additional_discordant"] + ), + } + ) + + conditions = ( + FIXED_CONDITIONS + + ADAPTIVE_CONDITIONS + ) + + summaries = {} + + for condition in conditions: + subset = [ + row + for row in rows + if row["condition"] == condition + ] + + summaries[condition] = { + "world_count": len(subset), + "mean_primary_aulc_ppm": mean_floor( + [ + row["primary_aulc_ppm"] + for row in subset + ] + ), + "mean_final_window_reward_ppm": mean_floor( + [ + row["final_window_reward_ppm"] + for row in subset + ] + ), + "mean_cumulative_regret": mean_floor( + [ + row["cumulative_regret"] + for row in subset + ] + ), + "total_proposed_repairs": sum( + row["proposed_repairs"] + for row in subset + ), + "total_accepted_repairs": sum( + row["accepted_repairs"] + for row in subset + ), + "total_rejected_repairs": sum( + row["rejected_repairs"] + for row in subset + ), + "all_receipt_chains_valid": all( + row["receipt_chain_valid"] + for row in subset + ), + } + + def metric_map( + condition: str, + metric: str, + ) -> dict[int, int]: + return { + row["world_seed"]: row[metric] + for row in rows + if row["condition"] == condition + } + + full_primary = metric_map( + "FULL-PRIME-V1.2", + "primary_aulc_ppm", + ) + + fixed_primary = metric_map( + "FIXED-H4", + "primary_aulc_ppm", + ) + + ungated_primary = metric_map( + "ADAPTIVE-NO-VERIFIER", + "primary_aulc_ppm", + ) + + full_final = metric_map( + "FULL-PRIME-V1.2", + "final_window_reward_ppm", + ) + + fixed_final = metric_map( + "FIXED-H4", + "final_window_reward_ppm", + ) + + primary_deltas = [ + full_primary[seed] + - fixed_primary[seed] + for seed in EVALUATION_SEEDS + ] + + verifier_deltas = [ + full_primary[seed] + - ungated_primary[seed] + for seed in EVALUATION_SEEDS + ] + + final_deltas = [ + full_final[seed] + - fixed_final[seed] + for seed in EVALUATION_SEEDS + ] + + primary_bootstrap = paired_bootstrap( + primary_deltas + ) + + verifier_bootstrap = paired_bootstrap( + verifier_deltas + ) + + integrity_pass = ( + git_clean() + and all( + summary[ + "all_receipt_chains_valid" + ] + for summary in summaries.values() + ) + and all( + summary["world_count"] == 128 + for summary in summaries.values() + ) + ) + + primary_mean_positive = ( + sum(primary_deltas) > 0 + ) + + primary_lower_positive = ( + primary_bootstrap[ + "lower_sum_delta" + ] > 0 + ) + + final_not_degraded = ( + sum(final_deltas) >= 0 + ) + + primary_supported = all( + ( + primary_mean_positive, + primary_lower_positive, + final_not_degraded, + integrity_pass, + ) + ) + + verifier_supported = ( + sum(verifier_deltas) > 0 + and verifier_bootstrap[ + "lower_sum_delta" + ] > 0 + and integrity_pass + ) + + depth_diagnostics = [] + + for depth in (0, 1, 2, 4): + subset = [ + row + for row in rows + if ( + row["condition"] + == "FULL-PRIME-V1.2" + and row[ + "diagnostic_hidden_depth" + ] == depth + ) + ] + + counts = {} + + for row in subset: + key = str( + row[ + "final_representation_depth" + ] + ) + + counts[key] = ( + counts.get(key, 0) + 1 + ) + + latencies = [ + value + for row in subset + for value in row[ + "authorization_latencies_scored_events" + ] + ] + + extra = [ + value + for row in subset + for value in row[ + "additional_discordant_after_obstruction" + ] + ] + + depth_diagnostics.append( + { + "hidden_depth": depth, + "world_count": len(subset), + "final_depth_counts": counts, + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_authorization_latency_scored_events": ( + mean_floor(latencies) + if latencies + else None + ), + "max_authorization_latency_scored_events": ( + max(latencies) + if latencies + else None + ), + "mean_additional_discordant_after_obstruction": ( + mean_floor(extra) + if extra + else None + ), + } + ) + + full_rows = [ + row + for row in rows + if row["condition"] + == "FULL-PRIME-V1.2" + ] + + full_latencies = [ + value + for row in full_rows + for value in row[ + "authorization_latencies_scored_events" + ] + ] + + full_before = [ + value + for row in full_rows + for value in row[ + "discordant_at_obstruction" + ] + ] + + full_extra = [ + value + for row in full_rows + for value in row[ + "additional_discordant_after_obstruction" + ] + ] + + exact_depth = sum( + row["final_representation_depth"] + == row["diagnostic_hidden_depth"] + for row in full_rows + ) + + return { + "benchmark": ( + "prime-canonical-agent-benchmark-v1.2" + ), + "status": ( + "FROZEN_EVALUATION_COMPLETE" + ), + "evaluation_seed_count": 128, + "evaluation_seeds": list( + EVALUATION_SEEDS + ), + "preflight": preflight_record, + "condition_summaries": summaries, + "primary_full_vs_fixed_h4": { + "bootstrap": primary_bootstrap, + "mean_delta_positive": ( + primary_mean_positive + ), + "bootstrap_lower_positive": ( + primary_lower_positive + ), + "mean_final_delta_ppm": ( + sum(final_deltas) // 128 + ), + "final_not_degraded": ( + final_not_degraded + ), + "integrity_pass": ( + integrity_pass + ), + "claim": ( + "SUPPORTED" + if primary_supported + else "NOT SUPPORTED" + ), + }, + "verifier_specific_full_vs_ungated": { + "bootstrap": verifier_bootstrap, + "integrity_pass": ( + integrity_pass + ), + "claim": ( + "SUPPORTED" + if verifier_supported + else "NOT SUPPORTED" + ), + }, + "full_prime_exact_depth_recovery": ( + exact_depth + ), + "full_prime_exact_depth_total": ( + len(full_rows) + ), + "full_prime_latency": { + "accepted_repairs": ( + len(full_latencies) + ), + "mean_authorization_latency_scored_events": ( + mean_floor(full_latencies) + if full_latencies + else None + ), + "max_authorization_latency_scored_events": ( + max(full_latencies) + if full_latencies + else None + ), + "immediate_authorizations": sum( + value == 0 + for value in full_latencies + ), + "mean_discordant_at_obstruction": ( + mean_floor(full_before) + if full_before + else None + ), + "mean_additional_discordant_after_obstruction": ( + mean_floor(full_extra) + if full_extra + else None + ), + "v1_1_historical_fixed_prospective_scored_events": ( + 256 + ), + }, + "full_prime_depth_diagnostics": ( + depth_diagnostics + ), + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + + parser.add_argument( + "--preflight-only", + action="store_true", + ) + + parser.add_argument( + "--unlock", + ) + + parser.add_argument( + "--output", + ) + + args = parser.parse_args() + + if args.preflight_only: + print( + json.dumps( + preflight(), + sort_keys=True, + indent=2, + ) + ) + return + + if args.unlock != UNLOCK: + raise SystemExit( + "v1.2 held-out evaluation remains locked" + ) + + if not args.output: + raise SystemExit( + "--output is required" + ) + + output = Path( + args.output + ).expanduser().resolve() + + try: + output.relative_to( + REPO.resolve() + ) + except ValueError: + pass + else: + raise SystemExit( + "evaluation output must be outside Git worktree" + ) + + if output.exists(): + raise SystemExit( + "refusing to overwrite existing evaluation output" + ) + + report = build_report() + + temporary = output.with_name( + output.name + ".partial" + ) + + temporary.write_bytes( + canonical_bytes(report) + ) + + os.replace( + temporary, + output, + ) + + print( + json.dumps( + { + "status": report["status"], + "primary_claim": report[ + "primary_full_vs_fixed_h4" + ]["claim"], + "verifier_specific_claim": report[ + "verifier_specific_full_vs_ungated" + ]["claim"], + "output": str(output), + "sha256": sha256_file(output), + }, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/evaluation_tools/frozen_evaluation.sha256 b/experiments/prime_canonical_agent_benchmark_v1_2/evaluation_tools/frozen_evaluation.sha256 new file mode 100644 index 0000000..680fed8 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/evaluation_tools/frozen_evaluation.sha256 @@ -0,0 +1 @@ +84793d28f7bc62051af7472b22a99cfd77315219c0940166958d87bdfb0a1da4 frozen_evaluation.py diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/manifest.py b/experiments/prime_canonical_agent_benchmark_v1_2/manifest.py new file mode 100644 index 0000000..566479b --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/manifest.py @@ -0,0 +1,28 @@ +"""Frozen configuration for PRIME Canonical Agent Benchmark v1.2.""" + +BENCHMARK_VERSION = "prime-canonical-agent-benchmark-v1.2" + +DEVELOPMENT_SEEDS = tuple(range(100, 132)) +EVALUATION_SEEDS = tuple(range(2000, 2128)) + +PERMITTED_DEPTHS = (0, 1, 2, 4) + +FIXED_CONDITIONS = ( + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", +) + +ADAPTIVE_CONDITIONS = ( + "ADAPTIVE-NO-VERIFIER", + "VERIFIER-NO-REPAIR", + "FULL-PRIME-V1.2", +) + +PARENT_CORE_IMPLEMENTATION_SHA256 = ( + "b98a84c501979eb05d221bdfb603dfb68895ee541696d7a7c80045feb7a8bb6f" +) + +PARENT_EVALUATION_RESULT_SHA256 = ( + "b58a51857864e61837168dbb5e36ef69d26a600b5775aa2dcc3cb17651962388" +) diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/provenance.py b/experiments/prime_canonical_agent_benchmark_v1_2/provenance.py new file mode 100644 index 0000000..12306bc --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/provenance.py @@ -0,0 +1,139 @@ +"""Frozen-input and source provenance for benchmark v1.2.""" + +import hashlib +from pathlib import Path +import subprocess + + +HERE = Path(__file__).resolve().parent +V1 = HERE.parent / "prime_canonical_agent_benchmark_v1" +V11 = HERE.parent / "prime_canonical_agent_benchmark_v1_1" +REPO = HERE.parent.parent + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _verify( + directory: Path, + target_name: str, + checksum_name: str, +) -> str: + target = directory / target_name + checksum = directory / checksum_name + + expected = checksum.read_text( + encoding="utf-8" + ).split()[0] + + actual = _sha256(target) + + if actual != expected: + raise RuntimeError( + f"frozen hash mismatch: {target}" + ) + + return actual + + +def frozen_identities() -> dict: + return { + "v1_2_contract_sha256": _verify( + HERE, + "EXPERIMENT_CONTRACT.md", + "EXPERIMENT_CONTRACT.sha256", + ), + "v1_2_lineage_sha256": _verify( + HERE, + "LINEAGE.json", + "LINEAGE.sha256", + ), + "v1_2_adaptive_rules_sha256": _verify( + HERE, + "ADAPTIVE_RULES.md", + "ADAPTIVE_RULES.sha256", + ), + "v1_2_fixed_comparator_sha256": _verify( + HERE, + "DEVELOPMENT_FIXED_COMPARATOR.json", + "DEVELOPMENT_FIXED_COMPARATOR.sha256", + ), + "parent_v1_1_result_sha256": _verify( + V11, + "FROZEN_EVALUATION_RESULT.json", + "FROZEN_EVALUATION_RESULT.sha256", + ), + } + + +def implementation_sha256() -> str: + """Hash executable parent apparatus plus v1.2 Python sources.""" + digest = hashlib.sha256() + entries: list[tuple[str, Path]] = [] + + for prefix, directory in ( + ("v1", V1), + ("v1_2", HERE), + ): + for path in directory.glob("*.py"): + entries.append( + (f"{prefix}/{path.name}", path) + ) + + for relative, path in sorted(entries): + name = relative.encode("utf-8") + payload = path.read_bytes() + + digest.update( + len(name).to_bytes(8, "big") + ) + digest.update(name) + + digest.update( + len(payload).to_bytes(8, "big") + ) + digest.update(payload) + + return digest.hexdigest() + + +def source_commit() -> str: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "rev-parse", + "HEAD", + ], + check=True, + capture_output=True, + text=True, + ) + + commit = result.stdout.strip() + + if len(commit) != 40: + raise RuntimeError( + "unexpected git commit identity" + ) + + return commit + + +def source_dirty() -> bool: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "status", + "--porcelain", + ], + check=True, + capture_output=True, + text=True, + ) + + return bool(result.stdout.strip()) diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/receipts.py b/experiments/prime_canonical_agent_benchmark_v1_2/receipts.py new file mode 100644 index 0000000..2edbfba --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/receipts.py @@ -0,0 +1,117 @@ +"""Canonical hash-chained receipts with truncation anchors.""" + +from copy import deepcopy +import hashlib +import json + + +GENESIS_HASH = "0" * 64 + + +def canonical_bytes(payload: object) -> bytes: + return ( + json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + +def payload_hash(payload: dict) -> str: + return hashlib.sha256( + canonical_bytes(payload) + ).hexdigest() + + +class ReceiptChain: + def __init__(self) -> None: + self._records: list[dict] = [] + + @property + def records(self) -> list[dict]: + return deepcopy(self._records) + + @property + def count(self) -> int: + return len(self._records) + + @property + def tip(self) -> str: + if not self._records: + return GENESIS_HASH + return self._records[-1]["receipt_hash"] + + def append(self, payload: dict) -> dict: + material = deepcopy(payload) + material["sequence"] = self.count + 1 + material["previous_receipt_hash"] = self.tip + + record = { + "payload": material, + "receipt_hash": payload_hash(material), + } + + self._records.append(record) + return deepcopy(record) + + +def verify_receipt_chain( + records: list[dict], + *, + expected_count: int | None = None, + expected_tip: str | None = None, +) -> bool: + if ( + expected_count is not None + and len(records) != expected_count + ): + return False + + previous = GENESIS_HASH + + for expected_sequence, record in enumerate( + records, + start=1, + ): + if set(record) != { + "payload", + "receipt_hash", + }: + return False + + payload = record["payload"] + claimed_hash = record["receipt_hash"] + + if not isinstance(payload, dict): + return False + + if payload.get("sequence") != expected_sequence: + return False + + if ( + payload.get("previous_receipt_hash") + != previous + ): + return False + + if payload_hash(payload) != claimed_hash: + return False + + previous = claimed_hash + + actual_tip = ( + records[-1]["receipt_hash"] + if records + else GENESIS_HASH + ) + + if ( + expected_tip is not None + and actual_tip != expected_tip + ): + return False + + return True diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/run_adaptive_development.py b/experiments/prime_canonical_agent_benchmark_v1_2/run_adaptive_development.py new file mode 100644 index 0000000..ea89226 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/run_adaptive_development.py @@ -0,0 +1,358 @@ +"""Development-only diagnostic sweep for PRIME benchmark v1.2.""" + +import json + +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from .adaptive_runner import ( + run_adaptive_condition, +) +from .manifest import ( + ADAPTIVE_CONDITIONS, + DEVELOPMENT_SEEDS, +) +from .provenance import ( + frozen_identities, + implementation_sha256, +) +from .receipts import verify_receipt_chain + + +def mean_floor(values: list[int]) -> int | None: + if not values: + return None + return sum(values) // len(values) + + +def main() -> None: + if DEVELOPMENT_SEEDS != tuple(range(100, 132)): + raise RuntimeError( + "v1.2 development seed set changed" + ) + + rows = [] + + for seed in DEVELOPMENT_SEEDS: + diagnostic_depth = (0, 1, 2, 4)[seed % 4] + + fixed_h4 = run_fixed_condition( + seed, + "FIXED-H4", + ).payload + + for condition in ADAPTIVE_CONDITIONS: + result = run_adaptive_condition( + seed, + condition, + ).payload + + receipt_ok = verify_receipt_chain( + result["repair_receipts"], + expected_count=( + result["canonical_receipt_count"] + ), + expected_tip=( + result["repair_receipt_chain_tip"] + ), + ) + + receipt_latencies = [] + discordant_at_obstruction = [] + additional_discordant = [] + + for record in result["repair_receipts"]: + payload = record["payload"] + + latency = payload.get( + "authorization_latency_scored_events" + ) + + if latency is not None: + receipt_latencies.append(latency) + + before = payload.get( + "selected_discordant_at_obstruction" + ) + + after = payload.get( + "selected_additional_discordant_after_obstruction" + ) + + if before is not None: + discordant_at_obstruction.append(before) + + if after is not None: + additional_discordant.append(after) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": diagnostic_depth, + "condition": condition, + "primary_aulc_ppm": ( + result["primary_aulc_ppm"] + ), + "final_window_reward_ppm": ( + result["final_window_reward_ppm"] + ), + "fixed_h4_primary_aulc_ppm": ( + fixed_h4["primary_aulc_ppm"] + ), + "cumulative_regret": ( + result["cumulative_regret"] + ), + "proposed_repairs": ( + result["proposed_repairs"] + ), + "accepted_repairs": ( + result["accepted_repairs"] + ), + "rejected_repairs": ( + result["rejected_repairs"] + ), + "verifier_supported_repairs": ( + result["verifier_supported_repairs"] + ), + "verifier_suppressed_repairs": ( + result["verifier_suppressed_repairs"] + ), + "final_representation_depth": ( + result["final_representation_depth"] + ), + "authorization_latencies_scored_events": ( + receipt_latencies + ), + "discordant_at_obstruction": ( + discordant_at_obstruction + ), + "additional_discordant_after_obstruction": ( + additional_discordant + ), + "canonical_receipt_count": ( + result["canonical_receipt_count"] + ), + "receipt_chain_valid": receipt_ok, + } + ) + + condition_summaries = [] + + for condition in ADAPTIVE_CONDITIONS: + subset = [ + row + for row in rows + if row["condition"] == condition + ] + + latencies = [ + latency + for row in subset + for latency in row[ + "authorization_latencies_scored_events" + ] + ] + + before = [ + value + for row in subset + for value in row["discordant_at_obstruction"] + ] + + additional = [ + value + for row in subset + for value in row[ + "additional_discordant_after_obstruction" + ] + ] + + condition_summaries.append( + { + "condition": condition, + "world_count": len(subset), + "mean_primary_aulc_ppm": mean_floor( + [ + row["primary_aulc_ppm"] + for row in subset + ] + ), + "mean_final_window_reward_ppm": mean_floor( + [ + row["final_window_reward_ppm"] + for row in subset + ] + ), + "mean_cumulative_regret": mean_floor( + [ + row["cumulative_regret"] + for row in subset + ] + ), + "total_proposed_repairs": sum( + row["proposed_repairs"] + for row in subset + ), + "total_accepted_repairs": sum( + row["accepted_repairs"] + for row in subset + ), + "total_rejected_repairs": sum( + row["rejected_repairs"] + for row in subset + ), + "mean_authorization_latency_scored_events": ( + mean_floor(latencies) + ), + "max_authorization_latency_scored_events": ( + max(latencies) + if latencies + else None + ), + "immediate_authorizations": sum( + latency == 0 + for latency in latencies + ), + "mean_discordant_at_obstruction": ( + mean_floor(before) + ), + "mean_additional_discordant_after_obstruction": ( + mean_floor(additional) + ), + "all_receipt_chains_valid": all( + row["receipt_chain_valid"] + for row in subset + ), + } + ) + + by_depth = [] + + for depth in (0, 1, 2, 4): + for condition in ADAPTIVE_CONDITIONS: + subset = [ + row + for row in rows + if ( + row["diagnostic_hidden_depth"] == depth + and row["condition"] == condition + ) + ] + + final_counts = {} + + for row in subset: + key = str( + row["final_representation_depth"] + ) + final_counts[key] = ( + final_counts.get(key, 0) + 1 + ) + + latencies = [ + latency + for row in subset + for latency in row[ + "authorization_latencies_scored_events" + ] + ] + + additional = [ + value + for row in subset + for value in row[ + "additional_discordant_after_obstruction" + ] + ] + + by_depth.append( + { + "diagnostic_hidden_depth": depth, + "condition": condition, + "world_count": len(subset), + "mean_primary_aulc_ppm": mean_floor( + [ + row["primary_aulc_ppm"] + for row in subset + ] + ), + "mean_final_window_reward_ppm": mean_floor( + [ + row["final_window_reward_ppm"] + for row in subset + ] + ), + "final_depth_counts": final_counts, + "accepted_repairs": sum( + row["accepted_repairs"] + for row in subset + ), + "rejected_repairs": sum( + row["rejected_repairs"] + for row in subset + ), + "mean_authorization_latency_scored_events": ( + mean_floor(latencies) + ), + "max_authorization_latency_scored_events": ( + max(latencies) + if latencies + else None + ), + "mean_additional_discordant_after_obstruction": ( + mean_floor(additional) + ), + } + ) + + full_rows = [ + row + for row in rows + if row["condition"] == "FULL-PRIME-V1.2" + ] + + exact_depth_recovery = sum( + row["final_representation_depth"] + == row["diagnostic_hidden_depth"] + for row in full_rows + ) + + fixed_h4_metrics = [ + run_fixed_condition( + seed, + "FIXED-H4", + ).payload["primary_aulc_ppm"] + for seed in DEVELOPMENT_SEEDS + ] + + report = { + "benchmark": "prime-canonical-agent-benchmark-v1.2", + "status": "DEVELOPMENT_ONLY_NOT_EVALUATION", + "evaluation_seeds_run": False, + "development_seeds": list(DEVELOPMENT_SEEDS), + "implementation_sha256": implementation_sha256(), + "frozen_identities": frozen_identities(), + "fixed_h4_mean_primary_aulc_ppm": ( + mean_floor(fixed_h4_metrics) + ), + "full_prime_exact_depth_recovery": ( + exact_depth_recovery + ), + "full_prime_exact_depth_total": len(full_rows), + "condition_summaries": condition_summaries, + "by_hidden_depth_diagnostic": by_depth, + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/run_fixed_development.py b/experiments/prime_canonical_agent_benchmark_v1_2/run_fixed_development.py new file mode 100644 index 0000000..4c53d78 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/run_fixed_development.py @@ -0,0 +1,91 @@ +"""Select v1.2 fixed comparator using development seeds only.""" + +import json + +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from .manifest import ( + DEVELOPMENT_SEEDS, + FIXED_CONDITIONS, +) + + +DEPTH = { + "FIXED-H1": 1, + "FIXED-H2": 2, + "FIXED-H4": 4, +} + + +def main() -> None: + if DEVELOPMENT_SEEDS != tuple(range(100, 132)): + raise RuntimeError( + "v1.2 development seed set is not frozen 100..131" + ) + + rows = [] + + for condition in FIXED_CONDITIONS: + metrics = [] + + for seed in DEVELOPMENT_SEEDS: + result = run_fixed_condition( + seed, + condition, + ).payload + + metrics.append( + result["primary_aulc_ppm"] + ) + + rows.append( + { + "condition": condition, + "representation_depth": DEPTH[condition], + "world_count": len(metrics), + "mean_primary_aulc_ppm": ( + sum(metrics) // len(metrics) + ), + } + ) + + best = max( + row["mean_primary_aulc_ppm"] + for row in rows + ) + + selected = min( + ( + row + for row in rows + if row["mean_primary_aulc_ppm"] == best + ), + key=lambda row: row["representation_depth"], + ) + + report = { + "benchmark": "prime-canonical-agent-benchmark-v1.2", + "status": "DEVELOPMENT_FIXED_COMPARATOR_SELECTION", + "development_seeds": list(DEVELOPMENT_SEEDS), + "evaluation_seeds_run": False, + "selection_rule": ( + "highest mean primary_aulc_ppm; " + "ties select smaller representation" + ), + "rows": rows, + "selected_fixed_baseline": selected["condition"], + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/test_adaptive.py b/experiments/prime_canonical_agent_benchmark_v1_2/test_adaptive.py new file mode 100644 index 0000000..dc1e16d --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/test_adaptive.py @@ -0,0 +1,330 @@ +"""Invariant and adversarial tests for benchmark v1.2.""" + +from copy import deepcopy +import unittest + +from .adaptive_runner import ( + run_adaptive_condition, +) +from .receipts import ( + ReceiptChain, + verify_receipt_chain, +) +from .verifier import ( + CandidateEvidence, + PrequentialPredictor, + SequentialVerifierEpoch, +) + + +class EvidenceTests(unittest.TestCase): + def test_anytime_threshold_exact_boundary(self): + evidence = CandidateEvidence( + depth=1, + wins=14, + losses=0, + ) + + self.assertFalse( + evidence.statistical_pass + ) + + evidence.wins = 15 + + self.assertTrue( + evidence.statistical_pass + ) + + def test_h4_complexity_requires_more_than_30_net(self): + evidence = CandidateEvidence( + depth=4, + wins=30, + losses=0, + ) + + self.assertTrue( + evidence.statistical_pass + ) + + self.assertFalse( + evidence.complexity_pass(0) + ) + + evidence.wins = 31 + + self.assertTrue( + evidence.supported(0) + ) + + def test_predictor_is_prequential(self): + predictor = PrequentialPredictor() + state = (0,) + + self.assertEqual( + predictor.predict(state), + 0, + ) + + predictor.update( + state, + 1, + ) + + self.assertEqual( + predictor.predict(state), + 1, + ) + + def test_verifier_private_history_matches_current_policy_only(self): + verifier = SequentialVerifierEpoch( + current_depth=0 + ) + + frozen = verifier.freeze_prediction( + 1, + (1,), + ) + + self.assertEqual( + frozen.current_state, + (1,), + ) + + self.assertIn( + 4, + frozen.candidate_states, + ) + + # H4 verifier state exists, but policy current state remains H0. + self.assertEqual( + len(frozen.current_state), + 1, + ) + self.assertEqual( + len(frozen.candidate_states[4]), + 5, + ) + + +class ReceiptTamperTests(unittest.TestCase): + def _chain(self): + chain = ReceiptChain() + + for sequence in range(3): + chain.append( + { + "benchmark_version": "test", + "condition": "FULL-PRIME-V1.2", + "world_seed": 100, + "candidate_depths": [1, 2, 4], + "verifier_evidence": [ + { + "candidate_depth": 1, + "wins": 15 + sequence, + "losses": 0, + "complexity_cost": 2, + } + ], + "authorized_depth": 1, + } + ) + + return ( + chain.records, + chain.count, + chain.tip, + ) + + def _assert_tampered(self, mutator): + records, count, tip = self._chain() + + self.assertTrue( + verify_receipt_chain( + records, + expected_count=count, + expected_tip=tip, + ) + ) + + damaged = deepcopy(records) + mutator(damaged) + + self.assertFalse( + verify_receipt_chain( + damaged, + expected_count=count, + expected_tip=tip, + ) + ) + + def test_changed_w(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "verifier_evidence" + ][0].__setitem__( + "wins", + 999, + ) + ) + + def test_changed_l(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "verifier_evidence" + ][0].__setitem__( + "losses", + 999, + ) + ) + + def test_changed_candidate_depth(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "verifier_evidence" + ][0].__setitem__( + "candidate_depth", + 4, + ) + ) + + def test_changed_complexity_cost(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "verifier_evidence" + ][0].__setitem__( + "complexity_cost", + 999, + ) + ) + + def test_changed_authorization_depth(self): + self._assert_tampered( + lambda r: r[0]["payload"].__setitem__( + "authorized_depth", + 4, + ) + ) + + def test_changed_previous_hash(self): + self._assert_tampered( + lambda r: r[1]["payload"].__setitem__( + "previous_receipt_hash", + "f" * 64, + ) + ) + + def test_changed_world_seed(self): + self._assert_tampered( + lambda r: r[0]["payload"].__setitem__( + "world_seed", + 999, + ) + ) + + def test_receipt_deletion(self): + self._assert_tampered( + lambda r: r.pop() + ) + + def test_receipt_insertion(self): + self._assert_tampered( + lambda r: r.insert( + 1, + deepcopy(r[0]), + ) + ) + + def test_receipt_reordering(self): + def mutate(records): + records[0], records[1] = ( + records[1], + records[0], + ) + + self._assert_tampered( + mutate + ) + + +class RunnerTests(unittest.TestCase): + def test_v1_2_evaluation_seed_blocked(self): + with self.assertRaises(RuntimeError): + run_adaptive_condition( + 2000, + "FULL-PRIME-V1.2", + ) + + def test_nondevelopment_seed_blocked(self): + with self.assertRaises(RuntimeError): + run_adaptive_condition( + 999, + "FULL-PRIME-V1.2", + ) + + def test_development_run_byte_reproducible(self): + first = run_adaptive_condition( + 101, + "FULL-PRIME-V1.2", + ) + second = run_adaptive_condition( + 101, + "FULL-PRIME-V1.2", + ) + + self.assertEqual( + first.canonical_bytes(), + second.canonical_bytes(), + ) + + self.assertEqual( + first.sha256(), + second.sha256(), + ) + + def test_receipts_verify_with_anchors(self): + result = run_adaptive_condition( + 102, + "FULL-PRIME-V1.2", + ).payload + + self.assertTrue( + verify_receipt_chain( + result["repair_receipts"], + expected_count=( + result["canonical_receipt_count"] + ), + expected_tip=( + result["repair_receipt_chain_tip"] + ), + ) + ) + + def test_no_native_floats(self): + payload = run_adaptive_condition( + 103, + "ADAPTIVE-NO-VERIFIER", + ).payload + + def walk(value): + self.assertNotIsInstance( + value, + float, + ) + + if isinstance(value, dict): + for key, item in value.items(): + self.assertIsInstance( + key, + str, + ) + walk(item) + + elif isinstance(value, list): + for item in value: + walk(item) + + walk(payload) + + +if __name__ == "__main__": + unittest.main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_2/verifier.py b/experiments/prime_canonical_agent_benchmark_v1_2/verifier.py new file mode 100644 index 0000000..efdd876 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_2/verifier.py @@ -0,0 +1,377 @@ +"""Anytime-valid sequential representation verifier for benchmark v1.2.""" + +from dataclasses import dataclass, field + + +PERMITTED_DEPTHS = (0, 1, 2, 4) +EVIDENCE_THRESHOLD = 384 +OBSTRUCTION_MIN_PER_TARGET = 8 + + +def representation_complexity(depth: int) -> int: + return 2 ** (depth + 1) + + +def deeper_depths(current_depth: int) -> tuple[int, ...]: + return tuple( + depth + for depth in PERMITTED_DEPTHS + if depth > current_depth + ) + + +def state_from_history( + history: list[int], + depth: int, +) -> tuple[int, ...]: + width = depth + 1 + tail = history[-width:] + padding = [0] * (width - len(tail)) + return tuple(padding + tail) + + +@dataclass +class PrequentialPredictor: + counts: dict[tuple[int, ...], list[int]] = field( + default_factory=dict + ) + + def predict(self, state: tuple[int, ...]) -> int: + count0, count1 = self.counts.get( + state, + [0, 0], + ) + return 1 if count1 > count0 else 0 + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + if target not in (0, 1): + raise ValueError("target must be binary") + + bucket = self.counts.setdefault( + state, + [0, 0], + ) + bucket[target] += 1 + + +@dataclass +class CandidateEvidence: + depth: int + wins: int = 0 + losses: int = 0 + + @property + def discordant(self) -> int: + return self.wins + self.losses + + @property + def evidence_lhs(self) -> int: + return 3 ** self.wins + + @property + def evidence_rhs(self) -> int: + return ( + EVIDENCE_THRESHOLD + * (2 ** self.discordant) + ) + + @property + def statistical_pass(self) -> bool: + return self.evidence_lhs >= self.evidence_rhs + + def complexity_cost( + self, + current_depth: int, + ) -> int: + return ( + representation_complexity(self.depth) + - representation_complexity(current_depth) + ) + + @property + def net_advantage(self) -> int: + return self.wins - self.losses + + def complexity_pass( + self, + current_depth: int, + ) -> bool: + return ( + self.net_advantage + > self.complexity_cost(current_depth) + ) + + def supported( + self, + current_depth: int, + ) -> bool: + return ( + self.statistical_pass + and self.complexity_pass(current_depth) + ) + + def summary( + self, + current_depth: int, + ) -> dict: + cost = self.complexity_cost(current_depth) + + return { + "candidate_depth": self.depth, + "wins": self.wins, + "losses": self.losses, + "discordant": self.discordant, + "evidence_lhs": self.evidence_lhs, + "evidence_rhs": self.evidence_rhs, + "evidence_threshold": EVIDENCE_THRESHOLD, + "statistical_pass": self.statistical_pass, + "complexity_cost": cost, + "net_advantage": self.net_advantage, + "complexity_pass": ( + self.net_advantage > cost + ), + "supported": self.supported(current_depth), + } + + +@dataclass(frozen=True) +class FrozenPrediction: + current_state: tuple[int, ...] + candidate_states: dict[int, tuple[int, ...]] + current_prediction: int + candidate_predictions: dict[int, int] + + +@dataclass(frozen=True) +class FinalizeOutcome: + proposal_opened: bool + supported_depths: tuple[int, ...] + + +class SequentialVerifierEpoch: + """Verifier state for one canonical representation epoch.""" + + def __init__( + self, + current_depth: int, + *, + seed_history: tuple[int, ...] = (), + ): + if current_depth not in PERMITTED_DEPTHS: + raise ValueError("invalid current depth") + + self.current_depth = current_depth + self.candidate_depths = deeper_depths( + current_depth + ) + + self.predictors = { + depth: PrequentialPredictor() + for depth in ( + current_depth, + *self.candidate_depths, + ) + } + + self.evidence = { + depth: CandidateEvidence(depth=depth) + for depth in self.candidate_depths + } + + self.obstruction_counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + self._history: list[int] = list(seed_history)[-5:] + + self.proposal_open = False + self.proposal_resolved = False + self.obstruction_episode: int | None = None + self.obstruction_event_index: int | None = None + self.discordant_at_obstruction: dict[int, int] = {} + + def reset_episode(self) -> None: + self._history = [] + + def seed_mid_episode( + self, + policy_state: tuple[int, ...], + ) -> None: + """Seed only history legitimately present in authorized policy state.""" + self._history = list(policy_state)[-5:] + + def freeze_prediction( + self, + observation: int, + policy_state: tuple[int, ...], + ) -> FrozenPrediction: + if observation not in (0, 1): + raise ValueError("observation must be binary") + + self._history.append(observation) + self._history = self._history[-5:] + + verifier_current_state = state_from_history( + self._history, + self.current_depth, + ) + + if verifier_current_state != policy_state: + raise RuntimeError( + "policy/verifier current-state mismatch" + ) + + candidate_states = { + depth: state_from_history( + self._history, + depth, + ) + for depth in self.candidate_depths + } + + current_prediction = self.predictors[ + self.current_depth + ].predict(policy_state) + + candidate_predictions = { + depth: self.predictors[depth].predict( + candidate_states[depth] + ) + for depth in self.candidate_depths + } + + return FrozenPrediction( + current_state=policy_state, + candidate_states=candidate_states, + current_prediction=current_prediction, + candidate_predictions=candidate_predictions, + ) + + def _obstruction_exists(self) -> bool: + return any( + counts[0] >= OBSTRUCTION_MIN_PER_TARGET + and counts[1] >= OBSTRUCTION_MIN_PER_TARGET + for counts in self.obstruction_counts.values() + ) + + def supported_depths(self) -> tuple[int, ...]: + return tuple( + depth + for depth in self.candidate_depths + if self.evidence[depth].supported( + self.current_depth + ) + ) + + def finalize_event( + self, + frozen: FrozenPrediction, + *, + target: int, + episode: int, + scored_event_index: int, + ) -> FinalizeOutcome: + if target not in (0, 1): + raise ValueError("target must be binary") + + # Paired evidence is scored using predictions frozen before + # target revelation. + for depth in self.candidate_depths: + candidate_prediction = ( + frozen.candidate_predictions[depth] + ) + + if ( + candidate_prediction + != frozen.current_prediction + ): + if candidate_prediction == target: + self.evidence[depth].wins += 1 + else: + self.evidence[depth].losses += 1 + + # Structural obstruction evidence uses only the current + # canonical representation. + bucket = self.obstruction_counts.setdefault( + frozen.current_state, + [0, 0], + ) + bucket[target] += 1 + + # Prequential predictors learn only after this event has + # already been scored. + self.predictors[self.current_depth].update( + frozen.current_state, + target, + ) + + for depth in self.candidate_depths: + self.predictors[depth].update( + frozen.candidate_states[depth], + target, + ) + + proposal_opened = False + + if ( + not self.proposal_open + and not self.proposal_resolved + and self.candidate_depths + and self._obstruction_exists() + ): + self.proposal_open = True + proposal_opened = True + self.obstruction_episode = episode + self.obstruction_event_index = ( + scored_event_index + ) + self.discordant_at_obstruction = { + depth: self.evidence[depth].discordant + for depth in self.candidate_depths + } + + supported = () + + if self.proposal_open and not self.proposal_resolved: + supported = self.supported_depths() + + return FinalizeOutcome( + proposal_opened=proposal_opened, + supported_depths=supported, + ) + + def evidence_summaries(self) -> list[dict]: + return [ + self.evidence[depth].summary( + self.current_depth + ) + for depth in self.candidate_depths + ] + + def additional_discordant_after_obstruction( + self, + depth: int, + ) -> int | None: + if depth not in self.evidence: + return None + + before = self.discordant_at_obstruction.get( + depth + ) + + if before is None: + return None + + return ( + self.evidence[depth].discordant + - before + ) + + def mark_resolved(self) -> None: + self.proposal_open = False + self.proposal_resolved = True diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/ADAPTIVE_RULES.md b/experiments/prime_canonical_agent_benchmark_v1_3/ADAPTIVE_RULES.md new file mode 100644 index 0000000..284a556 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/ADAPTIVE_RULES.md @@ -0,0 +1,544 @@ +# PRIME Canonical Agent Benchmark v1.3 +## Frozen Factorized Deep-Evidence Rules + +Status: + + FROZEN BEFORE v1.3 ADAPTIVE IMPLEMENTATION OR RESULTS + +--- + +# 1. Current policy representations + +Permitted canonical policy depths: + + 0 + 1 + 2 + 4 + +Initial depth: + + 0 + +Policy growth is monotone. + +--- + +# 2. Obstruction + +The obstruction detector is unchanged from v1.2. + +For each current canonical representation state s maintain: + + N(s,0) + N(s,1) + +An obstruction exists when: + + N(s,0) >= 8 + +and: + + N(s,1) >= 8 + +for at least one current state. + +Only the current canonical policy representation participates in obstruction +detection. + +--- + +# 3. Verifier private history + +The verifier may maintain at most: + + 5 binary observations + +for evidential state construction. + +This private queue may never control policy actions. + +It resets at episode boundaries. + +--- + +# 4. Factorized witnesses + +For current canonical depth c, define one witness for every historical lag: + + k in {c+1, ..., 4} + +Witness state: + + Z(c,k) = + (Hc state, X[t-k]) + +Thus each witness adds exactly one omitted historical coordinate. + +Examples from H0: + + Z(0,1) = (X[t], X[t-1]) + Z(0,2) = (X[t], X[t-2]) + Z(0,3) = (X[t], X[t-3]) + Z(0,4) = (X[t], X[t-4]) + +The witness is evidential only. + +It is not an authorized policy representation. + +--- + +# 5. Prequential predictors + +Maintain: + +- one predictor for current canonical state Hc; +- one predictor for every active witness Z(c,k). + +Each predictor stores per-state target counts: + + count0 + count1 + +Prediction rule: + + predict 1 iff count1 > count0 + +Otherwise: + + predict 0 + +Therefore unseen states and ties predict 0. + +Every prediction is frozen before target revelation. + +Counts update only after: + +- policy action; +- reward; +- target reconstruction. + +No event trains itself before being scored. + +--- + +# 6. Target reconstruction + +As in v1.2: + + reward == 1: + target = action + + reward == 0: + target = 1 - action + +Only public action/reward feedback is used. + +--- + +# 7. Paired witness evidence + +For each witness k compare: + + witness prediction + +against: + + current canonical predictor + +When predictions agree: + + no paired update + +When they disagree: + + WIN: + witness correct + current wrong + + LOSS: + current correct + witness wrong + +Maintain: + + W_k + L_k + +from the beginning of the current canonical representation epoch. + +--- + +# 8. Anytime-valid witness e-process + +For each witness: + + M_k = + (3/2) ** W_k + * + (1/2) ** L_k + +Equivalent exact integer comparison: + + M_k >= T + +iff: + + 3 ** W_k + >= + T * 2 ** (W_k + L_k) + +No native floating-point evidence is used. + +--- + +# 9. Multiplicity accounting + +Across a monotone run, the maximum number of distinct witness streams is: + + current H0: + lag 1, lag 2, lag 3, lag 4 + = 4 + + current H1: + lag 2, lag 3, lag 4 + = 3 + + current H2: + lag 3, lag 4 + = 2 + +Total maximum: + + 4 + 3 + 2 = 9 + +The frozen per-witness threshold is: + + T = 576 + +For each witness, Ville's inequality bounds false threshold crossing by: + + 1 / 576 + +Using a union bound over at most nine witness streams gives: + + 9 / 576 + = + 1 / 64 + +Thus the run-level false-support budget remains at most: + + 1 / 64 + +under the frozen null assumptions. + +Optional stopping is permitted. + +--- + +# 10. Witness-to-policy depth + +Define: + + required_depth(1) = 1 + required_depth(2) = 2 + required_depth(3) = 4 + required_depth(4) = 4 + +A witness may authorize only its mapped policy representation. + +--- + +# 11. FACTOR-WITNESS-CARRIER-COST complexity + +For the factorization-only ablation retain v1.2 carrier complexity: + + C(d) = 2 ** (d + 1) + +For witness k mapping current c to required depth d: + + cost = + C(d) - C(c) + +Witness support additionally requires: + + W_k - L_k > cost + +This isolates evidence factorization from complexity repricing. + +--- + +# 12. FULL-PRIME-v1.3 complexity + +For FULL-PRIME-v1.3 use frozen coordinate-description cost: + + K(c,d) = d - c + +Witness support additionally requires: + + W_k - L_k > K(c,d) + +No development-dependent scaling factor exists. + +The larger policy representation continues to pay its empirical learning cost +through ordinary state visitation and policy learning. + +The verifier does not additionally charge the complete induced state-carrier +cardinality. + +--- + +# 13. Support rule + +A witness is supported only when BOTH are true: + +1. anytime-valid evidence: + + 3 ** W_k + >= + 576 * 2 ** (W_k + L_k) + +2. the condition-specific frozen complexity margin passes. + +No alternative threshold is permitted. + +--- + +# 14. Proposal + +At the first obstruction of a canonical representation epoch: + + open all active omitted-lag witnesses + +Evidence accumulated prequentially before obstruction is eligible. + +Before obstruction: + + evidence may accumulate + +but: + + policy representation cannot change + +After obstruction, support is evaluated after every scored event. + +--- + +# 15. Selection + +If one or more witnesses are supported: + +1. map every supported witness to its required policy depth; +2. choose the smallest required policy depth; +3. within equal required depth choose the smallest lag witness; +4. authorize that policy depth. + +Examples: + + supported lag 2 and lag 4: + choose H2 + + supported lag 3 and lag 4: + both map to H4 + choose lag 3 as canonical evidential witness + +The selected witness identity is receipted. + +--- + +# 16. Policy memory after authorization + +Private verifier history may not be copied into policy memory. + +After authorization the policy may initialize the new representation only +from state information legitimately available through the old authorized +policy representation. + +New deeper history must be acquired prospectively. + +This is identical in spirit to the v1.2 memory-separation rule. + +--- + +# 17. Representation epoch reset + +After an authorized representation change: + +- current-representation obstruction counts reset; +- witness predictor counts reset; +- witness W/L evidence resets; +- proposal state resets. + +Evidence from one canonical epoch cannot authorize a later epoch. + +--- + +# 18. End-of-run rejection + +If an obstruction opened a proposal but no witness becomes supported before +run termination: + + VERIFIER_REJECT_END_OF_RUN + +is receipted. + +Canonical policy representation remains unchanged. + +--- + +# 19. FULL-PRIME-v1.2-REFERENCE + +The reference condition must preserve the v1.2 mechanism: + +- complete candidate-state predictors; +- candidate depths H1/H2/H4 as applicable; +- v1.2 threshold 384; +- v1.2 maximum six candidate streams; +- v1.2 complexity: + + C(d) = 2 ** (d + 1) + +- v1.2 condition: + + wins - losses > + C(candidate) - C(current) + +- smallest supported candidate. + +It exists solely to test the new architecture on common fresh worlds. + +--- + +# 20. ADAPTIVE-NO-VERIFIER + +Ungated adaptation remains: + + obstruction + -> + smallest strictly deeper permitted representation + +with no verifier evidence required for authority. + +--- + +# 21. Authorization latency + +For every authorized repair record: + + obstruction_scored_event_index + + authorization_scored_event_index + +Define: + + latency = + authorization_index + - + obstruction_index + +Immediate authorization: + + latency = 0 + +For the selected witness also record: + + discordant_at_obstruction + +and: + + additional_discordant_after_obstruction + +--- + +# 22. Required receipts + +Every resolved factorized proposal receipt must include at least: + +- benchmark version; +- condition; +- world seed; +- canonical depth before; +- candidate witness lags; +- witness-to-depth mapping; +- W/L for every witness; +- exact evidence operands; +- complexity rule identifier; +- complexity cost; +- supported witnesses; +- selected witness lag; +- selected required depth; +- authorized depth; +- canonical depth after; +- obstruction index; +- authorization index; +- latency; +- previous receipt hash; +- receipt sequence. + +--- + +# 23. Tamper tests + +The implementation must detect alteration of at least: + +- witness lag; +- witness W; +- witness L; +- mapped policy depth; +- complexity rule; +- complexity cost; +- authorized depth; +- world seed; +- previous receipt hash; +- receipt deletion; +- receipt insertion; +- receipt reordering. + +--- + +# 24. Development seeds + +Adaptive development may run only: + + 300 through 331 + +Evaluation seeds: + + 3000 through 3127 + +remain inaccessible without the later frozen evaluation unlock. + +--- + +# 25. Frozen-rule discipline + +Development performance may not modify: + +- obstruction threshold 8/8; +- witness definitions; +- witness lag set; +- witness-to-policy mapping; +- prequential prediction rule; +- e-process bet; +- threshold 576; +- multiplicity count 9; +- carrier-cost ablation rule; +- coordinate-description cost; +- selection order; +- evidence epoch reset. + +A defect requiring one of these to change retires v1.3 and creates a successor. + +--- + +# 26. Falsification + +Retain negative outcomes including: + +- deep witness evidence remains slow; +- factorization-only provides no benefit; +- coordinate repricing causes false repair; +- v1.3 loses exact-depth recovery; +- v1.3 loses to v1.2 reference; +- v1.3 loses to FIXED-H4; +- increased variance eliminates apparent development gains. diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/ADAPTIVE_RULES.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/ADAPTIVE_RULES.sha256 new file mode 100644 index 0000000..5811a46 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/ADAPTIVE_RULES.sha256 @@ -0,0 +1 @@ +bdd1d0484047715767fe227c46e95f1f66dcf1d44f9bc83bea3d5214bde79b2a ADAPTIVE_RULES.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json new file mode 100644 index 0000000..78a9f03 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json @@ -0,0 +1,2721 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.3", + "by_hidden_depth": [ + { + "accepted_repairs": 0, + "condition": "ADAPTIVE-NO-VERIFIER", + "final_depth_counts": { + "0": 8 + }, + "hidden_depth": 0, + "max_authorization_latency": null, + "mean_authorization_latency": null, + "mean_final_window_reward_ppm": 953124, + "mean_primary_aulc_ppm": 945810, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME-V1.2-REFERENCE", + "final_depth_counts": { + "0": 8 + }, + "hidden_depth": 0, + "max_authorization_latency": null, + "mean_authorization_latency": null, + "mean_final_window_reward_ppm": 953124, + "mean_primary_aulc_ppm": 945810, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "FACTOR-WITNESS-CARRIER-COST", + "final_depth_counts": { + "0": 8 + }, + "hidden_depth": 0, + "max_authorization_latency": null, + "mean_authorization_latency": null, + "mean_final_window_reward_ppm": 953124, + "mean_primary_aulc_ppm": 945810, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 0, + "condition": "FULL-PRIME-V1.3", + "final_depth_counts": { + "0": 8 + }, + "hidden_depth": 0, + "max_authorization_latency": null, + "mean_authorization_latency": null, + "mean_final_window_reward_ppm": 953124, + "mean_primary_aulc_ppm": 945810, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "ADAPTIVE-NO-VERIFIER", + "final_depth_counts": { + "1": 8 + }, + "hidden_depth": 1, + "max_authorization_latency": 0, + "mean_authorization_latency": 0, + "mean_final_window_reward_ppm": 946532, + "mean_primary_aulc_ppm": 927505, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.2-REFERENCE", + "final_depth_counts": { + "1": 8 + }, + "hidden_depth": 1, + "max_authorization_latency": 9, + "mean_authorization_latency": 2, + "mean_final_window_reward_ppm": 946532, + "mean_primary_aulc_ppm": 926346, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FACTOR-WITNESS-CARRIER-COST", + "final_depth_counts": { + "1": 8 + }, + "hidden_depth": 1, + "max_authorization_latency": 17, + "mean_authorization_latency": 4, + "mean_final_window_reward_ppm": 946532, + "mean_primary_aulc_ppm": 924609, + "rejected_repairs": 0, + "selected_witness_counts": { + "1": 8 + }, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.3", + "final_depth_counts": { + "1": 8 + }, + "hidden_depth": 1, + "max_authorization_latency": 17, + "mean_authorization_latency": 4, + "mean_final_window_reward_ppm": 946532, + "mean_primary_aulc_ppm": 924609, + "rejected_repairs": 0, + "selected_witness_counts": { + "1": 8 + }, + "world_count": 8 + }, + { + "accepted_repairs": 16, + "condition": "ADAPTIVE-NO-VERIFIER", + "final_depth_counts": { + "2": 8 + }, + "hidden_depth": 2, + "max_authorization_latency": 0, + "mean_authorization_latency": 0, + "mean_final_window_reward_ppm": 949462, + "mean_primary_aulc_ppm": 901875, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.2-REFERENCE", + "final_depth_counts": { + "2": 8 + }, + "hidden_depth": 2, + "max_authorization_latency": 25, + "mean_authorization_latency": 6, + "mean_final_window_reward_ppm": 949462, + "mean_primary_aulc_ppm": 921505, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FACTOR-WITNESS-CARRIER-COST", + "final_depth_counts": { + "2": 8 + }, + "hidden_depth": 2, + "max_authorization_latency": 17, + "mean_authorization_latency": 3, + "mean_final_window_reward_ppm": 949462, + "mean_primary_aulc_ppm": 922557, + "rejected_repairs": 0, + "selected_witness_counts": { + "2": 8 + }, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.3", + "final_depth_counts": { + "2": 8 + }, + "hidden_depth": 2, + "max_authorization_latency": 17, + "mean_authorization_latency": 3, + "mean_final_window_reward_ppm": 949462, + "mean_primary_aulc_ppm": 922557, + "rejected_repairs": 0, + "selected_witness_counts": { + "2": 8 + }, + "world_count": 8 + }, + { + "accepted_repairs": 24, + "condition": "ADAPTIVE-NO-VERIFIER", + "final_depth_counts": { + "4": 8 + }, + "hidden_depth": 4, + "max_authorization_latency": 0, + "mean_authorization_latency": 0, + "mean_final_window_reward_ppm": 945312, + "mean_primary_aulc_ppm": 850285, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.2-REFERENCE", + "final_depth_counts": { + "4": 8 + }, + "hidden_depth": 4, + "max_authorization_latency": 72, + "mean_authorization_latency": 57, + "mean_final_window_reward_ppm": 945312, + "mean_primary_aulc_ppm": 880262, + "rejected_repairs": 0, + "selected_witness_counts": {}, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FACTOR-WITNESS-CARRIER-COST", + "final_depth_counts": { + "4": 8 + }, + "hidden_depth": 4, + "max_authorization_latency": 49, + "mean_authorization_latency": 32, + "mean_final_window_reward_ppm": 945312, + "mean_primary_aulc_ppm": 889407, + "rejected_repairs": 0, + "selected_witness_counts": { + "4": 8 + }, + "world_count": 8 + }, + { + "accepted_repairs": 8, + "condition": "FULL-PRIME-V1.3", + "final_depth_counts": { + "4": 8 + }, + "hidden_depth": 4, + "max_authorization_latency": 13, + "mean_authorization_latency": 5, + "mean_final_window_reward_ppm": 945312, + "mean_primary_aulc_ppm": 901571, + "rejected_repairs": 0, + "selected_witness_counts": { + "4": 8 + }, + "world_count": 8 + } + ], + "condition_summaries": { + "ADAPTIVE-NO-VERIFIER": { + "all_receipts_valid": true, + "max_authorization_latency": 0, + "mean_authorization_latency": 0, + "mean_cumulative_regret": 251, + "mean_final_window_reward_ppm": 948607, + "mean_primary_aulc_ppm": 906369, + "total_accepted_repairs": 48, + "total_proposed_repairs": 48, + "total_rejected_repairs": 0, + "world_count": 32 + }, + "FACTOR-WITNESS-CARRIER-COST": { + "all_receipts_valid": true, + "max_authorization_latency": 49, + "mean_authorization_latency": 13, + "mean_cumulative_regret": 233, + "mean_final_window_reward_ppm": 948607, + "mean_primary_aulc_ppm": 920596, + "total_accepted_repairs": 24, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0, + "world_count": 32 + }, + "FULL-PRIME-V1.2-REFERENCE": { + "all_receipts_valid": true, + "max_authorization_latency": 72, + "mean_authorization_latency": 22, + "mean_cumulative_regret": 236, + "mean_final_window_reward_ppm": 948607, + "mean_primary_aulc_ppm": 918481, + "total_accepted_repairs": 24, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0, + "world_count": 32 + }, + "FULL-PRIME-V1.3": { + "all_receipts_valid": true, + "max_authorization_latency": 17, + "mean_authorization_latency": 4, + "mean_cumulative_regret": 230, + "mean_final_window_reward_ppm": 948607, + "mean_primary_aulc_ppm": 923637, + "total_accepted_repairs": 24, + "total_proposed_repairs": 24, + "total_rejected_repairs": 0, + "world_count": 32 + } + }, + "development_seeds": [ + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331 + ], + "evaluation_seeds_run": false, + "fixed_h4_mean_primary_aulc_ppm": 917849, + "frozen_identities": { + "parent_v1_2_result_sha256": "6ce64dc7aa0bcc44ce1453788162a007ea79429d0283e69d6ba4e8c9e91028f0", + "v1_3_adaptive_rules_sha256": "bdd1d0484047715767fe227c46e95f1f66dcf1d44f9bc83bea3d5214bde79b2a", + "v1_3_contract_sha256": "c57358a6f4a7167c9d387df13a3a68e497a60fb60b8b384f7722c729627704d8", + "v1_3_fixed_comparator_sha256": "e31bf08632c4abeb9094e22f39667b2743bcc6afd6815bd80252ef810cf294e9", + "v1_3_lineage_sha256": "237b4cfbefa28fc627ace1d78d9bec1c784485c4f1a8684cbb307581d549b743" + }, + "full_v13_exact_depth_recovery": 32, + "full_v13_exact_depth_total": 32, + "implementation_sha256": "3f8082ad340af46f786a773922ec4a5a49d42fda01f77fe658b911d44afe957e", + "paired_development_deltas": { + "factor_carrier_minus_v12_reference_ppm": 2114, + "v13_minus_factor_carrier_ppm": 3040, + "v13_minus_v12_reference_ppm": 5155 + }, + "rows": [ + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 946286, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 300 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 946286, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 300 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 946286, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 300 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 946286, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 300 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 930116, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 301 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 928957, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 301 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 2 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 928957, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 301 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 2 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 928957, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 301 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 235, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 960937, + "primary_aulc_ppm": 911411, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 302 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 25 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 222, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 960937, + "primary_aulc_ppm": 923294, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 302 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 17 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 960937, + "primary_aulc_ppm": 925122, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 302 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 17 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 960937, + "primary_aulc_ppm": 925122, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 302 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 331, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 845897, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 303 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 58 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 298, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 872724, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 303 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 28 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 288, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 880623, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 303 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 276, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 890513, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 303 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 941194, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 304 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 941194, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 304 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 941194, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 304 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 941194, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 304 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 920721, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 305 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 920721, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 305 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 920721, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 305 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 920721, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 305 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 250, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 894613, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 306 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 2 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 915698, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 306 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 229, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 914540, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 306 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 229, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 914540, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 306 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 308, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 850186, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 307 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 54 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 265, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 882674, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 307 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 37 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 252, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 894068, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 307 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 13 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 240, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 904671, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 307 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 194, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 947887, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 308 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 194, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 947887, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 308 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 194, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 947887, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 308 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 194, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 947887, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 308 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 226, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 931018, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 309 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 8 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 229, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 927544, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 309 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 17 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 919436, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 309 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 17 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 939453, + "primary_aulc_ppm": 919436, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 309 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 269, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 937500, + "primary_aulc_ppm": 895752, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 310 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 242, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 937500, + "primary_aulc_ppm": 922750, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 310 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 242, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 937500, + "primary_aulc_ppm": 922750, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 310 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 242, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 937500, + "primary_aulc_ppm": 922750, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 310 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 332, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 849634, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 311 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 55 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 292, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 878456, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 311 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 29 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 278, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 889604, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 311 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 9 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 264, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 902502, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 311 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 945578, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 312 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 945578, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 312 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 945578, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 312 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 945578, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 312 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 921691, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 313 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 237, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 921691, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 313 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 238, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 920533, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 313 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 238, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 951171, + "primary_aulc_ppm": 920533, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 313 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 240, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "primary_aulc_ppm": 904239, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 314 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 4 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "primary_aulc_ppm": 923008, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 314 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 217, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "primary_aulc_ppm": 926482, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 314 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 217, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 953125, + "primary_aulc_ppm": 926482, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 314 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 310, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 859338, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 315 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 54 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 275, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 883150, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 315 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 35 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 268, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 888612, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 315 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 9 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 252, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 903766, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 315 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 223, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 941623, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 316 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 223, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 941623, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 316 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 223, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 941623, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 316 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 223, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 941623, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 316 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 232, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 930875, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 317 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 232, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 930875, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 317 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 2 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 233, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 929717, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 317 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 2 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 233, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 929717, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 317 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 241, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 906071, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 318 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 5 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 221, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 924108, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 318 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 221, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 924108, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 318 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 221, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 955078, + "primary_aulc_ppm": 924108, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 318 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 321, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 927734, + "primary_aulc_ppm": 845816, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 319 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 72 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 267, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 927734, + "primary_aulc_ppm": 886486, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 319 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 49 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 258, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 927734, + "primary_aulc_ppm": 893472, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 319 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 12 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 244, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 927734, + "primary_aulc_ppm": 904966, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 319 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 949834, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 320 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 949834, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 320 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 949834, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 320 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 200, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 949834, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 320 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 930730, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 321 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 5 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 227, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 928413, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 321 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 6 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 927255, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 321 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 6 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 228, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 927255, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 321 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 243, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 905131, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 322 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 4 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 225, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 922316, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 322 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 223, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 924267, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 322 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 223, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 941406, + "primary_aulc_ppm": 924267, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 322 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 326, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 842758, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 323 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 66 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 280, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 878545, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 323 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 32 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 269, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 886517, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 323 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 2 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 252, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 947265, + "primary_aulc_ppm": 901811, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 323 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 947121, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 324 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 947121, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 324 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 947121, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 324 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 209, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 947121, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 324 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 215, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 964843, + "primary_aulc_ppm": 928517, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 325 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 215, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 964843, + "primary_aulc_ppm": 928517, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 325 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 216, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 964843, + "primary_aulc_ppm": 927359, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 325 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 1 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 216, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 964843, + "primary_aulc_ppm": 927359, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 325 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 257, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 896568, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 326 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 233, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 919116, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 326 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 233, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 919116, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 326 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 233, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 919116, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 326 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 320, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 845122, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 327 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 51 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 277, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 872638, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 327 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 28 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 266, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 882387, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 327 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 251, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 945312, + "primary_aulc_ppm": 896505, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 327 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 212, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 946963, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 328 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 212, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 946963, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 328 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 212, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 946963, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 328 + }, + { + "accepted_repairs": 0, + "authorization_latencies": [], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 212, + "diagnostic_hidden_depth": 0, + "final_representation_depth": 0, + "final_window_reward_ppm": 958984, + "primary_aulc_ppm": 946963, + "proposed_repairs": 0, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 328 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 233, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 926373, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 329 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 9 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 235, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 924057, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 329 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 10 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 922899, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 329 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 10 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 1, + "final_representation_depth": 1, + "final_window_reward_ppm": 943359, + "primary_aulc_ppm": 922899, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 1 + ], + "source_dirty": false, + "world_seed": 329 + }, + { + "accepted_repairs": 2, + "authorization_latencies": [ + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 259, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 901221, + "proposed_repairs": 2, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 330 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 9 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 236, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 921755, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 330 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 5 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 234, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 924072, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 330 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 5 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 234, + "diagnostic_hidden_depth": 2, + "final_representation_depth": 2, + "final_window_reward_ppm": 949218, + "primary_aulc_ppm": 924072, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 2 + ], + "source_dirty": false, + "world_seed": 330 + }, + { + "accepted_repairs": 3, + "authorization_latencies": [ + 0, + 0, + 0 + ], + "condition": "ADAPTIVE-NO-VERIFIER", + "cumulative_regret": 275, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 863529, + "proposed_repairs": 3, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 331 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 51 + ], + "condition": "FULL-PRIME-V1.2-REFERENCE", + "cumulative_regret": 244, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 887429, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [], + "source_dirty": false, + "world_seed": 331 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 25 + ], + "condition": "FACTOR-WITNESS-CARRIER-COST", + "cumulative_regret": 229, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 899980, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 331 + }, + { + "accepted_repairs": 1, + "authorization_latencies": [ + 0 + ], + "condition": "FULL-PRIME-V1.3", + "cumulative_regret": 220, + "diagnostic_hidden_depth": 4, + "final_representation_depth": 4, + "final_window_reward_ppm": 957031, + "primary_aulc_ppm": 907840, + "proposed_repairs": 1, + "receipt_chain_valid": true, + "rejected_repairs": 0, + "selected_witness_lags": [ + 4 + ], + "source_dirty": false, + "world_seed": 331 + } + ], + "status": "DEVELOPMENT_ONLY_NOT_EVALUATION" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 new file mode 100644 index 0000000..5e5f907 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256 @@ -0,0 +1 @@ +691cdb8490d5e7df12c6fb11e311a727ef5ac5424b2d2dae56e457f4b8bb46b3 DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_FIXED_COMPARATOR.json b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_FIXED_COMPARATOR.json new file mode 100644 index 0000000..2a02a6c --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_FIXED_COMPARATOR.json @@ -0,0 +1,62 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.3", + "development_seeds": [ + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331 + ], + "evaluation_seed_range": "3000..3127", + "evaluation_seeds_run": false, + "rows": [ + { + "condition": "FIXED-H1", + "mean_primary_aulc_ppm": 723789, + "representation_depth": 1, + "world_count": 32 + }, + { + "condition": "FIXED-H2", + "mean_primary_aulc_ppm": 831092, + "representation_depth": 2, + "world_count": 32 + }, + { + "condition": "FIXED-H4", + "mean_primary_aulc_ppm": 917849, + "representation_depth": 4, + "world_count": 32 + } + ], + "selected_fixed_baseline": "FIXED-H4", + "selection_rule": "highest mean primary_aulc_ppm; ties select smaller representation", + "status": "DEVELOPMENT_FIXED_COMPARATOR_SELECTION" +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_FIXED_COMPARATOR.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_FIXED_COMPARATOR.sha256 new file mode 100644 index 0000000..802e4c5 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/DEVELOPMENT_FIXED_COMPARATOR.sha256 @@ -0,0 +1 @@ +e31bf08632c4abeb9094e22f39667b2743bcc6afd6815bd80252ef810cf294e9 DEVELOPMENT_FIXED_COMPARATOR.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/EVALUATION_ANALYSIS_PLAN.md b/experiments/prime_canonical_agent_benchmark_v1_3/EVALUATION_ANALYSIS_PLAN.md new file mode 100644 index 0000000..910b982 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/EVALUATION_ANALYSIS_PLAN.md @@ -0,0 +1,270 @@ +# PRIME Canonical Agent Benchmark v1.3 +## Frozen Held-Out Evaluation Analysis Plan + +Status: + + FROZEN BEFORE ANY v1.3 EVALUATION WORLD IS RUN + +Evaluation seeds: + + 3000 through 3127 inclusive + +World count: + + 128 + +Development-selected fixed comparator: + + FIXED-H4 + +Frozen hypothesis-bearing core SHA-256: + + 3f8082ad340af46f786a773922ec4a5a49d42fda01f77fe658b911d44afe957e + +--- + +# 1. Held-out conditions + +Every evaluation world is run under: + + REACTIVE + FIXED-H1 + FIXED-H2 + FIXED-H4 + ADAPTIVE-NO-VERIFIER + FULL-PRIME-V1.2-REFERENCE + FACTOR-WITNESS-CARRIER-COST + FULL-PRIME-V1.3 + +All 128 worlds are retained. + +Total condition-world rows: + + 1024 + +--- + +# 2. Primary v1.3 upgrade comparison + +For each held-out world i: + + D_i = + AULC(FULL-PRIME-V1.3, i) + - + AULC(FULL-PRIME-V1.2-REFERENCE, i) + +The primary v1.3 upgrade claim is SUPPORTED only if: + +1. paired mean D_i > 0; +2. frozen paired-bootstrap lower bound > 0; +3. mean final-window delta >= 0; +4. exact final-depth recovery of FULL-PRIME-V1.3 is not below that of + FULL-PRIME-V1.2-REFERENCE; +5. all integrity checks pass. + +Otherwise: + + NOT SUPPORTED + +--- + +# 3. Fixed-H4 comparison + +For every world: + + H_i = + AULC(FULL-PRIME-V1.3, i) + - + AULC(FIXED-H4, i) + +The fixed-memory superiority claim is SUPPORTED only if: + +1. paired mean H_i > 0; +2. frozen paired-bootstrap lower bound > 0; +3. mean final-window delta >= 0; +4. all integrity checks pass. + +Otherwise: + + NOT SUPPORTED + +This claim is separate from the primary architectural-upgrade claim. + +--- + +# 4. Factorization-only comparison + +For every world: + + F_i = + AULC(FACTOR-WITNESS-CARRIER-COST, i) + - + AULC(FULL-PRIME-V1.2-REFERENCE, i) + +The factorization-only claim is SUPPORTED only if: + +1. paired mean F_i > 0; +2. frozen paired-bootstrap lower bound > 0; +3. mean final-window delta >= 0; +4. exact final-depth recovery is not degraded relative to the v1.2 reference; +5. all integrity checks pass. + +Otherwise: + + NOT SUPPORTED + +This isolates factorized evidence while retaining the old carrier cost. + +--- + +# 5. Repricing diagnostic + +Also report: + + R_i = + AULC(FULL-PRIME-V1.3, i) + - + AULC(FACTOR-WITNESS-CARRIER-COST, i) + +A paired bootstrap interval is reported. + +This comparison is diagnostic only. + +No separately preregistered inferential claim is attached to it. + +--- + +# 6. Deterministic paired bootstrap + +Reuse the frozen v1.1/v1.2 procedure without modification. + +Replicates: + + 16384 + +Paired sample size: + + 128 + +Sampling: + + with replacement + +Seed: + + 0x5052494D45563131 + +For replicate r and draw j: + + index = + splitmix64( + BOOTSTRAP_SEED + XOR splitmix64(r) + XOR splitmix64(j) + ) + mod 128 + +Store the SUM of 128 sampled paired deltas. + +Sort replicate sums. + +Frozen zero-based interval indices: + + lower = 409 + upper = 15974 + +A lower confidence bound is positive iff: + + sorted_bootstrap_sums[409] > 0 + +No post-evaluation interval selection or alternative test is permitted. + +--- + +# 7. Structural diagnostics + +For: + + FULL-PRIME-V1.2-REFERENCE + FACTOR-WITNESS-CARRIER-COST + FULL-PRIME-V1.3 + +report: + +- exact final-depth recovery; +- final-depth distribution by hidden depth; +- proposal count; +- accepted repair count; +- rejected repair count; +- verifier-supported repair count; +- unnecessary repairs in d=0 worlds; +- receipt-chain integrity. + +For FULL-PRIME-V1.3, 128/128 remains the strongest structural gate. + +--- + +# 8. Deep-evidence diagnostics + +For the three verifier-governed adaptive conditions report, overall and by +hidden depth: + +- mean authorization latency in scored events; +- maximum authorization latency; +- immediate authorization count; +- selected witness-lag distribution where applicable. + +The central d=4 mechanistic comparison is: + + FULL-PRIME-V1.2-REFERENCE + versus + FACTOR-WITNESS-CARRIER-COST + versus + FULL-PRIME-V1.3 + +Development values are not part of the held-out success criterion. + +--- + +# 9. Integrity requirements + +Before evaluation: + +- Git worktree clean; +- frozen contract valid; +- frozen lineage valid; +- frozen adaptive rules valid; +- frozen fixed comparator valid; +- frozen development diagnostic valid; +- parent v1.2 result valid; +- comparator remains FIXED-H4; +- core implementation SHA-256 exactly: + + 3f8082ad340af46f786a773922ec4a5a49d42fda01f77fe658b911d44afe957e + +During evaluation: + +- adaptive source_dirty=false; +- adaptive source commit equals frozen evaluation source commit; +- adaptive core hash equals frozen core hash; +- all receipt chains verify against count and tip; +- every condition yields exactly 128 worlds. + +Output must be outside the Git repository. + +--- + +# 10. Claim boundary + +A positive v1.3 result is controlled mechanistic benchmark evidence. + +It does not establish: + +- AGI; +- universal POMDP superiority; +- superiority over learned recurrent memory; +- universal superiority over fixed memory; +- production security; +- broad real-world generality. + +A separately frozen learned-memory benchmark remains required. diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/EVALUATION_ANALYSIS_PLAN.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/EVALUATION_ANALYSIS_PLAN.sha256 new file mode 100644 index 0000000..ac59790 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/EVALUATION_ANALYSIS_PLAN.sha256 @@ -0,0 +1 @@ +6374cfc603f9434873b4707ac47ce1a77e06b21df7d4e136889756eac1934d46 EVALUATION_ANALYSIS_PLAN.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/EXPERIMENT_CONTRACT.md b/experiments/prime_canonical_agent_benchmark_v1_3/EXPERIMENT_CONTRACT.md new file mode 100644 index 0000000..a16a1ad --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/EXPERIMENT_CONTRACT.md @@ -0,0 +1,528 @@ +# PRIME Canonical Agent Benchmark v1.3 +## Factorized Deep-Evidence Experiment + +Status: + + FROZEN BEFORE v1.3 ADAPTIVE IMPLEMENTATION OR RESULTS + +v1.3 is a successor to the completed PRIME Canonical Agent Benchmark v1.2. + +v1.2 remains immutable. + +--- + +# 1. Parent result + +PRIME v1.2 held-out evaluation: + + final commit: + 6f17789 + + held-out worlds: + 128 + + FULL-PRIME-v1.2 AULC: + 918754 ppm + + FIXED-H4 AULC: + 918084 ppm + + FULL minus FIXED-H4: + +669 ppm + + frozen bootstrap interval: + [-3644, +4983] ppm + + primary superiority claim: + NOT SUPPORTED + + FULL minus ADAPTIVE-NO-VERIFIER: + +13102 ppm + + verifier-specific frozen interval: + [+10414, +15817] ppm + + verifier-specific claim: + SUPPORTED + + exact final-depth recovery: + 128 / 128 + + mean FULL authorization latency: + 25 scored events + + d=4 mean authorization latency: + 64 scored events + + d=4 maximum authorization latency: + 100 scored events + +The principal remaining mechanistic bottleneck is deep-representation evidence +cost. + +--- + +# 2. v1.3 research question + +Can PRIME reduce the evidence complexity of discovering deep memory +requirements while preserving: + +- verifier sovereignty; +- anytime-valid evidence; +- exact minimal representation selection; +- policy/verifier memory separation; +- deterministic receipts; +- held-out adaptive performance? + +v1.3 specifically tests whether predictive evidence can be factorized over +new historical coordinates instead of requiring the verifier to estimate the +entire deeper representation carrier. + +--- + +# 3. Reused task family + +v1.3 reuses the canonical MemoryAlias-POMDP substrate. + +Permitted policy representations remain: + + H0 + H1 + H2 + H4 + +The policy still begins at: + + H0 + +The environment semantics, horizon, reward interface and common learner are +not changed to make v1.3 easier. + +--- + +# 4. Fresh worlds + +v1.1 and v1.2 held-out worlds are permanently burned. + +v1.3 development seeds: + + 300 through 331 inclusive + +Count: + + 32 + +v1.3 held-out evaluation seeds: + + 3000 through 3127 inclusive + +Count: + + 128 + +Evaluation seeds may not be run during development. + +--- + +# 5. Core v1.3 experimental distinction + +v1.2 candidate evidence predicts using the complete candidate representation. + +Example: + + H0 -> H4 + +requires a verifier predictor over a five-bit H4 state carrier. + +v1.3 introduces factorized lag witnesses. + +For current canonical depth c and omitted historical coordinate k where: + + k > c + +define witness state: + + W(c,k) = + (current canonical state Hc, observation at lag k) + +The witness therefore adds one historical coordinate to the currently +authorized state for evidential purposes. + +It is not itself a policy representation. + +It cannot control actions. + +--- + +# 6. Witness-to-policy mapping + +A supported witness authorizes the smallest permitted policy representation +containing that historical coordinate. + +Frozen mapping: + + lag 1 -> H1 + lag 2 -> H2 + lag 3 -> H4 + lag 4 -> H4 + +Examples: + + from H0: + lag-1 witness -> H1 + lag-2 witness -> H2 + lag-3 witness -> H4 + lag-4 witness -> H4 + + from H1: + lag-2 witness -> H2 + lag-3 witness -> H4 + lag-4 witness -> H4 + +Witness support is evidence for required representational capacity. + +It is not policy authority until canonical authorization occurs. + +--- + +# 7. Conditions + +Every v1.3 held-out world must include at least: + + REACTIVE + FIXED-H1 + FIXED-H2 + FIXED-H4 + ADAPTIVE-NO-VERIFIER + FULL-PRIME-V1.2-REFERENCE + FACTOR-WITNESS-CARRIER-COST + FULL-PRIME-V1.3 + +The purpose of the two factorized conditions is to separate: + + evidence factorization + +from: + + complexity repricing + +so that a positive result cannot automatically be attributed to both. + +--- + +# 8. FULL-PRIME-v1.2-REFERENCE + +This condition reproduces the v1.2 adaptive logic on the fresh v1.3 worlds: + +- complete-candidate prequential predictors; +- v1.2 anytime-valid evidence rule; +- v1.2 representation complexity rule; +- v1.2 smallest-supported candidate selection. + +The implementation must be behaviourally equivalent to frozen v1.2 logic +except for use of the v1.3 seed sets and v1.3 provenance wrapper. + +This condition is the primary mechanistic comparator. + +--- + +# 9. FACTOR-WITNESS-CARRIER-COST + +This ablation uses: + +- factorized lag-witness predictors; +- v1.3 witness evidence; +- but the old v1.2 exponential carrier complexity penalty. + +Thus it isolates the effect of evidence factorization while retaining the old +complexity pricing. + +--- + +# 10. FULL-PRIME-v1.3 + +FULL-PRIME-v1.3 uses: + +- factorized lag-witness evidence; +- anytime-valid sequential support; +- direct minimal policy-depth authorization; +- coordinate-description representation cost; +- canonical receipts; +- no candidate-memory leakage into policy state. + +This is the full v1.3 mechanism. + +--- + +# 11. Why complexity pricing changes + +v1.2 used: + + C(d) = 2 ** (d + 1) + +and required: + + wins - losses > + C(candidate) - C(current) + +For H0 -> H4 this imposes a cost of: + + 30 + +The policy learner already pays for the larger H4 carrier through sparse +state visitation and slower parameter learning. + +v1.3 tests whether additionally charging the verifier the full induced +tabular-carrier cardinality double-prices representational complexity. + +The full v1.3 condition therefore prices the additional memory description +itself rather than the complete induced carrier. + +Frozen coordinate-description cost: + + K(c,d) = d - c + +Examples: + + H0 -> H1: + 1 + + H0 -> H2: + 2 + + H0 -> H4: + 4 + + H2 -> H4: + 2 + +This rule is frozen before adaptive results. + +--- + +# 12. Statistical validity + +Factorization must not weaken the run-level false-support budget. + +All witness evidence is: + +- prequential; +- deterministic; +- paired against the current canonical predictor; +- anytime-valid; +- evaluated without native floating-point arithmetic. + +The exact e-process and multiplicity accounting are frozen separately before +implementation. + +--- + +# 13. Primary v1.3 mechanistic claim + +For every held-out world i define: + + D_i = + AULC(FULL-PRIME-v1.3, i) + - + AULC(FULL-PRIME-v1.2-REFERENCE, i) + +The primary v1.3 upgrade claim is supported only if: + +1. mean paired D_i > 0; +2. frozen deterministic paired-bootstrap lower bound > 0; +3. exact final-depth recovery is not degraded relative to the v1.2 reference; +4. mean final-window performance is not degraded; +5. all integrity checks pass. + +This tests whether the new evidence architecture actually improves the parent +mechanism. + +--- + +# 14. Fixed-H4 boundary + +A separate comparison remains: + + FULL-PRIME-v1.3 + versus + development-selected fixed representation + +The fixed comparator is selected on v1.3 development worlds before adaptive +development results are inspected. + +A superiority claim over that fixed comparator requires the same frozen +paired-bootstrap criterion used in v1.2. + +This comparison is reported separately from the primary mechanistic claim. + +--- + +# 15. Factorization-only ablation + +Report paired performance: + + FACTOR-WITNESS-CARRIER-COST + minus + FULL-PRIME-v1.2-REFERENCE + +This isolates the effect of factorized evidence while retaining v1.2 +complexity pricing. + +--- + +# 16. Repricing increment + +Report paired performance: + + FULL-PRIME-v1.3 + minus + FACTOR-WITNESS-CARRIER-COST + +This measures the additional effect of coordinate-description pricing after +factorization. + +It is an ablation diagnostic unless separately frozen as an inferential claim. + +--- + +# 17. Structural preservation + +Report for every adaptive condition: + +- final policy depth; +- exact required-depth recovery; +- unnecessary d=0 repairs; +- proposal count; +- accepted repair count; +- rejected repair count; +- authorization latency; +- receipt-chain validity. + +The strongest structural preservation result requires: + + FULL-PRIME-v1.3 exact final-depth recovery = 128/128 + +No performance gain may be described as successful exact repair if this gate +fails. + +--- + +# 18. Deep-evidence diagnostic + +For held-out d=4 worlds report: + +- mean authorization latency; +- maximum authorization latency; +- evidence already available at obstruction; +- additional discordant events after obstruction. + +The central mechanistic diagnostic is whether FULL-PRIME-v1.3 reduces d=4 +authorization latency relative to FULL-PRIME-v1.2-REFERENCE on the same fresh +worlds. + +--- + +# 19. Policy/verifier separation + +The verifier may maintain the bounded observation history required to score +witnesses. + +The policy may access only its currently authorized canonical representation. + +A witness may never: + +- control the policy; +- initialize unauthorized policy memory; +- alter policy Q-values; +- expose hidden depth; +- copy private verifier history into policy memory after repair. + +Upon authorization, policy memory is initialized only from observations +legitimately available under the prior authorized policy state plus future +observations. + +--- + +# 20. Receipts + +All authoritative repair decisions remain: + +- deterministic; +- canonical; +- provenance-bound; +- hash chained; +- replayable; +- tamper detectable; +- free of timestamps; +- free of random UUIDs; +- free of native JSON floats. + +Witness identity and witness evidence must be included in authorization +receipts. + +--- + +# 21. Development discipline + +Development seeds may be used to: + +- implement frozen rules; +- debug defects; +- run invariant tests; +- select the fixed comparator; +- inspect development diagnostics. + +After factorized adaptive rules are frozen, poor adaptive performance may not +be used to tune: + +- witness definitions; +- evidence threshold; +- multiplicity correction; +- complexity pricing; +- witness-to-policy mapping. + +A substantive change requires a successor benchmark. + +--- + +# 22. Evaluation discipline + +Before seeds 3000 through 3127 are unlocked: + +- contract must be frozen; +- factorized adaptive rules must be frozen; +- fixed comparator must be frozen; +- implementation must be committed; +- tests must pass; +- development diagnostic must be frozen; +- implementation hash must be frozen; +- analysis plan must be frozen; +- evaluation harness must be frozen; +- Git worktree must be clean. + +--- + +# 23. Learned-memory boundary + +v1.3 remains a controlled representation-repair experiment. + +It does not yet establish superiority over recurrent learned-memory agents. + +A GRU/RNN or comparable learned-memory baseline remains a required subsequent +benchmark. + +--- + +# 24. Falsification + +Scientifically valid negative outcomes include: + +- factorization fails to reduce d=4 latency; +- factorized witnesses cause incorrect deep repairs; +- v1.3 loses to the v1.2 reference; +- coordinate repricing increases unnecessary repair; +- exact-depth recovery falls below the parent reference; +- fixed H4 remains superior; +- no measurable performance benefit occurs. + +These results must be retained rather than tuned away. diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/EXPERIMENT_CONTRACT.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/EXPERIMENT_CONTRACT.sha256 new file mode 100644 index 0000000..ba97974 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/EXPERIMENT_CONTRACT.sha256 @@ -0,0 +1 @@ +c57358a6f4a7167c9d387df13a3a68e497a60fb60b8b384f7722c729627704d8 EXPERIMENT_CONTRACT.md diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/FROZEN_EVALUATION_RESULT.json b/experiments/prime_canonical_agent_benchmark_v1_3/FROZEN_EVALUATION_RESULT.json new file mode 100644 index 0000000..cbe7e94 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/FROZEN_EVALUATION_RESULT.json @@ -0,0 +1 @@ +{"adaptive_depth_diagnostics":{"FACTOR-WITNESS-CARRIER-COST":[{"accepted_repairs":0,"final_depth_counts":{"0":32},"hidden_depth":0,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_final_window_reward_ppm":946960,"mean_primary_aulc_ppm":948055,"rejected_repairs":0,"selected_witness_counts":{},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"1":32},"hidden_depth":1,"immediate_authorizations":13,"max_authorization_latency":16,"mean_authorization_latency":4,"mean_final_window_reward_ppm":950133,"mean_primary_aulc_ppm":926720,"rejected_repairs":0,"selected_witness_counts":{"1":32},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"2":32},"hidden_depth":2,"immediate_authorizations":15,"max_authorization_latency":19,"mean_authorization_latency":3,"mean_final_window_reward_ppm":949218,"mean_primary_aulc_ppm":922239,"rejected_repairs":0,"selected_witness_counts":{"2":32},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"4":32},"hidden_depth":4,"immediate_authorizations":0,"max_authorization_latency":57,"mean_authorization_latency":34,"mean_final_window_reward_ppm":949035,"mean_primary_aulc_ppm":887971,"rejected_repairs":0,"selected_witness_counts":{"4":32},"world_count":32}],"FULL-PRIME-V1.2-REFERENCE":[{"accepted_repairs":0,"final_depth_counts":{"0":32},"hidden_depth":0,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_final_window_reward_ppm":946960,"mean_primary_aulc_ppm":948055,"rejected_repairs":0,"selected_witness_counts":{},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"1":32},"hidden_depth":1,"immediate_authorizations":18,"max_authorization_latency":12,"mean_authorization_latency":2,"mean_final_window_reward_ppm":950133,"mean_primary_aulc_ppm":927262,"rejected_repairs":0,"selected_witness_counts":{},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"2":32},"hidden_depth":2,"immediate_authorizations":3,"max_authorization_latency":19,"mean_authorization_latency":6,"mean_final_window_reward_ppm":949218,"mean_primary_aulc_ppm":921004,"rejected_repairs":0,"selected_witness_counts":{},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"4":32},"hidden_depth":4,"immediate_authorizations":0,"max_authorization_latency":78,"mean_authorization_latency":59,"mean_final_window_reward_ppm":949035,"mean_primary_aulc_ppm":878948,"rejected_repairs":0,"selected_witness_counts":{},"world_count":32}],"FULL-PRIME-V1.3":[{"accepted_repairs":0,"final_depth_counts":{"0":32},"hidden_depth":0,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_final_window_reward_ppm":946960,"mean_primary_aulc_ppm":948055,"rejected_repairs":0,"selected_witness_counts":{},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"1":32},"hidden_depth":1,"immediate_authorizations":13,"max_authorization_latency":16,"mean_authorization_latency":4,"mean_final_window_reward_ppm":950133,"mean_primary_aulc_ppm":926720,"rejected_repairs":0,"selected_witness_counts":{"1":32},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"2":32},"hidden_depth":2,"immediate_authorizations":15,"max_authorization_latency":19,"mean_authorization_latency":3,"mean_final_window_reward_ppm":949218,"mean_primary_aulc_ppm":922239,"rejected_repairs":0,"selected_witness_counts":{"2":32},"world_count":32},{"accepted_repairs":32,"final_depth_counts":{"4":32},"hidden_depth":4,"immediate_authorizations":9,"max_authorization_latency":17,"mean_authorization_latency":4,"mean_final_window_reward_ppm":949035,"mean_primary_aulc_ppm":900376,"rejected_repairs":0,"selected_witness_counts":{"4":32},"world_count":32}]},"benchmark":"prime-canonical-agent-benchmark-v1.3","condition_count":8,"condition_summaries":{"ADAPTIVE-NO-VERIFIER":{"all_receipt_chains_valid":true,"exact_depth_recovery":128,"immediate_authorizations":192,"max_authorization_latency":0,"mean_authorization_latency":0,"mean_cumulative_regret":251,"mean_final_window_reward_ppm":948836,"mean_primary_aulc_ppm":904833,"total_accepted_repairs":192,"total_proposed_repairs":192,"total_rejected_repairs":0,"total_verifier_supported_repairs":0,"world_count":128},"FACTOR-WITNESS-CARRIER-COST":{"all_receipt_chains_valid":true,"exact_depth_recovery":128,"immediate_authorizations":28,"max_authorization_latency":57,"mean_authorization_latency":13,"mean_cumulative_regret":231,"mean_final_window_reward_ppm":948836,"mean_primary_aulc_ppm":921246,"total_accepted_repairs":96,"total_proposed_repairs":96,"total_rejected_repairs":0,"total_verifier_supported_repairs":96,"world_count":128},"FIXED-H1":{"all_receipt_chains_valid":true,"exact_depth_recovery":32,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_cumulative_regret":1128,"mean_final_window_reward_ppm":725066,"mean_primary_aulc_ppm":721981,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"total_verifier_supported_repairs":0,"world_count":128},"FIXED-H2":{"all_receipt_chains_valid":true,"exact_depth_recovery":32,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_cumulative_regret":669,"mean_final_window_reward_ppm":836349,"mean_primary_aulc_ppm":831280,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"total_verifier_supported_repairs":0,"world_count":128},"FIXED-H4":{"all_receipt_chains_valid":true,"exact_depth_recovery":32,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_cumulative_regret":234,"mean_final_window_reward_ppm":948836,"mean_primary_aulc_ppm":918191,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"total_verifier_supported_repairs":0,"world_count":128},"FULL-PRIME-V1.2-REFERENCE":{"all_receipt_chains_valid":true,"exact_depth_recovery":128,"immediate_authorizations":21,"max_authorization_latency":78,"mean_authorization_latency":22,"mean_cumulative_regret":234,"mean_final_window_reward_ppm":948836,"mean_primary_aulc_ppm":918817,"total_accepted_repairs":96,"total_proposed_repairs":96,"total_rejected_repairs":0,"total_verifier_supported_repairs":96,"world_count":128},"FULL-PRIME-V1.3":{"all_receipt_chains_valid":true,"exact_depth_recovery":128,"immediate_authorizations":37,"max_authorization_latency":19,"mean_authorization_latency":4,"mean_cumulative_regret":228,"mean_final_window_reward_ppm":948836,"mean_primary_aulc_ppm":924347,"total_accepted_repairs":96,"total_proposed_repairs":96,"total_rejected_repairs":0,"total_verifier_supported_repairs":96,"world_count":128},"REACTIVE":{"all_receipt_chains_valid":true,"exact_depth_recovery":32,"immediate_authorizations":0,"max_authorization_latency":null,"mean_authorization_latency":null,"mean_cumulative_regret":1587,"mean_final_window_reward_ppm":611907,"mean_primary_aulc_ppm":611823,"total_accepted_repairs":0,"total_proposed_repairs":0,"total_rejected_repairs":0,"total_verifier_supported_repairs":0,"world_count":128}},"evaluation_seed_count":128,"evaluation_seeds":[3000,3001,3002,3003,3004,3005,3006,3007,3008,3009,3010,3011,3012,3013,3014,3015,3016,3017,3018,3019,3020,3021,3022,3023,3024,3025,3026,3027,3028,3029,3030,3031,3032,3033,3034,3035,3036,3037,3038,3039,3040,3041,3042,3043,3044,3045,3046,3047,3048,3049,3050,3051,3052,3053,3054,3055,3056,3057,3058,3059,3060,3061,3062,3063,3064,3065,3066,3067,3068,3069,3070,3071,3072,3073,3074,3075,3076,3077,3078,3079,3080,3081,3082,3083,3084,3085,3086,3087,3088,3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3099,3100,3101,3102,3103,3104,3105,3106,3107,3108,3109,3110,3111,3112,3113,3114,3115,3116,3117,3118,3119,3120,3121,3122,3123,3124,3125,3126,3127],"factorization_only_comparison":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":1698,"lower_sum_delta":217397,"observed_mean_delta_ppm":2428,"observed_sum_delta":310863,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":3187,"upper_sum_delta":408008},"bootstrap_lower_positive":true,"claim":"SUPPORTED","final_not_degraded":true,"integrity_pass":true,"left_condition":"FACTOR-WITNESS-CARRIER-COST","left_exact_depth_recovery":128,"mean_delta_positive":true,"mean_final_delta_ppm":0,"recovery_preservation_required":true,"recovery_preserved":true,"right_condition":"FULL-PRIME-V1.2-REFERENCE","right_exact_depth_recovery":128},"fixed_h4_comparison":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":3220,"lower_sum_delta":412240,"observed_mean_delta_ppm":6155,"observed_sum_delta":787947,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":9151,"upper_sum_delta":1171407},"bootstrap_lower_positive":true,"claim":"SUPPORTED","final_not_degraded":true,"integrity_pass":true,"left_condition":"FULL-PRIME-V1.3","left_exact_depth_recovery":128,"mean_delta_positive":true,"mean_final_delta_ppm":0,"recovery_preservation_required":false,"recovery_preserved":true,"right_condition":"FIXED-H4","right_exact_depth_recovery":32},"integrity_pass":true,"preflight":{"analysis_plan_sha256":"6374cfc603f9434873b4707ac47ce1a77e06b21df7d4e136889756eac1934d46","core_implementation_sha256":"3f8082ad340af46f786a773922ec4a5a49d42fda01f77fe658b911d44afe957e","development_diagnostic_sha256":"691cdb8490d5e7df12c6fb11e311a727ef5ac5424b2d2dae56e457f4b8bb46b3","evaluation_harness_sha256":"2c43ef2595a744a9a0d63195d0b106f09e66c383262d5251aee47a87be057451","frozen_identities":{"parent_v1_2_result_sha256":"6ce64dc7aa0bcc44ce1453788162a007ea79429d0283e69d6ba4e8c9e91028f0","v1_3_adaptive_rules_sha256":"bdd1d0484047715767fe227c46e95f1f66dcf1d44f9bc83bea3d5214bde79b2a","v1_3_contract_sha256":"c57358a6f4a7167c9d387df13a3a68e497a60fb60b8b384f7722c729627704d8","v1_3_fixed_comparator_sha256":"e31bf08632c4abeb9094e22f39667b2743bcc6afd6815bd80252ef810cf294e9","v1_3_lineage_sha256":"237b4cfbefa28fc627ace1d78d9bec1c784485c4f1a8684cbb307581d549b743"},"selected_fixed_comparator":"FIXED-H4","source_commit":"dda47f6ec3cdfc611e27bd7f2f9a8ec16c1cf28d"},"primary_upgrade_v13_vs_v12_reference":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":3921,"lower_sum_delta":501981,"observed_mean_delta_ppm":5529,"observed_sum_delta":707824,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":7200,"upper_sum_delta":921618},"bootstrap_lower_positive":true,"claim":"SUPPORTED","final_not_degraded":true,"integrity_pass":true,"left_condition":"FULL-PRIME-V1.3","left_exact_depth_recovery":128,"mean_delta_positive":true,"mean_final_delta_ppm":0,"recovery_preservation_required":true,"recovery_preserved":true,"right_condition":"FULL-PRIME-V1.2-REFERENCE","right_exact_depth_recovery":128},"repricing_diagnostic":{"bootstrap":{"lower_index":409,"lower_mean_delta_ppm":2158,"lower_sum_delta":276224,"observed_mean_delta_ppm":3101,"observed_sum_delta":396961,"replicates":16384,"sample_size":128,"seed_hex":"0x5052494d45563131","upper_index":15974,"upper_mean_delta_ppm":4090,"upper_sum_delta":523596},"left_condition":"FULL-PRIME-V1.3","right_condition":"FACTOR-WITNESS-CARRIER-COST","status":"DIAGNOSTIC_ONLY"},"row_count":1024,"rows":[{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951006,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":948689,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":944056,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":922176,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951006,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951006,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951006,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":951006,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3000},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2032,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":500236,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3001},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":205,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":946397,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3001},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":941764,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3001},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":920432,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3001},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":925550,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3001},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":925550,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3001},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":925550,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3001},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":925550,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3001},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2075,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":472656,"primary_aulc_ppm":504584,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3002},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2025,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":501288,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3002},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":936947,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3002},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":253,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":914335,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3002},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":274,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":893919,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3002},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":249,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":917258,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3002},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":250,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":916100,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3002},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.3","cumulative_regret":250,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":916100,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3002},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2037,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":499095,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3003},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2009,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":519531,"primary_aulc_ppm":498516,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3003},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2017,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":515625,"primary_aulc_ppm":498680,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3003},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":214,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":922603,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3003},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":296,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":858399,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3003},{"accepted_repairs":1,"authorization_latencies":[56],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":257,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":884134,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3003},{"accepted_repairs":1,"authorization_latencies":[27],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":243,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":895608,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3003},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.3","cumulative_regret":228,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":910051,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3003},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":230,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":942538,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":231,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":941380,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":235,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":936747,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":257,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":913709,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":230,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":942538,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":230,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":942538,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":230,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":942538,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":230,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":942538,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3004},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2042,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":503140,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3005},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":206,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":944293,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3005},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":210,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":939660,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3005},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":917110,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3005},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":926920,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3005},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":926920,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3005},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":924604,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3005},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.3","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":924604,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3005},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2035,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":505418,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3006},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":1994,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":520905,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3006},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":200,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":944894,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3006},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":221,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":923380,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3006},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":239,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":904120,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3006},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":218,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":924291,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3006},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":219,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":922889,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3006},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FULL-PRIME-V1.3","cumulative_regret":219,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":922889,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3006},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2049,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":508834,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3007},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2046,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":494820,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3007},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2056,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":507812,"primary_aulc_ppm":508394,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3007},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":916428,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3007},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":339,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":840065,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3007},{"accepted_repairs":1,"authorization_latencies":[47],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":277,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":887890,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3007},{"accepted_repairs":1,"authorization_latencies":[31],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":271,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":893036,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3007},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FULL-PRIME-V1.3","cumulative_regret":260,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":903387,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3007},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":947247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":222,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":944930,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":941456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":918721,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":947247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":947247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":947247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":947247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3008},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2013,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":525390,"primary_aulc_ppm":497281,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3009},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":202,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":947325,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3009},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":943851,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3009},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":919269,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3009},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":931111,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3009},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":216,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":931111,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3009},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":929953,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3009},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.3","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":929953,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3009},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2061,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":537109,"primary_aulc_ppm":483599,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3010},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2050,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":490769,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3010},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942179,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3010},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918775,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3010},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":244,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":905305,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3010},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":927123,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3010},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":927123,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3010},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":927123,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3010},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2032,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":509173,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3011},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2038,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":495046,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3011},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2047,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":480468,"primary_aulc_ppm":496555,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3011},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":916748,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3011},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":342,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":826284,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3011},{"accepted_repairs":1,"authorization_latencies":[51],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":276,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":873419,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3011},{"accepted_repairs":1,"authorization_latencies":[27],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":269,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":878963,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3011},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":254,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":893528,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3011},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":941927,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":938452,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":915902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":944243,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3012},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2057,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":506991,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3013},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":216,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":946435,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3013},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":941802,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3013},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":917484,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3013},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":233,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":926746,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3013},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":233,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":926746,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3013},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":233,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":926746,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3013},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":233,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":926746,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3013},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2000,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":531606,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3014},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2010,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":525667,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3014},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":219,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":940780,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3014},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":917316,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3014},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":250,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":909271,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3014},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":926212,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3014},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":231,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":927126,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3014},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":231,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":927126,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3014},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2051,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":457031,"primary_aulc_ppm":509518,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3015},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2040,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":504134,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3015},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":1996,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":484375,"primary_aulc_ppm":513410,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3015},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":918898,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3015},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":329,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":843473,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3015},{"accepted_repairs":1,"authorization_latencies":[56],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":276,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":881951,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3015},{"accepted_repairs":1,"authorization_latencies":[37],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":268,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":889040,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3015},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FULL-PRIME-V1.3","cumulative_regret":253,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":901469,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3015},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":950379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":949221,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":944588,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":921612,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":950379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":950379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":950379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":950379,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3016},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2043,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":455078,"primary_aulc_ppm":497032,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3017},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":194,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":949216,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3017},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":198,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":944583,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3017},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":920021,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3017},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":934160,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3017},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":207,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":934160,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3017},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":209,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":931844,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3017},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.3","cumulative_regret":209,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":931844,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3017},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2045,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":499486,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3018},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2031,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":488281,"primary_aulc_ppm":508230,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3018},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":943131,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3018},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":918568,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3018},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":257,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":898944,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3018},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":922528,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3018},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":922528,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3018},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":922528,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3018},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":1978,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":513671,"primary_aulc_ppm":518666,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3019},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2009,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":511982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3019},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2003,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":492187,"primary_aulc_ppm":517200,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3019},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":219,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":923466,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3019},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":317,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":848457,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3019},{"accepted_repairs":1,"authorization_latencies":[56],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":260,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":887536,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3019},{"accepted_repairs":1,"authorization_latencies":[41],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":247,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":899175,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3019},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":237,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":907257,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3019},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":943647,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":942489,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":937856,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":914695,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":943647,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":943647,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":943647,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":943647,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3020},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2056,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":503965,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3021},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":203,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":947510,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3021},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":206,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":944036,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3021},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":923132,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3021},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":219,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":928980,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3021},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":924591,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3021},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":923433,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3021},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FULL-PRIME-V1.3","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":923433,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3021},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2063,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":499303,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3022},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2066,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":511718,"primary_aulc_ppm":497921,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3022},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":939920,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3022},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":917552,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3022},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":256,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":893418,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3022},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":923706,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3022},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":923706,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3022},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":923706,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3022},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2087,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":464843,"primary_aulc_ppm":488985,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3023},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2096,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":533203,"primary_aulc_ppm":481234,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3023},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2072,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":476562,"primary_aulc_ppm":489218,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3023},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":250,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":913711,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3023},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":335,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":842292,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3023},{"accepted_repairs":1,"authorization_latencies":[59],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":290,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":876986,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3023},{"accepted_repairs":1,"authorization_latencies":[36],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":278,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":887589,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3023},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.3","cumulative_regret":265,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":899390,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3023},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":204,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947573,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":945257,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":940624,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":917464,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":204,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947573,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":204,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947573,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":204,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947573,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":204,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":951171,"primary_aulc_ppm":947573,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3024},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2067,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":510753,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3025},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":210,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":948401,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3025},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":944927,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3025},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":920305,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3025},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":931029,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3025},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":931029,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3025},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":931029,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3025},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":931029,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3025},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2023,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":492547,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3026},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2065,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":485561,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3026},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":938757,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3026},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":914764,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3026},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":260,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":890120,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3026},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":235,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":915168,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3026},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":237,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":912119,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3026},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":237,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":912119,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3026},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2034,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":460937,"primary_aulc_ppm":505291,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3027},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2085,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":466796,"primary_aulc_ppm":497598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3027},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2062,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":482421,"primary_aulc_ppm":503399,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3027},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916439,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3027},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":331,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":835236,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3027},{"accepted_repairs":1,"authorization_latencies":[50],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":276,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":876951,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3027},{"accepted_repairs":1,"authorization_latencies":[33],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":266,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":885481,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3027},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.3","cumulative_regret":252,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":897789,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3027},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949839,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":947522,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":942890,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":247,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":919059,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949839,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949839,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949839,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":949839,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3028},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2063,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":480958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3029},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":216,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":941592,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3029},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":936959,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3029},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":913798,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3029},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":917270,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3029},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":917270,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3029},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":916112,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3029},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":916112,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3029},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":1999,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":548828,"primary_aulc_ppm":510298,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3030},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2009,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":542968,"primary_aulc_ppm":507807,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3030},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":200,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":940479,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3030},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":915306,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3030},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":246,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":892574,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3030},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":226,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":910611,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3030},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":912927,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3030},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.3","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":912927,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3030},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2040,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":506114,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3031},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2063,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":466796,"primary_aulc_ppm":492810,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3031},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2060,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":468750,"primary_aulc_ppm":480777,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3031},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":232,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":929687,"primary_aulc_ppm":919203,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3031},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":340,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":929687,"primary_aulc_ppm":830317,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3031},{"accepted_repairs":1,"authorization_latencies":[68],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":273,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":929687,"primary_aulc_ppm":881930,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3031},{"accepted_repairs":1,"authorization_latencies":[30],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":262,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":929687,"primary_aulc_ppm":889788,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3031},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":248,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":929687,"primary_aulc_ppm":901526,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3031},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":951750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":203,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":949434,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":944801,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":919690,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":951750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":951750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":951750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":951750,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3032},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2061,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":492700,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3033},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":212,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":943876,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3033},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":215,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":940402,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3033},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":916468,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3033},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":926504,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3033},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":924187,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3033},{"accepted_repairs":1,"authorization_latencies":[7],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":231,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":921871,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3033},{"accepted_repairs":1,"authorization_latencies":[7],"condition":"FULL-PRIME-V1.3","cumulative_regret":231,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":921871,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3033},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2038,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":500000,"primary_aulc_ppm":509518,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3034},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":1999,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":533203,"primary_aulc_ppm":512845,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3034},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":191,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":947730,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3034},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":923777,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3034},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":898425,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3034},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":206,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":930845,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3034},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":205,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":931759,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3034},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":205,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":931759,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3034},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2061,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":489389,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3035},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2023,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":508943,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3035},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2016,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":513671,"primary_aulc_ppm":498962,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3035},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":918449,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3035},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":322,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":844255,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3035},{"accepted_repairs":1,"authorization_latencies":[56],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":277,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":878698,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3035},{"accepted_repairs":1,"authorization_latencies":[32],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":268,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":886273,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3035},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":258,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":894925,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3035},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":203,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":946139,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942665,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917003,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3036},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":1979,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":516810,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3037},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":201,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":953329,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3037},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":948696,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3037},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":922487,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3037},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":215,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":937114,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3037},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":934798,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3037},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":934798,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3037},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.3","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":934798,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3037},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2043,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":515625,"primary_aulc_ppm":487015,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3038},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2073,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":482661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3038},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":938661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3038},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":241,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":916658,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3038},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":269,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":887281,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3038},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":242,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":913181,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3038},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":239,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":916655,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3038},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":239,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":916655,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3038},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2025,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":501791,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3039},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2023,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":505890,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3039},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2008,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":523437,"primary_aulc_ppm":503508,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3039},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":918470,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3039},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":321,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":839757,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3039},{"accepted_repairs":1,"authorization_latencies":[53],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":271,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":877679,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3039},{"accepted_repairs":1,"authorization_latencies":[28],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":261,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":885925,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3039},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":250,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":896711,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3039},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":950448,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":948131,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":943499,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":921863,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":950448,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":950448,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":950448,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":939453,"primary_aulc_ppm":950448,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3040},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2041,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":508986,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3041},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":196,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":947861,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3041},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":200,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":943228,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3041},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":222,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":920658,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3041},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":930489,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3041},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":930489,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3041},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":930489,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3041},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":930489,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3041},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2070,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":453125,"primary_aulc_ppm":480910,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3042},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2109,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":470703,"primary_aulc_ppm":475530,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3042},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":206,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":942049,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3042},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":917486,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3042},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":254,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":891583,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3042},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":921201,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3042},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":923518,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3042},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":923518,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3042},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2019,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":508743,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3043},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2017,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":478515,"primary_aulc_ppm":515962,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3043},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2010,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":480468,"primary_aulc_ppm":516619,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3043},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":917791,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3043},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":310,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":856085,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3043},{"accepted_repairs":1,"authorization_latencies":[77],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":273,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":884566,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3043},{"accepted_repairs":1,"authorization_latencies":[48],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":261,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":894342,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3043},{"accepted_repairs":1,"authorization_latencies":[7],"condition":"FULL-PRIME-V1.3","cumulative_regret":249,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":903695,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3043},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":211,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946355,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":213,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":944039,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":939406,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916368,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":211,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946355,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":211,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946355,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":211,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946355,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":211,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946355,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3044},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2060,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":499848,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3045},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":942793,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3045},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":216,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":939319,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3045},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":913598,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3045},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926579,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3045},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926579,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3045},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926579,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3045},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":926579,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3045},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2014,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":509765,"primary_aulc_ppm":502660,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3046},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2045,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":478515,"primary_aulc_ppm":491255,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3046},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":200,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":945542,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3046},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":919577,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3046},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":246,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":898125,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3046},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":218,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":924695,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3046},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":215,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":928170,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3046},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":215,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":928170,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3046},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2068,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":503597,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3047},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2025,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":507812,"primary_aulc_ppm":501694,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3047},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":1997,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":515625,"primary_aulc_ppm":519280,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3047},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":920046,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3047},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":308,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":854334,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3047},{"accepted_repairs":1,"authorization_latencies":[69],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":276,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":879555,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3047},{"accepted_repairs":1,"authorization_latencies":[46],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":264,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":888786,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3047},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.3","cumulative_regret":249,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":901499,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3047},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":948043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":945727,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":941094,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":919032,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":948043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":948043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":948043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":948043,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3048},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2054,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":489267,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3049},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":198,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":958984,"primary_aulc_ppm":947615,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3049},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":201,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":958984,"primary_aulc_ppm":944140,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3049},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":958984,"primary_aulc_ppm":920247,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3049},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":958984,"primary_aulc_ppm":930242,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3049},{"accepted_repairs":1,"authorization_latencies":[12],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":218,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":958984,"primary_aulc_ppm":924451,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3049},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":218,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":958984,"primary_aulc_ppm":924451,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3049},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FULL-PRIME-V1.3","cumulative_regret":218,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":958984,"primary_aulc_ppm":924451,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3049},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2030,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":510951,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3050},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2028,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":511945,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3050},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":946512,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3050},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":923167,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3050},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":251,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":903118,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3050},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":227,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":925909,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3050},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":928226,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3050},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.3","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":928226,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3050},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2021,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":494140,"primary_aulc_ppm":509602,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3051},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2038,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":474609,"primary_aulc_ppm":509778,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3051},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2044,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":494140,"primary_aulc_ppm":504708,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3051},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":919564,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3051},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":327,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":842764,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3051},{"accepted_repairs":1,"authorization_latencies":[72],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":279,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":879428,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3051},{"accepted_repairs":1,"authorization_latencies":[36],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":265,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":890190,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3051},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.3","cumulative_regret":252,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":902194,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3051},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":221,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":945637,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":942162,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":248,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":917296,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":946795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3052},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2070,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":493279,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3053},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":210,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":948592,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3053},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":945118,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3053},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":919944,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3053},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932378,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3053},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932378,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3053},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932378,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3053},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":932378,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3053},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2047,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":519531,"primary_aulc_ppm":503157,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3054},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2050,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":468750,"primary_aulc_ppm":502441,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3054},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":944410,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3054},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":919237,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3054},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":253,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":902415,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3054},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":928195,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3054},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":928195,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3054},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.3","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":928195,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3054},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2022,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":513671,"primary_aulc_ppm":498330,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3055},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2036,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":494205,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3055},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2033,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":509765,"primary_aulc_ppm":495397,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3055},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":226,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":920163,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3055},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":302,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":855037,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3055},{"accepted_repairs":1,"authorization_latencies":[53],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":272,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":877222,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3055},{"accepted_repairs":1,"authorization_latencies":[24],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":258,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":888838,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3055},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":243,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":902549,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3055},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":945456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":219,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":943140,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":938507,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":245,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":916120,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":945456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":945456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":945456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":947265,"primary_aulc_ppm":945456,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3056},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2010,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":521484,"primary_aulc_ppm":522215,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3057},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":946704,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3057},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":942071,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3057},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":918911,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3057},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":932806,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3057},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":930489,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3057},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":928173,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3057},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.3","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":928173,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3057},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2063,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":470703,"primary_aulc_ppm":495486,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3058},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2094,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":458984,"primary_aulc_ppm":483696,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3058},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":939314,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3058},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":913897,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3058},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":266,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":888178,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3058},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":235,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":918467,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3058},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":235,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":918467,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3058},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":235,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":918467,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3058},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2024,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":546875,"primary_aulc_ppm":505499,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3059},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":1993,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":511519,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3059},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":1998,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":527343,"primary_aulc_ppm":509956,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3059},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":214,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":921642,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3059},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":297,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":856015,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3059},{"accepted_repairs":1,"authorization_latencies":[68],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":253,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":886300,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3059},{"accepted_repairs":1,"authorization_latencies":[36],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":243,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":894138,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3059},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.3","cumulative_regret":228,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":908601,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3059},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":947958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":222,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":945312,"primary_aulc_ppm":945642,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":942168,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":249,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":917179,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":947958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":947958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":947958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":945312,"primary_aulc_ppm":947958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3060},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2039,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":535156,"primary_aulc_ppm":494963,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3061},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":219,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":942354,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3061},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":937722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3061},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":244,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":916207,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3061},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":232,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":927298,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3061},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":232,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":927298,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3061},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":233,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":926140,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3061},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":233,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":960937,"primary_aulc_ppm":926140,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3061},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2061,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":539062,"primary_aulc_ppm":487584,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3062},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2068,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":511718,"primary_aulc_ppm":488112,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3062},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":939824,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3062},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":244,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":916175,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3062},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":269,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":891005,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3062},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":238,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":921538,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3062},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":238,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":921538,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3062},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":238,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":921538,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3062},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2057,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":504100,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3063},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2075,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":492187,"primary_aulc_ppm":491836,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3063},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2067,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":509765,"primary_aulc_ppm":483182,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3063},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":244,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":914894,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3063},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":324,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":850067,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3063},{"accepted_repairs":1,"authorization_latencies":[78],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":286,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":878254,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3063},{"accepted_repairs":1,"authorization_latencies":[57],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":279,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":884205,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3063},{"accepted_repairs":1,"authorization_latencies":[17],"condition":"FULL-PRIME-V1.3","cumulative_regret":263,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":897344,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3063},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":945706,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":225,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":937500,"primary_aulc_ppm":943390,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":228,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":939915,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":252,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":914560,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":945706,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":945706,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":945706,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":945706,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3064},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2055,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":502460,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3065},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":201,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":951250,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3065},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":946617,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3065},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":923579,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3065},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":932719,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3065},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":932719,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3065},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":932719,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3065},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":932719,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3065},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2043,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":513749,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3066},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2026,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":507812,"primary_aulc_ppm":504922,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3066},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":945248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3066},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":920989,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3066},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":255,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":896248,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3066},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":227,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":922573,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3066},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":927876,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3066},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.3","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":927876,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3066},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2102,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":513671,"primary_aulc_ppm":488743,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3067},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2058,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":470703,"primary_aulc_ppm":508348,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3067},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2046,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":509765,"primary_aulc_ppm":503445,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3067},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":241,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":920107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3067},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":333,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":842929,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3067},{"accepted_repairs":1,"authorization_latencies":[63],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":287,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":878631,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3067},{"accepted_repairs":1,"authorization_latencies":[38],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":270,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":893031,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3067},{"accepted_repairs":1,"authorization_latencies":[7],"condition":"FULL-PRIME-V1.3","cumulative_regret":255,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":906945,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3067},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":944063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":941747,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":938272,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":915193,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":944063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":944063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":944063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":944063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3068},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2069,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":492883,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3069},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":939806,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3069},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":936331,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3069},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":916849,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3069},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":928224,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3069},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":228,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":927066,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3069},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":228,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":927066,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3069},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.3","cumulative_regret":228,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":927066,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3069},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2078,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":529296,"primary_aulc_ppm":473929,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3070},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2045,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":515625,"primary_aulc_ppm":496974,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3070},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":936570,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3070},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":913491,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3070},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":272,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":886593,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3070},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":241,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":916881,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3070},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":918039,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3070},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":918039,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3070},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2089,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":488281,"primary_aulc_ppm":495397,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3071},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2068,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":499244,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3071},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2075,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":468750,"primary_aulc_ppm":502287,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3071},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":914684,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3071},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":323,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":837686,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3071},{"accepted_repairs":1,"authorization_latencies":[52],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":285,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":866177,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3071},{"accepted_repairs":1,"authorization_latencies":[28],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":270,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":878952,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3071},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.3","cumulative_regret":251,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":896726,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3071},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":951572,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":208,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":937500,"primary_aulc_ppm":949255,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":944623,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":920689,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":951572,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":951572,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":951572,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":206,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":951572,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3072},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2054,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":460937,"primary_aulc_ppm":512101,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3073},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":209,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":947097,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3073},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":935546,"primary_aulc_ppm":942464,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3073},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":935546,"primary_aulc_ppm":919548,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3073},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":933199,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3073},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":928566,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3073},{"accepted_repairs":1,"authorization_latencies":[16],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":928566,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3073},{"accepted_repairs":1,"authorization_latencies":[16],"condition":"FULL-PRIME-V1.3","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":935546,"primary_aulc_ppm":928566,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3073},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2071,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":499159,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3074},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2067,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":503362,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3074},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":939359,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3074},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918170,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3074},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":253,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":909127,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3074},{"accepted_repairs":1,"authorization_latencies":[19],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":242,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":920402,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3074},{"accepted_repairs":1,"authorization_latencies":[19],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":242,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":920402,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3074},{"accepted_repairs":1,"authorization_latencies":[19],"condition":"FULL-PRIME-V1.3","cumulative_regret":242,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":920402,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3074},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2010,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":490293,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3075},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2061,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":503906,"primary_aulc_ppm":488832,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3075},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2050,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":498046,"primary_aulc_ppm":491202,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3075},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":914459,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3075},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":329,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":837627,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3075},{"accepted_repairs":1,"authorization_latencies":[43],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":274,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":879378,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3075},{"accepted_repairs":1,"authorization_latencies":[20],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":266,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":886752,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3075},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":255,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":896663,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3075},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":943791,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940317,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":241,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917216,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":946107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3076},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2135,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":470395,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3077},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":200,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":946582,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3077},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":203,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":943107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3077},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":918848,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3077},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":214,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930368,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3077},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":214,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930368,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3077},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":214,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930368,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3077},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":214,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930368,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3077},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2057,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":517578,"primary_aulc_ppm":486036,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3078},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2068,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":505859,"primary_aulc_ppm":482096,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3078},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":940492,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3078},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":917636,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3078},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":265,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":890271,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3078},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":914098,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3078},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":239,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":915257,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3078},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.3","cumulative_regret":239,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":915257,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3078},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2032,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":527343,"primary_aulc_ppm":495834,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3079},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2060,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":521484,"primary_aulc_ppm":481074,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3079},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2008,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":531250,"primary_aulc_ppm":506850,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3079},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":242,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":912773,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3079},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":317,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":851036,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3079},{"accepted_repairs":1,"authorization_latencies":[51],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":292,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":866665,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3079},{"accepted_repairs":1,"authorization_latencies":[26],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":276,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":880150,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3079},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.3","cumulative_regret":262,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":893394,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3079},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":948011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":212,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":945695,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":216,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":941062,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":916133,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":948011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":948011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":948011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":948011,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3080},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2069,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":479941,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3081},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":941144,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3081},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":936511,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3081},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":248,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":912437,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3081},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":921455,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3081},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":921455,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3081},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":921455,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3081},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":921455,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3081},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2045,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":470703,"primary_aulc_ppm":508822,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3082},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2022,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":505859,"primary_aulc_ppm":499308,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3082},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":940730,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3082},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":917507,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3082},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":245,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":903430,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3082},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":923357,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3082},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":925674,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3082},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.3","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":925674,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3082},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2028,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":502758,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3083},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2017,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":527343,"primary_aulc_ppm":501483,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3083},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2012,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":521484,"primary_aulc_ppm":508372,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3083},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":215,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":922498,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3083},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":306,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":849111,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3083},{"accepted_repairs":1,"authorization_latencies":[73],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":261,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":882630,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3083},{"accepted_repairs":1,"authorization_latencies":[42],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":247,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":893148,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3083},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FULL-PRIME-V1.3","cumulative_regret":231,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":906796,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3083},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":209,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":946153,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":210,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":944995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":941520,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":916795,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":209,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":946153,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":209,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":946153,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":209,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":946153,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":209,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":946153,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3084},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2053,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":483104,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3085},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":222,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":941951,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3085},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":938476,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3085},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":247,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":914217,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3085},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":235,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":926894,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3085},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":924578,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3085},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":923420,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3085},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FULL-PRIME-V1.3","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":923420,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3085},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2049,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":501953,"primary_aulc_ppm":499786,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3086},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2091,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":523437,"primary_aulc_ppm":486396,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3086},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":209,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":941395,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3086},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":918926,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3086},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":253,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":895074,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3086},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":226,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":921950,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3086},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":926339,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3086},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":222,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":926339,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3086},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2035,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":503453,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3087},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2029,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":508277,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3087},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2034,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":519531,"primary_aulc_ppm":504829,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3087},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":227,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":920292,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3087},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":301,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":857527,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3087},{"accepted_repairs":1,"authorization_latencies":[49],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":267,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":883405,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3087},{"accepted_repairs":1,"authorization_latencies":[25],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":257,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":891874,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3087},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":248,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":899734,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3087},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":195,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":956982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":197,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":954666,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":950033,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":224,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":926691,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":195,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":956982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":195,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":956982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":195,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":956982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":195,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":943359,"primary_aulc_ppm":956982,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3088},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2007,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":480468,"primary_aulc_ppm":523436,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3089},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":947666,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3089},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":215,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":943359,"primary_aulc_ppm":943278,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3089},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":920321,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3089},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":932610,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3089},{"accepted_repairs":1,"authorization_latencies":[11],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":228,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":928222,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3089},{"accepted_repairs":1,"authorization_latencies":[12],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":927063,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3089},{"accepted_repairs":1,"authorization_latencies":[12],"condition":"FULL-PRIME-V1.3","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":943359,"primary_aulc_ppm":927063,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3089},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2106,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":496093,"primary_aulc_ppm":494301,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3090},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2078,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":501953,"primary_aulc_ppm":496504,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3090},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":942570,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3090},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":918659,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3090},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":239,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":909049,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3090},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":923126,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3090},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":221,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":926600,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3090},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FULL-PRIME-V1.3","cumulative_regret":221,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":926600,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3090},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2032,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":505393,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3091},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2040,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":505859,"primary_aulc_ppm":500693,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3091},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2042,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":505859,"primary_aulc_ppm":495426,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3091},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":920637,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3091},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":320,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":849213,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3091},{"accepted_repairs":1,"authorization_latencies":[50],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":270,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":884909,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3091},{"accepted_repairs":1,"authorization_latencies":[21],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":258,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":894860,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3091},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":246,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":906683,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3091},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":186,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":953248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":188,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":950932,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":191,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":947458,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":214,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":923871,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":186,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":953248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":186,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":953248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":186,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":953248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":186,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":955078,"primary_aulc_ppm":953248,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3092},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2024,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":513671,"primary_aulc_ppm":518406,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3093},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":208,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":945163,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3093},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":941689,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3093},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":917980,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3093},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":218,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":933582,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3093},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":930107,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3093},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":220,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":931265,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3093},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FULL-PRIME-V1.3","cumulative_regret":220,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":931265,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3093},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2055,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":494602,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3094},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2061,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":492633,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3094},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":211,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":938228,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3094},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":233,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":914213,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3094},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":257,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":890323,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3094},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":230,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":916223,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3094},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":230,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":916223,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3094},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.3","cumulative_regret":230,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":916223,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3094},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2112,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":544921,"primary_aulc_ppm":476612,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3095},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":1999,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":525390,"primary_aulc_ppm":504815,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3095},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2024,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":519531,"primary_aulc_ppm":492789,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3095},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":221,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":917481,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3095},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":317,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":839320,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3095},{"accepted_repairs":1,"authorization_latencies":[56],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":266,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":876390,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3095},{"accepted_repairs":1,"authorization_latencies":[28],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":251,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":889449,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3095},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.3","cumulative_regret":241,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":897857,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3095},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":947177,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":209,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":944861,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":940228,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":916661,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":947177,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":947177,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":947177,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":207,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":953125,"primary_aulc_ppm":947177,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3096},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":1998,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":510562,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3097},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":208,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":947305,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3097},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942672,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3097},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":231,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":923800,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3097},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":928774,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3097},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":928774,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3097},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":928774,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3097},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":928774,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3097},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2119,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":482421,"primary_aulc_ppm":482771,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3098},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2052,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":504160,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3098},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":940162,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3098},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":915722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3098},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":254,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":902193,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3098},{"accepted_repairs":1,"authorization_latencies":[15],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":234,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":920962,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3098},{"accepted_repairs":1,"authorization_latencies":[13],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":923278,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3098},{"accepted_repairs":1,"authorization_latencies":[13],"condition":"FULL-PRIME-V1.3","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":923278,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3098},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2054,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":503906,"primary_aulc_ppm":503082,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3099},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2066,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":480468,"primary_aulc_ppm":499063,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3099},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2081,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":492187,"primary_aulc_ppm":487534,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3099},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":913279,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3099},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":331,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":840347,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3099},{"accepted_repairs":1,"authorization_latencies":[72],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":285,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":874588,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3099},{"accepted_repairs":1,"authorization_latencies":[36],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":282,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":876720,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3099},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.3","cumulative_regret":262,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":892763,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3099},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948587,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":946270,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":941638,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":920183,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948587,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948587,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948587,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948587,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3100},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2035,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":474609,"primary_aulc_ppm":508616,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3101},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":190,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":950627,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3101},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":194,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":945994,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3101},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":218,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":920029,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3101},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":202,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":936729,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3101},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":204,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":934412,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3101},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":205,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":933254,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3101},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.3","cumulative_regret":205,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":951171,"primary_aulc_ppm":933254,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3101},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2091,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":515625,"primary_aulc_ppm":465138,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3102},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2090,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":484877,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3102},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":204,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":943181,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3102},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":227,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":919107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3102},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":253,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":891314,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3102},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":919104,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3102},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":919104,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3102},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":225,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":919104,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3102},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2020,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":496154,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3103},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2064,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":494140,"primary_aulc_ppm":490783,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3103},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2059,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":474609,"primary_aulc_ppm":499620,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3103},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":219,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":925395,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3103},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":318,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":841538,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3103},{"accepted_repairs":1,"authorization_latencies":[55],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":262,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":883223,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3103},{"accepted_repairs":1,"authorization_latencies":[34],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":257,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":887122,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3103},{"accepted_repairs":1,"authorization_latencies":[8],"condition":"FULL-PRIME-V1.3","cumulative_regret":242,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":902379,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3103},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":201,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":946679,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":205,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":942046,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":227,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":918967,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":949218,"primary_aulc_ppm":948995,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3104},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2058,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":498046,"primary_aulc_ppm":499696,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3105},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":197,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":947136,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3105},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":201,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":942503,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3105},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":919098,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3105},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":209,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":933237,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3105},{"accepted_repairs":1,"authorization_latencies":[2],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930921,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3105},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930921,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3105},{"accepted_repairs":1,"authorization_latencies":[4],"condition":"FULL-PRIME-V1.3","cumulative_regret":211,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":930921,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3105},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2032,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":523437,"primary_aulc_ppm":504415,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3106},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2076,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":509765,"primary_aulc_ppm":498198,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3106},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":220,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":938664,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3106},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":240,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":916477,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3106},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":266,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":890393,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3106},{"accepted_repairs":1,"authorization_latencies":[18],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":243,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":912270,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3106},{"accepted_repairs":1,"authorization_latencies":[16],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":244,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":911112,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3106},{"accepted_repairs":1,"authorization_latencies":[16],"condition":"FULL-PRIME-V1.3","cumulative_regret":244,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":960937,"primary_aulc_ppm":911112,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3106},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2068,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":496303,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3107},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2065,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":470703,"primary_aulc_ppm":489150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3107},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2032,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":498046,"primary_aulc_ppm":494242,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3107},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":915227,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3107},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":307,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":855104,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3107},{"accepted_repairs":1,"authorization_latencies":[65],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":288,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":869403,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3107},{"accepted_repairs":1,"authorization_latencies":[41],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":276,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":879394,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3107},{"accepted_repairs":1,"authorization_latencies":[17],"condition":"FULL-PRIME-V1.3","cumulative_regret":261,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":892250,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3107},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":196,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":949902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":198,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":957031,"primary_aulc_ppm":947585,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":202,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":957031,"primary_aulc_ppm":942953,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":225,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":957031,"primary_aulc_ppm":918268,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":196,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":949902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":196,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":949902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":196,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":949902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":196,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":957031,"primary_aulc_ppm":949902,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3108},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2092,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":466796,"primary_aulc_ppm":494673,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3109},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":213,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":941392,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3109},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":217,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":953125,"primary_aulc_ppm":936759,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3109},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":953125,"primary_aulc_ppm":915082,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3109},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":242,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":907805,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3109},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":242,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":907805,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3109},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":242,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":907805,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3109},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":242,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":953125,"primary_aulc_ppm":907805,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3109},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2014,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":522895,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3110},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2007,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":513217,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3110},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":213,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":940768,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3110},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":918076,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3110},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":255,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":897740,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3110},{"accepted_repairs":1,"authorization_latencies":[17],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":231,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":920165,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3110},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":923396,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3110},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.3","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":945312,"primary_aulc_ppm":923396,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3110},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2028,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":505859,"primary_aulc_ppm":496690,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3111},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2040,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":498046,"primary_aulc_ppm":491339,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3111},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2070,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":478515,"primary_aulc_ppm":502125,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3111},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":918911,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3111},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":322,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":849062,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3111},{"accepted_repairs":1,"authorization_latencies":[69],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":283,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":873328,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3111},{"accepted_repairs":1,"authorization_latencies":[53],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":277,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":878120,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3111},{"accepted_repairs":1,"authorization_latencies":[9],"condition":"FULL-PRIME-V1.3","cumulative_regret":255,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":898433,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3111},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":944107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":941406,"primary_aulc_ppm":941790,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":221,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":937158,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":914974,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":944107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":944107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":944107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":215,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":941406,"primary_aulc_ppm":944107,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3112},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2051,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":501879,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3113},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":204,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":946930,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3113},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":208,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":955078,"primary_aulc_ppm":942297,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3113},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":955078,"primary_aulc_ppm":920051,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3113},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":927241,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3113},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":927241,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3113},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":927241,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3113},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":955078,"primary_aulc_ppm":927241,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3113},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2004,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":507812,"primary_aulc_ppm":510185,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3114},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2026,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":507812,"primary_aulc_ppm":503966,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3114},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":942957,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3114},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":236,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":941406,"primary_aulc_ppm":919390,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3114},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":260,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":895052,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3114},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":233,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":920952,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3114},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":922110,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3114},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":232,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":941406,"primary_aulc_ppm":922110,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3114},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2057,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":484375,"primary_aulc_ppm":492765,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3115},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2073,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":500000,"primary_aulc_ppm":495402,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3115},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2006,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":447265,"primary_aulc_ppm":514592,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3115},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":917150,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3115},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":334,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":840525,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3115},{"accepted_repairs":1,"authorization_latencies":[63],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":279,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":877381,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3115},{"accepted_repairs":1,"authorization_latencies":[34],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":265,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":888570,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3115},{"accepted_repairs":1,"authorization_latencies":[6],"condition":"FULL-PRIME-V1.3","cumulative_regret":253,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":945312,"primary_aulc_ppm":899295,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3115},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":193,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":964843,"primary_aulc_ppm":952722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":195,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":964843,"primary_aulc_ppm":950405,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":199,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":964843,"primary_aulc_ppm":945773,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":222,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":964843,"primary_aulc_ppm":920111,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":193,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":964843,"primary_aulc_ppm":952722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":193,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":964843,"primary_aulc_ppm":952722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":193,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":964843,"primary_aulc_ppm":952722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":193,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":964843,"primary_aulc_ppm":952722,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3116},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2116,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":486328,"primary_aulc_ppm":480643,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3117},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":221,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":940591,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3117},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":225,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":949218,"primary_aulc_ppm":935958,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3117},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":244,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":949218,"primary_aulc_ppm":916516,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3117},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":235,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":924376,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3117},{"accepted_repairs":1,"authorization_latencies":[5],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":236,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":923218,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3117},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":922060,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3117},{"accepted_repairs":1,"authorization_latencies":[14],"condition":"FULL-PRIME-V1.3","cumulative_regret":237,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":949218,"primary_aulc_ppm":922060,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3117},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2047,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":478515,"primary_aulc_ppm":501206,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3118},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2060,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":484375,"primary_aulc_ppm":491583,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3118},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":207,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":942325,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3118},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":229,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":962890,"primary_aulc_ppm":918310,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3118},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":254,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":895215,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3118},{"accepted_repairs":1,"authorization_latencies":[1],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":922636,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3118},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":922636,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3118},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":224,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":962890,"primary_aulc_ppm":922636,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3118},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2046,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":531250,"primary_aulc_ppm":482607,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3119},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2079,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":513671,"primary_aulc_ppm":488331,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3119},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2068,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":505859,"primary_aulc_ppm":491577,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3119},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":234,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":911264,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3119},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":318,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":839375,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3119},{"accepted_repairs":1,"authorization_latencies":[35],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":268,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":878884,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3119},{"accepted_repairs":1,"authorization_latencies":[18],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":261,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":884672,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3119},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":251,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":960937,"primary_aulc_ppm":893731,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3119},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":944571,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":218,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":937500,"primary_aulc_ppm":943413,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":222,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":938780,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":243,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":916290,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":944571,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":944571,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":944571,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":937500,"primary_aulc_ppm":944571,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3120},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2063,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":531250,"primary_aulc_ppm":485060,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3121},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":220,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":942377,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3121},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":224,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":947265,"primary_aulc_ppm":937744,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3121},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":914828,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3121},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":921530,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3121},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":921530,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3121},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":921530,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3121},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":238,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":947265,"primary_aulc_ppm":921530,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3121},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2014,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":490234,"primary_aulc_ppm":514208,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3122},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2060,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":488281,"primary_aulc_ppm":493130,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3122},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":212,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":942874,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3122},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":235,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":937500,"primary_aulc_ppm":917945,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3122},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":249,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":903195,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3122},{"accepted_repairs":1,"authorization_latencies":[3],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":231,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":920868,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3122},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":924343,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3122},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":228,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":937500,"primary_aulc_ppm":924343,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3122},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2087,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":491319,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3123},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2136,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":460937,"primary_aulc_ppm":470968,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3123},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2091,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":492187,"primary_aulc_ppm":484287,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3123},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":247,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":917517,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3123},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":333,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":846836,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3123},{"accepted_repairs":1,"authorization_latencies":[68],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":289,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":879677,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3123},{"accepted_repairs":1,"authorization_latencies":[43],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":280,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":887578,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3123},{"accepted_repairs":1,"authorization_latencies":[10],"condition":"FULL-PRIME-V1.3","cumulative_regret":264,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":943359,"primary_aulc_ppm":900798,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3123},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":925781,"primary_aulc_ppm":948141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":219,"diagnostic_hidden_depth":0,"final_representation_depth":1,"final_window_reward_ppm":925781,"primary_aulc_ppm":945825,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":223,"diagnostic_hidden_depth":0,"final_representation_depth":2,"final_window_reward_ppm":925781,"primary_aulc_ppm":941192,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":246,"diagnostic_hidden_depth":0,"final_representation_depth":4,"final_window_reward_ppm":925781,"primary_aulc_ppm":915775,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":925781,"primary_aulc_ppm":948141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":925781,"primary_aulc_ppm":948141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":925781,"primary_aulc_ppm":948141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FULL-PRIME-V1.3","cumulative_regret":217,"diagnostic_hidden_depth":0,"final_representation_depth":0,"final_window_reward_ppm":925781,"primary_aulc_ppm":948141,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3124},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":1966,"diagnostic_hidden_depth":1,"final_representation_depth":0,"final_window_reward_ppm":492187,"primary_aulc_ppm":515185,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3125},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":214,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":944758,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3125},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":218,"diagnostic_hidden_depth":1,"final_representation_depth":2,"final_window_reward_ppm":939453,"primary_aulc_ppm":940126,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3125},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":239,"diagnostic_hidden_depth":1,"final_representation_depth":4,"final_window_reward_ppm":939453,"primary_aulc_ppm":918876,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3125},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":927386,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3125},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":927386,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3125},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":927386,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3125},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":229,"diagnostic_hidden_depth":1,"final_representation_depth":1,"final_window_reward_ppm":939453,"primary_aulc_ppm":927386,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[1],"verifier_supported_repairs":1,"world_seed":3125},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2023,"diagnostic_hidden_depth":2,"final_representation_depth":0,"final_window_reward_ppm":511718,"primary_aulc_ppm":513835,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3126},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2011,"diagnostic_hidden_depth":2,"final_representation_depth":1,"final_window_reward_ppm":541015,"primary_aulc_ppm":509218,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3126},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":200,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":943697,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3126},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":223,"diagnostic_hidden_depth":2,"final_representation_depth":4,"final_window_reward_ppm":951171,"primary_aulc_ppm":919989,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3126},{"accepted_repairs":2,"authorization_latencies":[0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":227,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":916821,"proposed_repairs":2,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3126},{"accepted_repairs":1,"authorization_latencies":[13],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":216,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":925655,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3126},{"accepted_repairs":1,"authorization_latencies":[12],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":928215,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3126},{"accepted_repairs":1,"authorization_latencies":[12],"condition":"FULL-PRIME-V1.3","cumulative_regret":214,"diagnostic_hidden_depth":2,"final_representation_depth":2,"final_window_reward_ppm":951171,"primary_aulc_ppm":928215,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[2],"verifier_supported_repairs":1,"world_seed":3126},{"accepted_repairs":0,"authorization_latencies":[],"condition":"REACTIVE","cumulative_regret":2045,"diagnostic_hidden_depth":4,"final_representation_depth":0,"final_window_reward_ppm":521484,"primary_aulc_ppm":504850,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3127},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H1","cumulative_regret":2040,"diagnostic_hidden_depth":4,"final_representation_depth":1,"final_window_reward_ppm":550781,"primary_aulc_ppm":496018,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3127},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H2","cumulative_regret":2055,"diagnostic_hidden_depth":4,"final_representation_depth":2,"final_window_reward_ppm":525390,"primary_aulc_ppm":490419,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3127},{"accepted_repairs":0,"authorization_latencies":[],"condition":"FIXED-H4","cumulative_regret":230,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":921396,"proposed_repairs":0,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3127},{"accepted_repairs":3,"authorization_latencies":[0,0,0],"condition":"ADAPTIVE-NO-VERIFIER","cumulative_regret":318,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":849644,"proposed_repairs":3,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":0,"world_seed":3127},{"accepted_repairs":1,"authorization_latencies":[72],"condition":"FULL-PRIME-V1.2-REFERENCE","cumulative_regret":279,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":879172,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[],"verifier_supported_repairs":1,"world_seed":3127},{"accepted_repairs":1,"authorization_latencies":[37],"condition":"FACTOR-WITNESS-CARRIER-COST","cumulative_regret":261,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":893305,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3127},{"accepted_repairs":1,"authorization_latencies":[0],"condition":"FULL-PRIME-V1.3","cumulative_regret":246,"diagnostic_hidden_depth":4,"final_representation_depth":4,"final_window_reward_ppm":947265,"primary_aulc_ppm":905673,"proposed_repairs":1,"receipt_chain_valid":true,"rejected_repairs":0,"selected_witness_lags":[4],"verifier_supported_repairs":1,"world_seed":3127}],"status":"FROZEN_EVALUATION_COMPLETE"} diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/FROZEN_EVALUATION_RESULT.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/FROZEN_EVALUATION_RESULT.sha256 new file mode 100644 index 0000000..877de11 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/FROZEN_EVALUATION_RESULT.sha256 @@ -0,0 +1 @@ +06542efb67ea9fbfefb482c9e7fcfc77d5cc5a884e31266578ed2831dcbffab4 FROZEN_EVALUATION_RESULT.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/HELD_OUT_RESULT.md b/experiments/prime_canonical_agent_benchmark_v1_3/HELD_OUT_RESULT.md new file mode 100644 index 0000000..934434c --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/HELD_OUT_RESULT.md @@ -0,0 +1,313 @@ +# PRIME Canonical Agent Benchmark v1.3 +## Frozen Held-Out Evaluation Result + +Status: + + COMPLETE + +Evaluation protocol commit: + + dda47f6ec3cdfc611e27bd7f2f9a8ec16c1cf28d + +Frozen hypothesis-bearing implementation SHA-256: + + 3f8082ad340af46f786a773922ec4a5a49d42fda01f77fe658b911d44afe957e + +Evaluation result SHA-256: + + 06542efb67ea9fbfefb482c9e7fcfc77d5cc5a884e31266578ed2831dcbffab4 + +Evaluation worlds: + + 128 + +Condition-world rows: + + 1024 + +Evaluation seeds: + + 3000 through 3127 inclusive + +All integrity checks passed. + +--- + +# Condition means + + REACTIVE 611823 + FIXED-H1 721981 + FIXED-H2 831280 + FIXED-H4 918191 + ADAPTIVE-NO-VERIFIER 904833 + FULL-PRIME-V1.2-REFERENCE 918817 + FACTOR-WITNESS-CARRIER-COST 921246 + FULL-PRIME-V1.3 924347 + +Mean final-window reward: + + FIXED-H4 948836 + FULL-PRIME-V1.2-REFERENCE 948836 + FACTOR-WITNESS-CARRIER-COST 948836 + FULL-PRIME-V1.3 948836 + +--- + +# Primary architectural-upgrade claim + +Comparison: + + FULL-PRIME-v1.3 + minus + FULL-PRIME-v1.2-REFERENCE + +Observed paired mean AULC delta: + + +5529 ppm + +Frozen deterministic bootstrap 95% interval: + + [+3921, +7200] ppm + +Final-window delta: + + 0 ppm + +Exact final-depth recovery: + + FULL-PRIME-v1.3: + 128/128 + + FULL-PRIME-v1.2-REFERENCE: + 128/128 + +Integrity: + + PASS + +Primary architectural-upgrade claim: + + SUPPORTED + +Thus the frozen v1.3 mechanism improved held-out online-learning efficiency +relative to the frozen v1.2 reference while preserving exact minimal +representation recovery and final-window performance. + +--- + +# Fixed-H4 comparison + +Comparison: + + FULL-PRIME-v1.3 + minus + FIXED-H4 + +Observed paired mean AULC delta: + + +6155 ppm + +Frozen deterministic bootstrap 95% interval: + + [+3220, +9151] ppm + +Final-window delta: + + 0 ppm + +Integrity: + + PASS + +Fixed-memory superiority claim: + + SUPPORTED + +Within this frozen MemoryAlias-POMDP benchmark, FULL-PRIME-v1.3 therefore +outperformed the development-selected FIXED-H4 comparator despite beginning +from H0 and having to discover its required representation online. + +--- + +# Factorization-only claim + +Comparison: + + FACTOR-WITNESS-CARRIER-COST + minus + FULL-PRIME-v1.2-REFERENCE + +Observed paired mean AULC delta: + + +2428 ppm + +Frozen deterministic bootstrap 95% interval: + + [+1698, +3187] ppm + +Final-window delta: + + 0 ppm + +Exact final-depth recovery: + + 128/128 versus 128/128 + +Factorization-only claim: + + SUPPORTED + +Thus replacing complete-candidate carrier evidence with factorized historical +coordinate witnesses improved held-out learning efficiency while retaining the +old v1.2 carrier complexity cost. + +--- + +# Coordinate-repricing diagnostic + +Comparison: + + FULL-PRIME-v1.3 + minus + FACTOR-WITNESS-CARRIER-COST + +Observed paired mean AULC delta: + + +3101 ppm + +Frozen deterministic bootstrap interval: + + [+2158, +4090] ppm + +Status: + + DIAGNOSTIC ONLY + +This comparison was not preregistered as a separate inferential claim and +must remain described as diagnostic. + +--- + +# Representation recovery + +FULL-PRIME-v1.3 exact final-depth recovery: + + 128/128 + +By hidden dependency depth: + + d=0 -> H0: + 32/32 + + d=1 -> H1: + 32/32 + + d=2 -> H2: + 32/32 + + d=4 -> H4: + 32/32 + +Accepted FULL-PRIME-v1.3 repairs: + + 96 + +Rejected repairs: + + 0 + +No representation repair occurred in d=0 worlds. + +--- + +# Deep-evidence mechanism + +Held-out d=4 mean authorization latency: + + FULL-PRIME-v1.2-REFERENCE: + 59 scored events + + FACTOR-WITNESS-CARRIER-COST: + 34 scored events + + FULL-PRIME-v1.3: + 4 scored events + +Held-out d=4 maximum authorization latency: + + FULL-PRIME-v1.2-REFERENCE: + 78 + + FACTOR-WITNESS-CARRIER-COST: + 57 + + FULL-PRIME-v1.3: + 17 + +Immediate d=4 FULL-v1.3 authorizations: + + 9 / 32 + +Held-out d=4 mean AULC: + + FULL-PRIME-v1.2-REFERENCE: + 878948 + + FACTOR-WITNESS-CARRIER-COST: + 887971 + + FULL-PRIME-v1.3: + 900376 + +Every d=4 world ended at H4 in all three verifier-governed adaptive +conditions. + +--- + +# Scientific interpretation + +v1.1 established exact adaptive representation discovery but showed that +fixed prospective verification imposed a severe online-learning cost. + +v1.2 replaced fixed prospective evidence with passive anytime-valid +verification. This preserved exact representation recovery and established a +held-out advantage over ungated adaptive growth, but superiority over FIXED-H4 +was not established. + +v1.3 targeted the remaining deep-representation evidence bottleneck with: + +1. factorized lag witnesses rather than full deeper-state carriers; and +2. coordinate-description complexity pricing rather than pricing the complete + induced tabular carrier. + +The frozen held-out evaluation supports the preregistered architectural-upgrade +claim and the factorization-only claim. + +It also supports superiority of FULL-PRIME-v1.3 over the development-selected +FIXED-H4 comparator on this benchmark. + +The d=4 diagnostics provide a mechanistic explanation: mean authorization +latency fell from 59 scored events in the v1.2 reference to 4 in FULL-v1.3, +while exact representation recovery remained perfect. + +--- + +# Claim boundary + +The supported result is: + +A verifier-governed adaptive representation-repair agent, starting from H0, +outperformed its frozen v1.2 predecessor and the development-selected +maximal-memory fixed H4 comparator on the frozen held-out MemoryAlias-POMDP +benchmark while preserving exact minimal representation recovery. + +This does not establish: + +- universal superiority over fixed-memory agents; +- superiority over learned recurrent-memory agents; +- general POMDP superiority; +- AGI; +- broad real-world generality; +- production security. + +A separately frozen learned-memory comparison remains required. diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/LINEAGE.json b/experiments/prime_canonical_agent_benchmark_v1_3/LINEAGE.json new file mode 100644 index 0000000..db59b63 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/LINEAGE.json @@ -0,0 +1,17 @@ +{ + "benchmark": "prime-canonical-agent-benchmark-v1.3", + "parent_benchmark": "prime-canonical-agent-benchmark-v1.2", + "parent_final_commit": "6f17789", + "parent_evaluation_result_sha256": "6ce64dc7aa0bcc44ce1453788162a007ea79429d0283e69d6ba4e8c9e91028f0", + "parent_core_implementation_sha256": "bed64cbe558c928d3793c915e34260638c9c0ed3f7061c350695e769b5c3efc9", + "parent_primary_claim": "NOT SUPPORTED", + "parent_verifier_specific_claim": "SUPPORTED", + "parent_exact_final_depth_recovery": "128/128", + "parent_mean_authorization_latency_scored_events": 25, + "parent_d4_mean_authorization_latency_scored_events": 64, + "parent_d4_max_authorization_latency_scored_events": 100, + "identified_bottleneck": "deep-representation evidence complexity", + "v1_3_development_seeds": "300..331", + "v1_3_evaluation_seeds": "3000..3127", + "prior_held_out_seeds_reused": false +} diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/LINEAGE.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/LINEAGE.sha256 new file mode 100644 index 0000000..48ff6ea --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/LINEAGE.sha256 @@ -0,0 +1 @@ +237b4cfbefa28fc627ace1d78d9bec1c784485c4f1a8684cbb307581d549b743 LINEAGE.json diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/__init__.py b/experiments/prime_canonical_agent_benchmark_v1_3/__init__.py new file mode 100644 index 0000000..6a3412a --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/__init__.py @@ -0,0 +1 @@ +"""PRIME Canonical Agent Benchmark v1.3.""" diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/adaptive_runner.py b/experiments/prime_canonical_agent_benchmark_v1_3/adaptive_runner.py new file mode 100644 index 0000000..7859ba7 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/adaptive_runner.py @@ -0,0 +1,1110 @@ +"""Adaptive runner for PRIME Canonical Agent Benchmark v1.3.""" + +from dataclasses import dataclass +import hashlib + +from experiments.prime_canonical_agent_benchmark_v1.baselines import ( + HistoryRepresentation, +) +from experiments.prime_canonical_agent_benchmark_v1.deterministic import ( + splitmix64, +) +from experiments.prime_canonical_agent_benchmark_v1.environment import ( + MemoryAliasPOMDP, +) +from experiments.prime_canonical_agent_benchmark_v1.learner import ( + BinaryTabularLearner, +) +from experiments.prime_canonical_agent_benchmark_v1.manifest import ( + DECISION_STEPS_PER_EPISODE, + EPISODES, + FINAL_WINDOW_EPISODES, + PPM, + WARMUP_STEPS, +) + +from experiments.prime_canonical_agent_benchmark_v1_2.receipts import ( + ReceiptChain, + canonical_bytes, + verify_receipt_chain, +) +from experiments.prime_canonical_agent_benchmark_v1_2.verifier import ( + SequentialVerifierEpoch, + deeper_depths, +) + +from .factor_verifier import ( + CARRIER_COST, + COORDINATE_COST, + FactorizedVerifierEpoch, + required_depth_for_lag, +) +from .manifest import ( + ADAPTIVE_CONDITIONS, + BENCHMARK_VERSION, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, +) +from .provenance import ( + frozen_identities, + implementation_sha256, + source_commit, + source_dirty, +) + + +MAX_ACCEPTED_REPAIRS = 3 +OBSTRUCTION_MIN_PER_TARGET = 8 + + +@dataclass(frozen=True) +class AdaptiveResult: + payload: dict + + def canonical_bytes(self) -> bytes: + return canonical_bytes( + self.payload + ) + + def sha256(self) -> str: + return hashlib.sha256( + self.canonical_bytes() + ).hexdigest() + + +def _infer_target( + action: int, + reward: int, +) -> int: + if reward == 1: + return action + + if reward == 0: + return 1 - action + + raise RuntimeError( + "reward must be binary" + ) + + +def _primary_aulc_ppm( + episode_rewards: list[int], +) -> int: + cumulative = 0 + curve_sum = 0 + + for index, reward in enumerate( + episode_rewards, + start=1, + ): + cumulative += reward + + denominator = ( + index + * DECISION_STEPS_PER_EPISODE + ) + + curve_sum += ( + PPM * cumulative + ) // denominator + + return ( + curve_sum + // len(episode_rewards) + ) + + +def _final_window_ppm( + episode_rewards: list[int], +) -> int: + window = episode_rewards[ + -FINAL_WINDOW_EPISODES: + ] + + return ( + PPM * sum(window) + ) // ( + len(window) + * DECISION_STEPS_PER_EPISODE + ) + + +def _promote_policy( + old_policy_state: tuple[int, ...], + new_depth: int, +) -> HistoryRepresentation: + representation = ( + HistoryRepresentation( + depth=new_depth + ) + ) + + # This seeds only information already + # present in the old authorized state. + for bit in old_policy_state: + representation.observe(bit) + + return representation + + +def _obstruction_exists( + evidence: dict[ + tuple[int, ...], + list[int], + ], +) -> bool: + return any( + counts[0] + >= OBSTRUCTION_MIN_PER_TARGET + and counts[1] + >= OBSTRUCTION_MIN_PER_TARGET + for counts + in evidence.values() + ) + + +def _guard_seed( + world_seed: int, + permit_evaluation: bool, +) -> None: + if permit_evaluation: + if ( + world_seed + not in EVALUATION_SEEDS + ): + raise RuntimeError( + "evaluation mode accepts only " + "frozen v1.3 evaluation seeds" + ) + else: + if ( + world_seed + not in DEVELOPMENT_SEEDS + ): + raise RuntimeError( + "development mode accepts only " + "frozen v1.3 development seeds" + ) + + +def _reference_receipt( + *, + condition: str, + world_seed: int, + verifier: SequentialVerifierEpoch, + episode: int, + event_index: int, + authorized_depth: int | None, + resolution: str, +) -> dict: + supported = ( + verifier.supported_depths() + ) + + selected = ( + min(supported) + if supported + else None + ) + + latency = None + before = None + additional = None + + if ( + selected is not None + and verifier.obstruction_event_index + is not None + ): + latency = ( + event_index + - verifier.obstruction_event_index + ) + + before = ( + verifier.discordant_at_obstruction.get( + selected + ) + ) + + additional = ( + verifier.additional_discordant_after_obstruction( + selected + ) + ) + + return { + "benchmark_version": BENCHMARK_VERSION, + "architecture": ( + "V1.2_COMPLETE_CANDIDATE_REFERENCE" + ), + "condition": condition, + "world_seed": world_seed, + "canonical_depth_before": ( + verifier.current_depth + ), + "obstruction_episode": ( + verifier.obstruction_episode + ), + "obstruction_scored_event_index": ( + verifier.obstruction_event_index + ), + "resolution_episode": episode, + "resolution_scored_event_index": ( + event_index + ), + "candidate_depths": list( + verifier.candidate_depths + ), + "candidate_evidence": ( + verifier.evidence_summaries() + ), + "supported_candidate_depths": list( + supported + ), + "selected_candidate_depth": ( + selected + ), + "authorized_depth": ( + authorized_depth + ), + "canonical_depth_after": ( + authorized_depth + if authorized_depth is not None + else verifier.current_depth + ), + "authorization_latency_scored_events": ( + latency + ), + "selected_discordant_at_obstruction": ( + before + ), + "selected_additional_discordant_after_obstruction": ( + additional + ), + "resolution": resolution, + } + + +def _factor_receipt( + *, + condition: str, + world_seed: int, + verifier: FactorizedVerifierEpoch, + episode: int, + event_index: int, + authorized_depth: int | None, + resolution: str, +) -> dict: + supported = ( + verifier.supported_lags() + ) + + selected_lag = ( + verifier.selected_supported_lag() + ) + + selected_depth = ( + required_depth_for_lag( + selected_lag + ) + if selected_lag is not None + else None + ) + + latency = None + before = None + additional = None + + if ( + selected_lag is not None + and verifier.obstruction_event_index + is not None + ): + latency = ( + event_index + - verifier.obstruction_event_index + ) + + before = ( + verifier.discordant_at_obstruction.get( + selected_lag + ) + ) + + additional = ( + verifier.additional_discordant_after_obstruction( + selected_lag + ) + ) + + return { + "benchmark_version": BENCHMARK_VERSION, + "architecture": ( + "FACTORIZED_LAG_WITNESS" + ), + "condition": condition, + "world_seed": world_seed, + "canonical_depth_before": ( + verifier.current_depth + ), + "obstruction_episode": ( + verifier.obstruction_episode + ), + "obstruction_scored_event_index": ( + verifier.obstruction_event_index + ), + "resolution_episode": episode, + "resolution_scored_event_index": ( + event_index + ), + "candidate_witness_lags": list( + verifier.witness_lags + ), + "witness_to_policy_depth": { + str(lag): ( + required_depth_for_lag( + lag + ) + ) + for lag in verifier.witness_lags + }, + "witness_evidence": ( + verifier.witness_summaries() + ), + "complexity_rule": ( + verifier.complexity_rule + ), + "supported_witness_lags": list( + supported + ), + "selected_witness_lag": ( + selected_lag + ), + "selected_required_depth": ( + selected_depth + ), + "authorized_depth": ( + authorized_depth + ), + "canonical_depth_after": ( + authorized_depth + if authorized_depth is not None + else verifier.current_depth + ), + "authorization_latency_scored_events": ( + latency + ), + "selected_discordant_at_obstruction": ( + before + ), + "selected_additional_discordant_after_obstruction": ( + additional + ), + "resolution": resolution, + } + + +def run_adaptive_condition( + world_seed: int, + condition: str, + *, + permit_evaluation: bool = False, +) -> AdaptiveResult: + if condition not in ADAPTIVE_CONDITIONS: + raise ValueError( + f"unknown v1.3 condition: {condition}" + ) + + _guard_seed( + world_seed, + permit_evaluation, + ) + + frozen = frozen_identities() + + env = MemoryAliasPOMDP( + world_seed + ) + + current_depth = 0 + + policy = HistoryRepresentation( + depth=current_depth + ) + + learner_seed = splitmix64( + world_seed + ^ 0x8EBC6AF09C88C6E3 + ) + + learner = BinaryTabularLearner( + seed=learner_seed + ) + + is_reference = ( + condition + == "FULL-PRIME-V1.2-REFERENCE" + ) + + is_factor = condition in ( + "FACTOR-WITNESS-CARRIER-COST", + "FULL-PRIME-V1.3", + ) + + complexity_rule = None + + if ( + condition + == "FACTOR-WITNESS-CARRIER-COST" + ): + complexity_rule = CARRIER_COST + + elif condition == "FULL-PRIME-V1.3": + complexity_rule = ( + COORDINATE_COST + ) + + reference_verifier = ( + SequentialVerifierEpoch( + current_depth=0 + ) + if is_reference + else None + ) + + factor_verifier = ( + FactorizedVerifierEpoch( + current_depth=0, + complexity_rule=( + complexity_rule + ), + ) + if is_factor + else None + ) + + ungated_obstruction: dict[ + tuple[int, ...], + list[int], + ] = {} + + receipts = ReceiptChain() + + episode_rewards: list[int] = [] + + proposed_repairs = 0 + accepted_repairs = 0 + rejected_repairs = 0 + verifier_supported_repairs = 0 + + representation_change_episodes: ( + list[int] + ) = [] + + authorization_latencies: ( + list[int] + ) = [] + + selected_witness_lags: ( + list[int] + ) = [] + + global_scored_event_index = -1 + + for episode in range(EPISODES): + policy.reset() + + if ( + reference_verifier + is not None + ): + reference_verifier.reset_episode() + + if factor_verifier is not None: + factor_verifier.reset_episode() + + observation = env.reset( + episode + ) + + scored_reward = 0 + + total_steps = ( + WARMUP_STEPS + + DECISION_STEPS_PER_EPISODE + ) + + for _step_index in range( + total_steps + ): + state = policy.observe( + observation + ) + + reference_prediction = None + factor_prediction = None + + if ( + reference_verifier + is not None + ): + reference_prediction = ( + reference_verifier.freeze_prediction( + observation, + state, + ) + ) + + if factor_verifier is not None: + factor_prediction = ( + factor_verifier.freeze_prediction( + observation, + state, + ) + ) + + action = learner.choose( + state + ) + + result = env.step( + action + ) + + if result.scored: + global_scored_event_index += 1 + + learner.update( + state, + action, + result.reward, + ) + + scored_reward += ( + result.reward + ) + + target = _infer_target( + action, + result.reward, + ) + + if ( + condition + == "ADAPTIVE-NO-VERIFIER" + ): + bucket = ( + ungated_obstruction.setdefault( + state, + [0, 0], + ) + ) + + bucket[target] += 1 + + candidates = deeper_depths( + current_depth + ) + + if ( + candidates + and accepted_repairs + < MAX_ACCEPTED_REPAIRS + and _obstruction_exists( + ungated_obstruction + ) + ): + proposed_repairs += 1 + + authorized = ( + candidates[0] + ) + + receipts.append( + { + "benchmark_version": ( + BENCHMARK_VERSION + ), + "architecture": ( + "UNGATED_INCREMENTAL" + ), + "condition": condition, + "world_seed": ( + world_seed + ), + "canonical_depth_before": ( + current_depth + ), + "obstruction_episode": ( + episode + ), + "obstruction_scored_event_index": ( + global_scored_event_index + ), + "candidate_depths": list( + candidates + ), + "authorized_depth": ( + authorized + ), + "canonical_depth_after": ( + authorized + ), + "authorization_latency_scored_events": 0, + "resolution": ( + "UNGATED_ACCEPT" + ), + } + ) + + current_depth = ( + authorized + ) + + policy = _promote_policy( + state, + current_depth, + ) + + accepted_repairs += 1 + + authorization_latencies.append( + 0 + ) + + representation_change_episodes.append( + episode + ) + + ungated_obstruction = {} + + elif is_reference: + if ( + reference_prediction + is None + or reference_verifier + is None + ): + raise RuntimeError( + "reference verifier missing" + ) + + outcome = ( + reference_verifier.finalize_event( + reference_prediction, + target=target, + episode=episode, + scored_event_index=( + global_scored_event_index + ), + ) + ) + + if outcome.proposal_opened: + proposed_repairs += 1 + + if outcome.supported_depths: + selected = min( + outcome.supported_depths + ) + + payload = ( + _reference_receipt( + condition=condition, + world_seed=( + world_seed + ), + verifier=( + reference_verifier + ), + episode=episode, + event_index=( + global_scored_event_index + ), + authorized_depth=( + selected + ), + resolution=( + "VERIFIER_AUTHORIZE" + ), + ) + ) + + receipts.append( + payload + ) + + latency = payload[ + "authorization_latency_scored_events" + ] + + if latency is None: + raise RuntimeError( + "missing latency" + ) + + authorization_latencies.append( + latency + ) + + accepted_repairs += 1 + verifier_supported_repairs += 1 + + representation_change_episodes.append( + episode + ) + + current_depth = ( + selected + ) + + policy = _promote_policy( + state, + current_depth, + ) + + reference_verifier = ( + SequentialVerifierEpoch( + current_depth=( + current_depth + ) + ) + ) + + reference_verifier.seed_mid_episode( + state + ) + + elif is_factor: + if ( + factor_prediction is None + or factor_verifier is None + ): + raise RuntimeError( + "factor verifier missing" + ) + + outcome = ( + factor_verifier.finalize_event( + factor_prediction, + target=target, + episode=episode, + scored_event_index=( + global_scored_event_index + ), + ) + ) + + if outcome.proposal_opened: + proposed_repairs += 1 + + if outcome.supported_lags: + selected_lag = ( + factor_verifier.selected_supported_lag() + ) + + if selected_lag is None: + raise RuntimeError( + "supported witness " + "without selection" + ) + + selected_depth = ( + required_depth_for_lag( + selected_lag + ) + ) + + payload = ( + _factor_receipt( + condition=condition, + world_seed=( + world_seed + ), + verifier=( + factor_verifier + ), + episode=episode, + event_index=( + global_scored_event_index + ), + authorized_depth=( + selected_depth + ), + resolution=( + "VERIFIER_AUTHORIZE" + ), + ) + ) + + receipts.append( + payload + ) + + latency = payload[ + "authorization_latency_scored_events" + ] + + if latency is None: + raise RuntimeError( + "missing factor latency" + ) + + authorization_latencies.append( + latency + ) + + selected_witness_lags.append( + selected_lag + ) + + accepted_repairs += 1 + verifier_supported_repairs += 1 + + representation_change_episodes.append( + episode + ) + + current_depth = ( + selected_depth + ) + + policy = _promote_policy( + state, + current_depth, + ) + + factor_verifier = ( + FactorizedVerifierEpoch( + current_depth=( + current_depth + ), + complexity_rule=( + complexity_rule + ), + ) + ) + + factor_verifier.seed_mid_episode( + state + ) + + else: + raise RuntimeError( + "unexpected adaptive condition" + ) + + if result.done: + if ( + result.next_observation + is not None + ): + raise RuntimeError( + "terminal observation leak" + ) + else: + if ( + result.next_observation + not in (0, 1) + ): + raise RuntimeError( + "invalid next observation" + ) + + observation = ( + result.next_observation + ) + + episode_rewards.append( + scored_reward + ) + + # Explicit unresolved proposal receipts. + if ( + reference_verifier is not None + and reference_verifier.proposal_open + and not reference_verifier.proposal_resolved + ): + receipts.append( + _reference_receipt( + condition=condition, + world_seed=world_seed, + verifier=reference_verifier, + episode=EPISODES - 1, + event_index=( + global_scored_event_index + ), + authorized_depth=None, + resolution=( + "VERIFIER_REJECT_END_OF_RUN" + ), + ) + ) + + rejected_repairs += 1 + reference_verifier.mark_resolved() + + if ( + factor_verifier is not None + and factor_verifier.proposal_open + and not factor_verifier.proposal_resolved + ): + receipts.append( + _factor_receipt( + condition=condition, + world_seed=world_seed, + verifier=factor_verifier, + episode=EPISODES - 1, + event_index=( + global_scored_event_index + ), + authorized_depth=None, + resolution=( + "VERIFIER_REJECT_END_OF_RUN" + ), + ) + ) + + rejected_repairs += 1 + factor_verifier.mark_resolved() + + records = receipts.records + + if not verify_receipt_chain( + records, + expected_count=receipts.count, + expected_tip=receipts.tip, + ): + raise RuntimeError( + "receipt-chain verification failed" + ) + + total_reward = sum( + episode_rewards + ) + + total_trials = ( + EPISODES + * DECISION_STEPS_PER_EPISODE + ) + + implementation_hash = ( + implementation_sha256() + ) + + run_identity_material = { + "benchmark_version": ( + BENCHMARK_VERSION + ), + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "implementation_sha256": ( + implementation_hash + ), + "frozen_identities": frozen, + } + + deterministic_run_identity = ( + hashlib.sha256( + canonical_bytes( + run_identity_material + ) + ).hexdigest() + ) + + payload = { + "benchmark_version": ( + BENCHMARK_VERSION + ), + "condition": condition, + "world_seed": world_seed, + "learner_seed": learner_seed, + "episodes": EPISODES, + "decision_steps_per_episode": ( + DECISION_STEPS_PER_EPISODE + ), + "warmup_steps": WARMUP_STEPS, + "episode_rewards": ( + episode_rewards + ), + "primary_aulc_ppm": ( + _primary_aulc_ppm( + episode_rewards + ) + ), + "final_window_reward_ppm": ( + _final_window_ppm( + episode_rewards + ) + ), + "total_reward": total_reward, + "cumulative_regret": ( + total_trials + - total_reward + ), + "proposed_repairs": ( + proposed_repairs + ), + "accepted_repairs": ( + accepted_repairs + ), + "rejected_repairs": ( + rejected_repairs + ), + "verifier_supported_repairs": ( + verifier_supported_repairs + ), + "final_representation_depth": ( + current_depth + ), + "representation_change_episodes": ( + representation_change_episodes + ), + "authorization_latencies_scored_events": ( + authorization_latencies + ), + "mean_authorization_latency_scored_events": ( + sum( + authorization_latencies + ) + // len( + authorization_latencies + ) + if authorization_latencies + else None + ), + "selected_witness_lags": ( + selected_witness_lags + ), + "repair_receipts": records, + "canonical_receipt_count": ( + receipts.count + ), + "repair_receipt_chain_tip": ( + receipts.tip + ), + "repair_receipt_chain_valid": True, + "deterministic_run_identity": ( + deterministic_run_identity + ), + "integrity_failures": 0, + "complexity_rule": ( + complexity_rule + ), + "frozen_identities": frozen, + "implementation_sha256": ( + implementation_hash + ), + "source_commit": ( + source_commit() + ), + "source_dirty": ( + source_dirty() + ), + } + + return AdaptiveResult( + payload=payload + ) diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/evaluation_tools/frozen_evaluation.py b/experiments/prime_canonical_agent_benchmark_v1_3/evaluation_tools/frozen_evaluation.py new file mode 100644 index 0000000..f0cf23f --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/evaluation_tools/frozen_evaluation.py @@ -0,0 +1,1224 @@ +"""Frozen held-out evaluator for PRIME Canonical Agent Benchmark v1.3.""" + +import argparse +import hashlib +import json +import os +from pathlib import Path +import subprocess + +from experiments.prime_canonical_agent_benchmark_v1.deterministic import ( + splitmix64, +) +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from experiments.prime_canonical_agent_benchmark_v1_3.adaptive_runner import ( + run_adaptive_condition, +) +from experiments.prime_canonical_agent_benchmark_v1_3.manifest import ( + ADAPTIVE_CONDITIONS, + EVALUATION_SEEDS, +) +from experiments.prime_canonical_agent_benchmark_v1_3.provenance import ( + frozen_identities, + implementation_sha256, +) +from experiments.prime_canonical_agent_benchmark_v1_2.receipts import ( + verify_receipt_chain, +) + + +HERE = Path(__file__).resolve().parent +V13 = HERE.parent +REPO = V13.parent.parent + +FROZEN_CORE_SHA256 = ( + "3f8082ad340af46f786a773922ec4a5a" + "49d42fda01f77fe658b911d44afe957e" +) + +FIXED_CONDITIONS = ( + "REACTIVE", + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", +) + +ALL_CONDITIONS = ( + FIXED_CONDITIONS + + ADAPTIVE_CONDITIONS +) + +BOOTSTRAP_REPLICATES = 16384 +BOOTSTRAP_SEED = 0x5052494D45563131 +BOOTSTRAP_LOWER_INDEX = 409 +BOOTSTRAP_UPPER_INDEX = 15974 + +UNLOCK = "RUN_FROZEN_EVALUATION_V1_3" + + +def canonical_bytes(value: object) -> bytes: + return ( + json.dumps( + value, + sort_keys=True, + separators=(",", ":"), + ensure_ascii=False, + ) + + "\n" + ).encode("utf-8") + + +def sha256_file(path: Path) -> str: + return hashlib.sha256( + path.read_bytes() + ).hexdigest() + + +def verify_checksum( + target: Path, + checksum: Path, +) -> str: + expected = checksum.read_text( + encoding="utf-8" + ).split()[0] + + actual = sha256_file(target) + + if actual != expected: + raise RuntimeError( + f"checksum mismatch: {target}" + ) + + return actual + + +def git_clean() -> bool: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "status", + "--porcelain", + ], + check=True, + capture_output=True, + text=True, + ) + + return result.stdout.strip() == "" + + +def git_commit() -> str: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "rev-parse", + "HEAD", + ], + check=True, + capture_output=True, + text=True, + ) + + return result.stdout.strip() + + +def mean_floor(values: list[int]) -> int | None: + if not values: + return None + + return sum(values) // len(values) + + +def paired_bootstrap( + deltas: list[int], +) -> dict: + if len(deltas) != 128: + raise RuntimeError( + "paired bootstrap requires 128 worlds" + ) + + sums = [] + + for replicate in range( + BOOTSTRAP_REPLICATES + ): + total = 0 + + for draw in range(128): + index = ( + splitmix64( + BOOTSTRAP_SEED + ^ splitmix64(replicate) + ^ splitmix64(draw) + ) + % 128 + ) + + total += deltas[index] + + sums.append(total) + + sums.sort() + + lower = sums[ + BOOTSTRAP_LOWER_INDEX + ] + + upper = sums[ + BOOTSTRAP_UPPER_INDEX + ] + + observed = sum(deltas) + + return { + "replicates": ( + BOOTSTRAP_REPLICATES + ), + "sample_size": 128, + "seed_hex": hex( + BOOTSTRAP_SEED + ), + "lower_index": ( + BOOTSTRAP_LOWER_INDEX + ), + "upper_index": ( + BOOTSTRAP_UPPER_INDEX + ), + "observed_sum_delta": observed, + "observed_mean_delta_ppm": ( + observed // 128 + ), + "lower_sum_delta": lower, + "lower_mean_delta_ppm": ( + lower // 128 + ), + "upper_sum_delta": upper, + "upper_mean_delta_ppm": ( + upper // 128 + ), + } + + +def preflight() -> dict: + if EVALUATION_SEEDS != tuple( + range(3000, 3128) + ): + raise RuntimeError( + "v1.3 evaluation seeds changed" + ) + + if not git_clean(): + raise RuntimeError( + "Git worktree must be clean" + ) + + identities = frozen_identities() + + verify_checksum( + V13 / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json", + V13 / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.sha256", + ) + + verify_checksum( + V13 / "EVALUATION_ANALYSIS_PLAN.md", + V13 / "EVALUATION_ANALYSIS_PLAN.sha256", + ) + + verify_checksum( + HERE / "frozen_evaluation.py", + HERE / "frozen_evaluation.sha256", + ) + + diagnostic = json.loads( + ( + V13 + / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json" + ).read_text() + ) + + if diagnostic[ + "evaluation_seeds_run" + ] is not False: + raise RuntimeError( + "development diagnostic reports " + "evaluation execution" + ) + + if ( + diagnostic[ + "implementation_sha256" + ] + != FROZEN_CORE_SHA256 + ): + raise RuntimeError( + "development diagnostic core mismatch" + ) + + comparator = json.loads( + ( + V13 + / "DEVELOPMENT_FIXED_COMPARATOR.json" + ).read_text() + ) + + if ( + comparator[ + "selected_fixed_baseline" + ] + != "FIXED-H4" + ): + raise RuntimeError( + "frozen comparator is not FIXED-H4" + ) + + core = implementation_sha256() + + if core != FROZEN_CORE_SHA256: + raise RuntimeError( + "v1.3 core implementation hash mismatch: " + + core + ) + + return { + "source_commit": git_commit(), + "core_implementation_sha256": ( + core + ), + "selected_fixed_comparator": ( + "FIXED-H4" + ), + "frozen_identities": ( + identities + ), + "development_diagnostic_sha256": ( + sha256_file( + V13 + / "DEVELOPMENT_ADAPTIVE_DIAGNOSTIC.json" + ) + ), + "analysis_plan_sha256": ( + sha256_file( + V13 + / "EVALUATION_ANALYSIS_PLAN.md" + ) + ), + "evaluation_harness_sha256": ( + sha256_file( + HERE + / "frozen_evaluation.py" + ) + ), + } + + +def receipt_diagnostics( + result: dict, +) -> dict: + latencies = [] + witness_lags = [] + + for record in result[ + "repair_receipts" + ]: + payload = record[ + "payload" + ] + + latency = payload.get( + "authorization_latency_scored_events" + ) + + if latency is not None: + latencies.append( + latency + ) + + witness = payload.get( + "selected_witness_lag" + ) + + if witness is not None: + witness_lags.append( + witness + ) + + return { + "latencies": latencies, + "selected_witness_lags": ( + witness_lags + ), + } + + +def metric_map( + rows: list[dict], + condition: str, + metric: str, +) -> dict[int, int]: + return { + row["world_seed"]: row[ + metric + ] + for row in rows + if row["condition"] + == condition + } + + +def exact_recovery_count( + rows: list[dict], + condition: str, +) -> int: + return sum( + row[ + "final_representation_depth" + ] + == row[ + "diagnostic_hidden_depth" + ] + for row in rows + if row["condition"] + == condition + ) + + +def paired_comparison( + *, + rows: list[dict], + left: str, + right: str, + integrity_pass: bool, + require_recovery_preservation: bool, +) -> dict: + left_primary = metric_map( + rows, + left, + "primary_aulc_ppm", + ) + + right_primary = metric_map( + rows, + right, + "primary_aulc_ppm", + ) + + left_final = metric_map( + rows, + left, + "final_window_reward_ppm", + ) + + right_final = metric_map( + rows, + right, + "final_window_reward_ppm", + ) + + deltas = [ + left_primary[seed] + - right_primary[seed] + for seed in EVALUATION_SEEDS + ] + + final_deltas = [ + left_final[seed] + - right_final[seed] + for seed in EVALUATION_SEEDS + ] + + bootstrap = paired_bootstrap( + deltas + ) + + mean_positive = ( + sum(deltas) > 0 + ) + + lower_positive = ( + bootstrap[ + "lower_sum_delta" + ] > 0 + ) + + final_not_degraded = ( + sum(final_deltas) >= 0 + ) + + left_recovery = ( + exact_recovery_count( + rows, + left, + ) + ) + + right_recovery = ( + exact_recovery_count( + rows, + right, + ) + ) + + recovery_preserved = ( + left_recovery + >= right_recovery + ) + + criteria = [ + mean_positive, + lower_positive, + final_not_degraded, + integrity_pass, + ] + + if require_recovery_preservation: + criteria.append( + recovery_preserved + ) + + supported = all( + criteria + ) + + return { + "left_condition": left, + "right_condition": right, + "bootstrap": bootstrap, + "mean_delta_positive": ( + mean_positive + ), + "bootstrap_lower_positive": ( + lower_positive + ), + "mean_final_delta_ppm": ( + sum(final_deltas) // 128 + ), + "final_not_degraded": ( + final_not_degraded + ), + "left_exact_depth_recovery": ( + left_recovery + ), + "right_exact_depth_recovery": ( + right_recovery + ), + "recovery_preserved": ( + recovery_preserved + ), + "recovery_preservation_required": ( + require_recovery_preservation + ), + "integrity_pass": ( + integrity_pass + ), + "claim": ( + "SUPPORTED" + if supported + else "NOT SUPPORTED" + ), + } + + +def diagnostic_comparison( + rows: list[dict], + left: str, + right: str, +) -> dict: + left_primary = metric_map( + rows, + left, + "primary_aulc_ppm", + ) + + right_primary = metric_map( + rows, + right, + "primary_aulc_ppm", + ) + + deltas = [ + left_primary[seed] + - right_primary[seed] + for seed in EVALUATION_SEEDS + ] + + return { + "left_condition": left, + "right_condition": right, + "bootstrap": paired_bootstrap( + deltas + ), + "status": "DIAGNOSTIC_ONLY", + } + + +def build_report() -> dict: + preflight_record = preflight() + + rows = [] + + for seed in EVALUATION_SEEDS: + hidden_depth = ( + (0, 1, 2, 4)[ + seed % 4 + ] + ) + + for condition in FIXED_CONDITIONS: + result = run_fixed_condition( + seed, + condition, + ).payload + + if result[ + "source_dirty" + ]: + raise RuntimeError( + "fixed result reports dirty source" + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": ( + hidden_depth + ), + "condition": condition, + "primary_aulc_ppm": ( + result[ + "primary_aulc_ppm" + ] + ), + "final_window_reward_ppm": ( + result[ + "final_window_reward_ppm" + ] + ), + "cumulative_regret": ( + result[ + "cumulative_regret" + ] + ), + "final_representation_depth": ( + result[ + "representation_depth" + ] + ), + "proposed_repairs": 0, + "accepted_repairs": 0, + "rejected_repairs": 0, + "verifier_supported_repairs": 0, + "receipt_chain_valid": True, + "authorization_latencies": [], + "selected_witness_lags": [], + } + ) + + for condition in ADAPTIVE_CONDITIONS: + result = run_adaptive_condition( + seed, + condition, + permit_evaluation=True, + ).payload + + if result[ + "source_dirty" + ]: + raise RuntimeError( + "adaptive result reports dirty source" + ) + + if ( + result[ + "source_commit" + ] + != preflight_record[ + "source_commit" + ] + ): + raise RuntimeError( + "adaptive source commit mismatch" + ) + + if ( + result[ + "implementation_sha256" + ] + != FROZEN_CORE_SHA256 + ): + raise RuntimeError( + "adaptive core hash mismatch" + ) + + receipt_ok = ( + verify_receipt_chain( + result[ + "repair_receipts" + ], + expected_count=( + result[ + "canonical_receipt_count" + ] + ), + expected_tip=( + result[ + "repair_receipt_chain_tip" + ] + ), + ) + ) + + if not receipt_ok: + raise RuntimeError( + "receipt-chain failure" + ) + + diag = receipt_diagnostics( + result + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": ( + hidden_depth + ), + "condition": condition, + "primary_aulc_ppm": ( + result[ + "primary_aulc_ppm" + ] + ), + "final_window_reward_ppm": ( + result[ + "final_window_reward_ppm" + ] + ), + "cumulative_regret": ( + result[ + "cumulative_regret" + ] + ), + "final_representation_depth": ( + result[ + "final_representation_depth" + ] + ), + "proposed_repairs": ( + result[ + "proposed_repairs" + ] + ), + "accepted_repairs": ( + result[ + "accepted_repairs" + ] + ), + "rejected_repairs": ( + result[ + "rejected_repairs" + ] + ), + "verifier_supported_repairs": ( + result[ + "verifier_supported_repairs" + ] + ), + "receipt_chain_valid": ( + receipt_ok + ), + "authorization_latencies": ( + diag[ + "latencies" + ] + ), + "selected_witness_lags": ( + diag[ + "selected_witness_lags" + ] + ), + } + ) + + summaries = {} + + for condition in ALL_CONDITIONS: + subset = [ + row + for row in rows + if row["condition"] + == condition + ] + + latencies = [ + latency + for row in subset + for latency in row[ + "authorization_latencies" + ] + ] + + summaries[condition] = { + "world_count": len( + subset + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_reward_ppm": ( + mean_floor( + [ + row[ + "final_window_reward_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_regret": ( + mean_floor( + [ + row[ + "cumulative_regret" + ] + for row in subset + ] + ) + ), + "total_proposed_repairs": sum( + row[ + "proposed_repairs" + ] + for row in subset + ), + "total_accepted_repairs": sum( + row[ + "accepted_repairs" + ] + for row in subset + ), + "total_rejected_repairs": sum( + row[ + "rejected_repairs" + ] + for row in subset + ), + "total_verifier_supported_repairs": sum( + row[ + "verifier_supported_repairs" + ] + for row in subset + ), + "exact_depth_recovery": ( + exact_recovery_count( + rows, + condition, + ) + ), + "mean_authorization_latency": ( + mean_floor( + latencies + ) + ), + "max_authorization_latency": ( + max(latencies) + if latencies + else None + ), + "immediate_authorizations": sum( + latency == 0 + for latency in latencies + ), + "all_receipt_chains_valid": all( + row[ + "receipt_chain_valid" + ] + for row in subset + ), + } + + integrity_pass = ( + git_clean() + and len(rows) + == 128 * len( + ALL_CONDITIONS + ) + and all( + summary[ + "world_count" + ] == 128 + for summary + in summaries.values() + ) + and all( + summary[ + "all_receipt_chains_valid" + ] + for summary + in summaries.values() + ) + ) + + primary_upgrade = ( + paired_comparison( + rows=rows, + left="FULL-PRIME-V1.3", + right=( + "FULL-PRIME-V1.2-REFERENCE" + ), + integrity_pass=( + integrity_pass + ), + require_recovery_preservation=True, + ) + ) + + fixed_h4 = paired_comparison( + rows=rows, + left="FULL-PRIME-V1.3", + right="FIXED-H4", + integrity_pass=( + integrity_pass + ), + require_recovery_preservation=False, + ) + + factorization = ( + paired_comparison( + rows=rows, + left=( + "FACTOR-WITNESS-CARRIER-COST" + ), + right=( + "FULL-PRIME-V1.2-REFERENCE" + ), + integrity_pass=( + integrity_pass + ), + require_recovery_preservation=True, + ) + ) + + repricing = ( + diagnostic_comparison( + rows, + "FULL-PRIME-V1.3", + "FACTOR-WITNESS-CARRIER-COST", + ) + ) + + adaptive_diagnostics = {} + + diagnostic_conditions = ( + "FULL-PRIME-V1.2-REFERENCE", + "FACTOR-WITNESS-CARRIER-COST", + "FULL-PRIME-V1.3", + ) + + for condition in diagnostic_conditions: + entries = [] + + for depth in ( + 0, + 1, + 2, + 4, + ): + subset = [ + row + for row in rows + if ( + row[ + "condition" + ] == condition + and row[ + "diagnostic_hidden_depth" + ] == depth + ) + ] + + depth_counts = {} + + witness_counts = {} + + for row in subset: + key = str( + row[ + "final_representation_depth" + ] + ) + + depth_counts[key] = ( + depth_counts.get( + key, + 0, + ) + + 1 + ) + + for lag in row[ + "selected_witness_lags" + ]: + lag_key = str( + lag + ) + + witness_counts[ + lag_key + ] = ( + witness_counts.get( + lag_key, + 0, + ) + + 1 + ) + + latencies = [ + latency + for row in subset + for latency in row[ + "authorization_latencies" + ] + ] + + entries.append( + { + "hidden_depth": depth, + "world_count": len( + subset + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row + in subset + ] + ) + ), + "mean_final_window_reward_ppm": ( + mean_floor( + [ + row[ + "final_window_reward_ppm" + ] + for row + in subset + ] + ) + ), + "final_depth_counts": ( + depth_counts + ), + "accepted_repairs": sum( + row[ + "accepted_repairs" + ] + for row in subset + ), + "rejected_repairs": sum( + row[ + "rejected_repairs" + ] + for row in subset + ), + "mean_authorization_latency": ( + mean_floor( + latencies + ) + ), + "max_authorization_latency": ( + max( + latencies + ) + if latencies + else None + ), + "immediate_authorizations": sum( + latency == 0 + for latency + in latencies + ), + "selected_witness_counts": ( + witness_counts + ), + } + ) + + adaptive_diagnostics[ + condition + ] = entries + + return { + "benchmark": ( + "prime-canonical-agent-benchmark-v1.3" + ), + "status": ( + "FROZEN_EVALUATION_COMPLETE" + ), + "evaluation_seed_count": 128, + "evaluation_seeds": list( + EVALUATION_SEEDS + ), + "condition_count": len( + ALL_CONDITIONS + ), + "row_count": len(rows), + "preflight": ( + preflight_record + ), + "condition_summaries": ( + summaries + ), + "primary_upgrade_v13_vs_v12_reference": ( + primary_upgrade + ), + "fixed_h4_comparison": ( + fixed_h4 + ), + "factorization_only_comparison": ( + factorization + ), + "repricing_diagnostic": ( + repricing + ), + "adaptive_depth_diagnostics": ( + adaptive_diagnostics + ), + "integrity_pass": ( + integrity_pass + ), + "rows": rows, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + + parser.add_argument( + "--preflight-only", + action="store_true", + ) + + parser.add_argument( + "--unlock", + ) + + parser.add_argument( + "--output", + ) + + args = parser.parse_args() + + if args.preflight_only: + print( + json.dumps( + preflight(), + sort_keys=True, + indent=2, + ) + ) + return + + if args.unlock != UNLOCK: + raise SystemExit( + "v1.3 held-out evaluation remains locked" + ) + + if not args.output: + raise SystemExit( + "--output is required" + ) + + output = Path( + args.output + ).expanduser().resolve() + + try: + output.relative_to( + REPO.resolve() + ) + except ValueError: + pass + else: + raise SystemExit( + "evaluation output must be outside Git worktree" + ) + + if output.exists(): + raise SystemExit( + "refusing to overwrite existing evaluation output" + ) + + report = build_report() + + temporary = output.with_name( + output.name + ".partial" + ) + + temporary.write_bytes( + canonical_bytes( + report + ) + ) + + os.replace( + temporary, + output, + ) + + print( + json.dumps( + { + "status": ( + report[ + "status" + ] + ), + "primary_upgrade_claim": ( + report[ + "primary_upgrade_v13_vs_v12_reference" + ]["claim"] + ), + "fixed_h4_claim": ( + report[ + "fixed_h4_comparison" + ]["claim"] + ), + "factorization_claim": ( + report[ + "factorization_only_comparison" + ]["claim"] + ), + "output": str( + output + ), + "sha256": ( + sha256_file( + output + ) + ), + }, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/evaluation_tools/frozen_evaluation.sha256 b/experiments/prime_canonical_agent_benchmark_v1_3/evaluation_tools/frozen_evaluation.sha256 new file mode 100644 index 0000000..bf40be5 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/evaluation_tools/frozen_evaluation.sha256 @@ -0,0 +1 @@ +2c43ef2595a744a9a0d63195d0b106f09e66c383262d5251aee47a87be057451 frozen_evaluation.py diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/factor_verifier.py b/experiments/prime_canonical_agent_benchmark_v1_3/factor_verifier.py new file mode 100644 index 0000000..e58e314 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/factor_verifier.py @@ -0,0 +1,548 @@ +"""Factorized anytime-valid lag-witness verifier for PRIME v1.3.""" + +from dataclasses import dataclass, field + +from experiments.prime_canonical_agent_benchmark_v1_2.verifier import ( + PrequentialPredictor, + state_from_history, +) + + +PERMITTED_DEPTHS = (0, 1, 2, 4) +WITNESS_THRESHOLD = 576 +OBSTRUCTION_MIN_PER_TARGET = 8 + +CARRIER_COST = "carrier" +COORDINATE_COST = "coordinate" + +COMPLEXITY_RULES = ( + CARRIER_COST, + COORDINATE_COST, +) + + +def representation_complexity(depth: int) -> int: + return 2 ** (depth + 1) + + +def active_witness_lags( + current_depth: int, +) -> tuple[int, ...]: + if current_depth not in PERMITTED_DEPTHS: + raise ValueError("invalid current depth") + + return tuple( + lag + for lag in range(current_depth + 1, 5) + ) + + +def required_depth_for_lag(lag: int) -> int: + mapping = { + 1: 1, + 2: 2, + 3: 4, + 4: 4, + } + + if lag not in mapping: + raise ValueError("invalid witness lag") + + return mapping[lag] + + +def lag_value( + history: list[int], + lag: int, +) -> int: + """Return X[t-lag], zero padded consistently with parent histories.""" + index = len(history) - 1 - lag + + if index < 0: + return 0 + + return history[index] + + +@dataclass +class WitnessEvidence: + lag: int + wins: int = 0 + losses: int = 0 + + @property + def required_depth(self) -> int: + return required_depth_for_lag( + self.lag + ) + + @property + def discordant(self) -> int: + return self.wins + self.losses + + @property + def net_advantage(self) -> int: + return self.wins - self.losses + + @property + def evidence_lhs(self) -> int: + return 3 ** self.wins + + @property + def evidence_rhs(self) -> int: + return ( + WITNESS_THRESHOLD + * 2 ** self.discordant + ) + + @property + def statistical_pass(self) -> bool: + return ( + self.evidence_lhs + >= self.evidence_rhs + ) + + def complexity_cost( + self, + current_depth: int, + complexity_rule: str, + ) -> int: + d = self.required_depth + + if complexity_rule == CARRIER_COST: + return ( + representation_complexity(d) + - representation_complexity( + current_depth + ) + ) + + if complexity_rule == COORDINATE_COST: + return d - current_depth + + raise ValueError( + "unknown complexity rule" + ) + + def complexity_pass( + self, + current_depth: int, + complexity_rule: str, + ) -> bool: + return ( + self.net_advantage + > self.complexity_cost( + current_depth, + complexity_rule, + ) + ) + + def supported( + self, + current_depth: int, + complexity_rule: str, + ) -> bool: + return ( + self.statistical_pass + and self.complexity_pass( + current_depth, + complexity_rule, + ) + ) + + def summary( + self, + current_depth: int, + complexity_rule: str, + ) -> dict: + cost = self.complexity_cost( + current_depth, + complexity_rule, + ) + + return { + "witness_lag": self.lag, + "required_policy_depth": ( + self.required_depth + ), + "wins": self.wins, + "losses": self.losses, + "discordant": self.discordant, + "net_advantage": ( + self.net_advantage + ), + "evidence_lhs": ( + self.evidence_lhs + ), + "evidence_rhs": ( + self.evidence_rhs + ), + "evidence_threshold": ( + WITNESS_THRESHOLD + ), + "statistical_pass": ( + self.statistical_pass + ), + "complexity_rule": ( + complexity_rule + ), + "complexity_cost": cost, + "complexity_pass": ( + self.net_advantage > cost + ), + "supported": self.supported( + current_depth, + complexity_rule, + ), + } + + +@dataclass(frozen=True) +class FrozenWitnessPrediction: + current_state: tuple[int, ...] + witness_states: dict[ + int, + tuple[int, ...], + ] + current_prediction: int + witness_predictions: dict[int, int] + + +@dataclass(frozen=True) +class FactorFinalizeOutcome: + proposal_opened: bool + supported_lags: tuple[int, ...] + + +class FactorizedVerifierEpoch: + """One factorized verifier epoch.""" + + def __init__( + self, + current_depth: int, + complexity_rule: str, + *, + seed_history: tuple[int, ...] = (), + ): + if current_depth not in PERMITTED_DEPTHS: + raise ValueError( + "invalid current depth" + ) + + if complexity_rule not in COMPLEXITY_RULES: + raise ValueError( + "invalid complexity rule" + ) + + self.current_depth = current_depth + self.complexity_rule = ( + complexity_rule + ) + + self.witness_lags = ( + active_witness_lags( + current_depth + ) + ) + + self.current_predictor = ( + PrequentialPredictor() + ) + + self.witness_predictors = { + lag: PrequentialPredictor() + for lag in self.witness_lags + } + + self.evidence = { + lag: WitnessEvidence(lag=lag) + for lag in self.witness_lags + } + + self.obstruction_counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + self._history = list( + seed_history + )[-5:] + + self.proposal_open = False + self.proposal_resolved = False + + self.obstruction_episode: ( + int | None + ) = None + + self.obstruction_event_index: ( + int | None + ) = None + + self.discordant_at_obstruction: ( + dict[int, int] + ) = {} + + def reset_episode(self) -> None: + self._history = [] + + def seed_mid_episode( + self, + policy_state: tuple[int, ...], + ) -> None: + # Only state visible under old policy + # authority is permitted here. + self._history = list( + policy_state + )[-5:] + + def freeze_prediction( + self, + observation: int, + policy_state: tuple[int, ...], + ) -> FrozenWitnessPrediction: + if observation not in (0, 1): + raise ValueError( + "observation must be binary" + ) + + self._history.append( + observation + ) + + self._history = ( + self._history[-5:] + ) + + verifier_current = ( + state_from_history( + self._history, + self.current_depth, + ) + ) + + if verifier_current != policy_state: + raise RuntimeError( + "policy/verifier current-state mismatch" + ) + + witness_states = {} + + for lag in self.witness_lags: + bit = lag_value( + self._history, + lag, + ) + + witness_states[lag] = ( + tuple(policy_state) + + (bit,) + ) + + current_prediction = ( + self.current_predictor.predict( + policy_state + ) + ) + + witness_predictions = { + lag: ( + self.witness_predictors[ + lag + ].predict( + witness_states[lag] + ) + ) + for lag in self.witness_lags + } + + return FrozenWitnessPrediction( + current_state=policy_state, + witness_states=witness_states, + current_prediction=( + current_prediction + ), + witness_predictions=( + witness_predictions + ), + ) + + def _obstruction_exists(self) -> bool: + return any( + counts[0] + >= OBSTRUCTION_MIN_PER_TARGET + and counts[1] + >= OBSTRUCTION_MIN_PER_TARGET + for counts + in self.obstruction_counts.values() + ) + + def supported_lags( + self, + ) -> tuple[int, ...]: + return tuple( + lag + for lag in self.witness_lags + if self.evidence[lag].supported( + self.current_depth, + self.complexity_rule, + ) + ) + + def selected_supported_lag( + self, + ) -> int | None: + supported = self.supported_lags() + + if not supported: + return None + + return min( + supported, + key=lambda lag: ( + required_depth_for_lag(lag), + lag, + ), + ) + + def finalize_event( + self, + frozen: FrozenWitnessPrediction, + *, + target: int, + episode: int, + scored_event_index: int, + ) -> FactorFinalizeOutcome: + if target not in (0, 1): + raise ValueError( + "target must be binary" + ) + + # Score all predictions before + # predictors learn this target. + for lag in self.witness_lags: + witness_prediction = ( + frozen.witness_predictions[ + lag + ] + ) + + if ( + witness_prediction + != frozen.current_prediction + ): + if ( + witness_prediction + == target + ): + self.evidence[ + lag + ].wins += 1 + else: + self.evidence[ + lag + ].losses += 1 + + bucket = ( + self.obstruction_counts.setdefault( + frozen.current_state, + [0, 0], + ) + ) + + bucket[target] += 1 + + self.current_predictor.update( + frozen.current_state, + target, + ) + + for lag in self.witness_lags: + self.witness_predictors[ + lag + ].update( + frozen.witness_states[ + lag + ], + target, + ) + + proposal_opened = False + + if ( + not self.proposal_open + and not self.proposal_resolved + and self.witness_lags + and self._obstruction_exists() + ): + self.proposal_open = True + proposal_opened = True + + self.obstruction_episode = ( + episode + ) + + self.obstruction_event_index = ( + scored_event_index + ) + + self.discordant_at_obstruction = { + lag: ( + self.evidence[ + lag + ].discordant + ) + for lag in self.witness_lags + } + + supported = () + + if ( + self.proposal_open + and not self.proposal_resolved + ): + supported = ( + self.supported_lags() + ) + + return FactorFinalizeOutcome( + proposal_opened=( + proposal_opened + ), + supported_lags=supported, + ) + + def witness_summaries( + self, + ) -> list[dict]: + return [ + self.evidence[lag].summary( + self.current_depth, + self.complexity_rule, + ) + for lag in self.witness_lags + ] + + def additional_discordant_after_obstruction( + self, + lag: int, + ) -> int | None: + before = ( + self.discordant_at_obstruction.get( + lag + ) + ) + + if before is None: + return None + + return ( + self.evidence[ + lag + ].discordant + - before + ) + + def mark_resolved(self) -> None: + self.proposal_open = False + self.proposal_resolved = True diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/manifest.py b/experiments/prime_canonical_agent_benchmark_v1_3/manifest.py new file mode 100644 index 0000000..a2a8240 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/manifest.py @@ -0,0 +1,33 @@ +"""Frozen configuration for PRIME Canonical Agent Benchmark v1.3.""" + +BENCHMARK_VERSION = "prime-canonical-agent-benchmark-v1.3" + +DEVELOPMENT_SEEDS = tuple(range(300, 332)) +EVALUATION_SEEDS = tuple(range(3000, 3128)) + +PERMITTED_DEPTHS = (0, 1, 2, 4) + +FIXED_CONDITIONS = ( + "FIXED-H1", + "FIXED-H2", + "FIXED-H4", +) + +ADAPTIVE_CONDITIONS = ( + "ADAPTIVE-NO-VERIFIER", + "FULL-PRIME-V1.2-REFERENCE", + "FACTOR-WITNESS-CARRIER-COST", + "FULL-PRIME-V1.3", +) + +PARENT_V12_FINAL_COMMIT = "6f17789" + +PARENT_V12_RESULT_SHA256 = ( + "6ce64dc7aa0bcc44ce1453788162a007" + "ea79429d0283e69d6ba4e8c9e91028f0" +) + +PARENT_V12_CORE_SHA256 = ( + "bed64cbe558c928d3793c915e3426063" + "8c9c0ed3f7061c350695e769b5c3efc9" +) diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/provenance.py b/experiments/prime_canonical_agent_benchmark_v1_3/provenance.py new file mode 100644 index 0000000..b3cf4e7 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/provenance.py @@ -0,0 +1,191 @@ +"""Frozen provenance for PRIME canonical agent benchmark v1.3.""" + +import hashlib +from pathlib import Path +import subprocess + + +HERE = Path(__file__).resolve().parent +EXPERIMENTS = HERE.parent +V1 = EXPERIMENTS / "prime_canonical_agent_benchmark_v1" +V12 = EXPERIMENTS / "prime_canonical_agent_benchmark_v1_2" +REPO = EXPERIMENTS.parent + + +def _sha256(path: Path) -> str: + return hashlib.sha256( + path.read_bytes() + ).hexdigest() + + +def _verify( + directory: Path, + target_name: str, + checksum_name: str, +) -> str: + target = directory / target_name + + expected = ( + directory + / checksum_name + ).read_text( + encoding="utf-8" + ).split()[0] + + actual = _sha256(target) + + if actual != expected: + raise RuntimeError( + f"frozen hash mismatch: {target}" + ) + + return actual + + +def frozen_identities() -> dict: + return { + "v1_3_contract_sha256": _verify( + HERE, + "EXPERIMENT_CONTRACT.md", + "EXPERIMENT_CONTRACT.sha256", + ), + "v1_3_lineage_sha256": _verify( + HERE, + "LINEAGE.json", + "LINEAGE.sha256", + ), + "v1_3_adaptive_rules_sha256": _verify( + HERE, + "ADAPTIVE_RULES.md", + "ADAPTIVE_RULES.sha256", + ), + "v1_3_fixed_comparator_sha256": _verify( + HERE, + "DEVELOPMENT_FIXED_COMPARATOR.json", + "DEVELOPMENT_FIXED_COMPARATOR.sha256", + ), + "parent_v1_2_result_sha256": _verify( + V12, + "FROZEN_EVALUATION_RESULT.json", + "FROZEN_EVALUATION_RESULT.sha256", + ), + } + + +def implementation_sha256() -> str: + """Hash only executable dependencies of the v1.3 adaptive core.""" + + entries: list[ + tuple[str, Path] + ] = [] + + # Canonical common apparatus. + for path in V1.glob("*.py"): + entries.append( + ( + f"v1/{path.name}", + path, + ) + ) + + # Frozen parent machinery reused directly + # by the v1.2-reference condition and + # receipt infrastructure. + for name in ( + "verifier.py", + "receipts.py", + ): + entries.append( + ( + f"v1_2/{name}", + V12 / name, + ) + ) + + # Explicit hypothesis-bearing v1.3 core. + for name in ( + "manifest.py", + "factor_verifier.py", + "adaptive_runner.py", + "provenance.py", + ): + path = HERE / name + + if path.exists(): + entries.append( + ( + f"v1_3/{name}", + path, + ) + ) + + digest = hashlib.sha256() + + for relative, path in sorted( + entries + ): + name = relative.encode( + "utf-8" + ) + payload = path.read_bytes() + + digest.update( + len(name).to_bytes( + 8, + "big", + ) + ) + digest.update(name) + + digest.update( + len(payload).to_bytes( + 8, + "big", + ) + ) + digest.update(payload) + + return digest.hexdigest() + + +def source_commit() -> str: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "rev-parse", + "HEAD", + ], + check=True, + capture_output=True, + text=True, + ) + + commit = result.stdout.strip() + + if len(commit) != 40: + raise RuntimeError( + "unexpected commit identity" + ) + + return commit + + +def source_dirty() -> bool: + result = subprocess.run( + [ + "git", + "-C", + str(REPO), + "status", + "--porcelain", + ], + check=True, + capture_output=True, + text=True, + ) + + return bool( + result.stdout.strip() + ) diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/run_adaptive_development.py b/experiments/prime_canonical_agent_benchmark_v1_3/run_adaptive_development.py new file mode 100644 index 0000000..ae36bf5 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/run_adaptive_development.py @@ -0,0 +1,453 @@ +"""Frozen-rule development diagnostic sweep for PRIME v1.3.""" + +import json + +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from .adaptive_runner import ( + run_adaptive_condition, +) +from .manifest import ( + ADAPTIVE_CONDITIONS, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, +) +from .provenance import ( + frozen_identities, + implementation_sha256, +) + + +def mean_floor(values): + if not values: + return None + + return sum(values) // len(values) + + +def main() -> None: + if DEVELOPMENT_SEEDS != tuple( + range(300, 332) + ): + raise RuntimeError( + "development seeds changed" + ) + + if EVALUATION_SEEDS != tuple( + range(3000, 3128) + ): + raise RuntimeError( + "evaluation seeds changed" + ) + + rows = [] + + fixed_h4_values = [] + + for seed in DEVELOPMENT_SEEDS: + hidden_depth = ( + (0, 1, 2, 4)[ + seed % 4 + ] + ) + + fixed = run_fixed_condition( + seed, + "FIXED-H4", + ).payload + + fixed_h4_values.append( + fixed["primary_aulc_ppm"] + ) + + for condition in ADAPTIVE_CONDITIONS: + result = run_adaptive_condition( + seed, + condition, + ).payload + + if result["source_dirty"]: + raise RuntimeError( + "development sweep requires " + "clean committed source" + ) + + rows.append( + { + "world_seed": seed, + "diagnostic_hidden_depth": ( + hidden_depth + ), + "condition": condition, + "primary_aulc_ppm": ( + result[ + "primary_aulc_ppm" + ] + ), + "final_window_reward_ppm": ( + result[ + "final_window_reward_ppm" + ] + ), + "cumulative_regret": ( + result[ + "cumulative_regret" + ] + ), + "proposed_repairs": ( + result[ + "proposed_repairs" + ] + ), + "accepted_repairs": ( + result[ + "accepted_repairs" + ] + ), + "rejected_repairs": ( + result[ + "rejected_repairs" + ] + ), + "final_representation_depth": ( + result[ + "final_representation_depth" + ] + ), + "authorization_latencies": ( + result[ + "authorization_latencies_scored_events" + ] + ), + "selected_witness_lags": ( + result[ + "selected_witness_lags" + ] + ), + "receipt_chain_valid": ( + result[ + "repair_receipt_chain_valid" + ] + ), + "source_dirty": ( + result[ + "source_dirty" + ] + ), + } + ) + + summaries = {} + + for condition in ADAPTIVE_CONDITIONS: + subset = [ + row + for row in rows + if row["condition"] + == condition + ] + + latencies = [ + latency + for row in subset + for latency in row[ + "authorization_latencies" + ] + ] + + summaries[condition] = { + "world_count": len(subset), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_reward_ppm": ( + mean_floor( + [ + row[ + "final_window_reward_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_regret": ( + mean_floor( + [ + row[ + "cumulative_regret" + ] + for row in subset + ] + ) + ), + "total_proposed_repairs": sum( + row["proposed_repairs"] + for row in subset + ), + "total_accepted_repairs": sum( + row["accepted_repairs"] + for row in subset + ), + "total_rejected_repairs": sum( + row["rejected_repairs"] + for row in subset + ), + "mean_authorization_latency": ( + mean_floor(latencies) + ), + "max_authorization_latency": ( + max(latencies) + if latencies + else None + ), + "all_receipts_valid": all( + row[ + "receipt_chain_valid" + ] + for row in subset + ), + } + + by_depth = [] + + for depth in ( + 0, + 1, + 2, + 4, + ): + for condition in ADAPTIVE_CONDITIONS: + subset = [ + row + for row in rows + if ( + row[ + "diagnostic_hidden_depth" + ] == depth + and row["condition"] + == condition + ) + ] + + depth_counts = {} + + for row in subset: + key = str( + row[ + "final_representation_depth" + ] + ) + + depth_counts[key] = ( + depth_counts.get( + key, + 0, + ) + + 1 + ) + + latencies = [ + latency + for row in subset + for latency in row[ + "authorization_latencies" + ] + ] + + witness_counts = {} + + for row in subset: + for lag in row[ + "selected_witness_lags" + ]: + key = str(lag) + + witness_counts[key] = ( + witness_counts.get( + key, + 0, + ) + + 1 + ) + + by_depth.append( + { + "hidden_depth": depth, + "condition": condition, + "world_count": ( + len(subset) + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_reward_ppm": ( + mean_floor( + [ + row[ + "final_window_reward_ppm" + ] + for row in subset + ] + ) + ), + "final_depth_counts": ( + depth_counts + ), + "accepted_repairs": sum( + row[ + "accepted_repairs" + ] + for row in subset + ), + "rejected_repairs": sum( + row[ + "rejected_repairs" + ] + for row in subset + ), + "mean_authorization_latency": ( + mean_floor( + latencies + ) + ), + "max_authorization_latency": ( + max(latencies) + if latencies + else None + ), + "selected_witness_counts": ( + witness_counts + ), + } + ) + + by_condition_seed = { + condition: { + row["world_seed"]: row + for row in rows + if row["condition"] + == condition + } + for condition + in ADAPTIVE_CONDITIONS + } + + def mean_pair_delta( + left, + right, + ): + values = [ + by_condition_seed[left][ + seed + ]["primary_aulc_ppm"] + - by_condition_seed[right][ + seed + ]["primary_aulc_ppm"] + for seed in DEVELOPMENT_SEEDS + ] + + return mean_floor( + values + ) + + full_rows = [ + row + for row in rows + if row["condition"] + == "FULL-PRIME-V1.3" + ] + + exact_recovery = sum( + row[ + "final_representation_depth" + ] + == row[ + "diagnostic_hidden_depth" + ] + for row in full_rows + ) + + report = { + "benchmark": ( + "prime-canonical-agent-benchmark-v1.3" + ), + "status": ( + "DEVELOPMENT_ONLY_NOT_EVALUATION" + ), + "development_seeds": list( + DEVELOPMENT_SEEDS + ), + "evaluation_seeds_run": False, + "implementation_sha256": ( + implementation_sha256() + ), + "frozen_identities": ( + frozen_identities() + ), + "fixed_h4_mean_primary_aulc_ppm": ( + mean_floor( + fixed_h4_values + ) + ), + "condition_summaries": ( + summaries + ), + "paired_development_deltas": { + "v13_minus_v12_reference_ppm": ( + mean_pair_delta( + "FULL-PRIME-V1.3", + "FULL-PRIME-V1.2-REFERENCE", + ) + ), + "factor_carrier_minus_v12_reference_ppm": ( + mean_pair_delta( + "FACTOR-WITNESS-CARRIER-COST", + "FULL-PRIME-V1.2-REFERENCE", + ) + ), + "v13_minus_factor_carrier_ppm": ( + mean_pair_delta( + "FULL-PRIME-V1.3", + "FACTOR-WITNESS-CARRIER-COST", + ) + ), + }, + "full_v13_exact_depth_recovery": ( + exact_recovery + ), + "full_v13_exact_depth_total": ( + len(full_rows) + ), + "by_hidden_depth": ( + by_depth + ), + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/run_fixed_development.py b/experiments/prime_canonical_agent_benchmark_v1_3/run_fixed_development.py new file mode 100644 index 0000000..a206691 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/run_fixed_development.py @@ -0,0 +1,94 @@ +"""Select v1.3 fixed comparator using fresh development worlds only.""" + +import json + +from experiments.prime_canonical_agent_benchmark_v1.runner import ( + run_fixed_condition, +) + +from .manifest import ( + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, + FIXED_CONDITIONS, +) + + +DEPTH = { + "FIXED-H1": 1, + "FIXED-H2": 2, + "FIXED-H4": 4, +} + + +def main() -> None: + if DEVELOPMENT_SEEDS != tuple(range(300, 332)): + raise RuntimeError("v1.3 development seeds changed") + + if EVALUATION_SEEDS != tuple(range(3000, 3128)): + raise RuntimeError("v1.3 evaluation seeds changed") + + rows = [] + + for condition in FIXED_CONDITIONS: + values = [] + + for seed in DEVELOPMENT_SEEDS: + result = run_fixed_condition( + seed, + condition, + ).payload + + values.append( + result["primary_aulc_ppm"] + ) + + rows.append( + { + "condition": condition, + "representation_depth": DEPTH[condition], + "world_count": len(values), + "mean_primary_aulc_ppm": ( + sum(values) // len(values) + ), + } + ) + + best = max( + row["mean_primary_aulc_ppm"] + for row in rows + ) + + selected = min( + ( + row + for row in rows + if row["mean_primary_aulc_ppm"] == best + ), + key=lambda row: row["representation_depth"], + ) + + report = { + "benchmark": "prime-canonical-agent-benchmark-v1.3", + "status": "DEVELOPMENT_FIXED_COMPARATOR_SELECTION", + "development_seeds": list(DEVELOPMENT_SEEDS), + "evaluation_seeds_run": False, + "evaluation_seed_range": "3000..3127", + "selection_rule": ( + "highest mean primary_aulc_ppm; " + "ties select smaller representation" + ), + "rows": rows, + "selected_fixed_baseline": selected["condition"], + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_canonical_agent_benchmark_v1_3/test_adaptive.py b/experiments/prime_canonical_agent_benchmark_v1_3/test_adaptive.py new file mode 100644 index 0000000..c469c75 --- /dev/null +++ b/experiments/prime_canonical_agent_benchmark_v1_3/test_adaptive.py @@ -0,0 +1,654 @@ +"""Invariant and adversarial tests for PRIME benchmark v1.3.""" + +from copy import deepcopy +import unittest + +from experiments.prime_canonical_agent_benchmark_v1_2.receipts import ( + ReceiptChain, + verify_receipt_chain, +) + +from .adaptive_runner import ( + _promote_policy, + run_adaptive_condition, +) +from .factor_verifier import ( + CARRIER_COST, + COORDINATE_COST, + FactorizedVerifierEpoch, + WitnessEvidence, + active_witness_lags, + required_depth_for_lag, +) + + +class WitnessMathTests( + unittest.TestCase +): + def test_mapping(self): + self.assertEqual( + required_depth_for_lag(1), + 1, + ) + self.assertEqual( + required_depth_for_lag(2), + 2, + ) + self.assertEqual( + required_depth_for_lag(3), + 4, + ) + self.assertEqual( + required_depth_for_lag(4), + 4, + ) + + def test_active_stream_count(self): + self.assertEqual( + active_witness_lags(0), + (1, 2, 3, 4), + ) + self.assertEqual( + active_witness_lags(1), + (2, 3, 4), + ) + self.assertEqual( + active_witness_lags(2), + (3, 4), + ) + self.assertEqual( + active_witness_lags(4), + (), + ) + + self.assertEqual( + 4 + 3 + 2, + 9, + ) + + def test_anytime_threshold_boundary(self): + evidence = WitnessEvidence( + lag=1, + wins=15, + losses=0, + ) + + self.assertFalse( + evidence.statistical_pass + ) + + evidence.wins = 16 + + self.assertTrue( + evidence.statistical_pass + ) + + def test_carrier_h4_cost_is_30(self): + evidence = WitnessEvidence( + lag=4 + ) + + self.assertEqual( + evidence.complexity_cost( + 0, + CARRIER_COST, + ), + 30, + ) + + def test_coordinate_h4_cost_is_4(self): + evidence = WitnessEvidence( + lag=4 + ) + + self.assertEqual( + evidence.complexity_cost( + 0, + COORDINATE_COST, + ), + 4, + ) + + def test_factorized_state_is_not_h4_carrier(self): + verifier = ( + FactorizedVerifierEpoch( + current_depth=0, + complexity_rule=( + COORDINATE_COST + ), + ) + ) + + frozen = ( + verifier.freeze_prediction( + 1, + (1,), + ) + ) + + # H0 + one witness coordinate. + self.assertEqual( + len( + frozen.witness_states[ + 4 + ] + ), + 2, + ) + + # Policy remains H0. + self.assertEqual( + len( + frozen.current_state + ), + 1, + ) + + def test_selection_prefers_smallest_policy_depth(self): + verifier = ( + FactorizedVerifierEpoch( + current_depth=0, + complexity_rule=( + COORDINATE_COST + ), + ) + ) + + # Artificial evidence only for + # selection-rule invariant. + verifier.evidence[2].wins = 20 + verifier.evidence[4].wins = 20 + + self.assertEqual( + verifier.selected_supported_lag(), + 2, + ) + + def test_equal_depth_prefers_smaller_lag(self): + verifier = ( + FactorizedVerifierEpoch( + current_depth=0, + complexity_rule=( + COORDINATE_COST + ), + ) + ) + + verifier.evidence[3].wins = 20 + verifier.evidence[4].wins = 20 + + self.assertEqual( + verifier.selected_supported_lag(), + 3, + ) + + + def test_same_evidence_separates_cost_ablations(self): + evidence = WitnessEvidence( + lag=4, + wins=16, + losses=0, + ) + + self.assertTrue( + evidence.statistical_pass + ) + + self.assertTrue( + evidence.supported( + 0, + COORDINATE_COST, + ) + ) + + self.assertFalse( + evidence.supported( + 0, + CARRIER_COST, + ) + ) + + def test_mid_episode_h0_to_h4_does_not_copy_private_history(self): + # Build a verifier with deep private history while the + # authorized policy remains H0. + old_verifier = FactorizedVerifierEpoch( + current_depth=0, + complexity_rule=COORDINATE_COST, + ) + + policy_state = None + + for observation in ( + 1, + 0, + 1, + 1, + 1, + ): + policy_state = ( + observation, + ) + + old_verifier.freeze_prediction( + observation, + policy_state, + ) + + self.assertEqual( + policy_state, + (1,), + ) + + # Direct H0 -> H4 authorization. + new_policy = _promote_policy( + policy_state, + 4, + ) + + new_verifier = FactorizedVerifierEpoch( + current_depth=4, + complexity_rule=COORDINATE_COST, + ) + + # Critically, seed from authorized H0 state only. + new_verifier.seed_mid_episode( + policy_state + ) + + next_observation = 0 + + next_policy_state = ( + new_policy.observe( + next_observation + ) + ) + + frozen = ( + new_verifier.freeze_prediction( + next_observation, + next_policy_state, + ) + ) + + # Policy and verifier agree after the jump. + self.assertEqual( + frozen.current_state, + next_policy_state, + ) + + # If private pre-authorization history had leaked into + # the new policy, this state would differ. + leaked_h4_state = ( + 0, + 1, + 1, + 1, + 0, + ) + + self.assertNotEqual( + next_policy_state, + leaked_h4_state, + ) + + +class ReceiptTamperTests( + unittest.TestCase +): + def _chain(self): + chain = ReceiptChain() + + payload = { + "benchmark_version": ( + "prime-canonical-agent-benchmark-v1.3" + ), + "condition": ( + "FULL-PRIME-V1.3" + ), + "world_seed": 300, + "canonical_depth_before": 0, + "candidate_witness_lags": [ + 1, + 2, + 3, + 4, + ], + "witness_to_policy_depth": { + "1": 1, + "2": 2, + "3": 4, + "4": 4, + }, + "witness_evidence": [ + { + "witness_lag": 4, + "required_policy_depth": 4, + "wins": 20, + "losses": 0, + "complexity_rule": ( + COORDINATE_COST + ), + "complexity_cost": 4, + } + ], + "supported_witness_lags": [ + 4 + ], + "selected_witness_lag": 4, + "selected_required_depth": 4, + "authorized_depth": 4, + } + + chain.append(payload) + chain.append( + { + **payload, + "canonical_depth_before": 4, + "candidate_witness_lags": [], + "supported_witness_lags": [], + "selected_witness_lag": None, + "selected_required_depth": None, + "authorized_depth": None, + } + ) + + return ( + chain.records, + chain.count, + chain.tip, + ) + + def _assert_tampered( + self, + mutation, + ): + records, count, tip = ( + self._chain() + ) + + self.assertTrue( + verify_receipt_chain( + records, + expected_count=count, + expected_tip=tip, + ) + ) + + damaged = deepcopy( + records + ) + + mutation(damaged) + + self.assertFalse( + verify_receipt_chain( + damaged, + expected_count=count, + expected_tip=tip, + ) + ) + + def test_witness_lag(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "witness_evidence" + ][0].__setitem__( + "witness_lag", + 3, + ) + ) + + def test_witness_w(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "witness_evidence" + ][0].__setitem__( + "wins", + 999, + ) + ) + + def test_witness_l(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "witness_evidence" + ][0].__setitem__( + "losses", + 999, + ) + ) + + def test_mapped_depth(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "witness_to_policy_depth" + ].__setitem__( + "4", + 2, + ) + ) + + def test_complexity_rule(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "witness_evidence" + ][0].__setitem__( + "complexity_rule", + CARRIER_COST, + ) + ) + + def test_complexity_cost(self): + self._assert_tampered( + lambda r: r[0]["payload"][ + "witness_evidence" + ][0].__setitem__( + "complexity_cost", + 30, + ) + ) + + def test_authorized_depth(self): + self._assert_tampered( + lambda r: r[0]["payload"].__setitem__( + "authorized_depth", + 2, + ) + ) + + def test_world_seed(self): + self._assert_tampered( + lambda r: r[0]["payload"].__setitem__( + "world_seed", + 999, + ) + ) + + def test_previous_hash(self): + self._assert_tampered( + lambda r: r[1]["payload"].__setitem__( + "previous_receipt_hash", + "f" * 64, + ) + ) + + def test_deletion(self): + self._assert_tampered( + lambda r: r.pop() + ) + + def test_insertion(self): + self._assert_tampered( + lambda r: r.insert( + 1, + deepcopy(r[0]), + ) + ) + + def test_reordering(self): + def mutate(records): + records[0], records[1] = ( + records[1], + records[0], + ) + + self._assert_tampered( + mutate + ) + + +class RunnerTests( + unittest.TestCase +): + def test_v1_3_evaluation_seed_blocked(self): + with self.assertRaises( + RuntimeError + ): + run_adaptive_condition( + 3000, + "FULL-PRIME-V1.3", + ) + + def test_nondevelopment_seed_blocked(self): + with self.assertRaises( + RuntimeError + ): + run_adaptive_condition( + 2999, + "FULL-PRIME-V1.3", + ) + + def test_full_v13_byte_reproducible(self): + first = ( + run_adaptive_condition( + 301, + "FULL-PRIME-V1.3", + ) + ) + + second = ( + run_adaptive_condition( + 301, + "FULL-PRIME-V1.3", + ) + ) + + self.assertEqual( + first.canonical_bytes(), + second.canonical_bytes(), + ) + + self.assertEqual( + first.sha256(), + second.sha256(), + ) + + def test_v12_reference_byte_reproducible(self): + first = ( + run_adaptive_condition( + 302, + "FULL-PRIME-V1.2-REFERENCE", + ) + ) + + second = ( + run_adaptive_condition( + 302, + "FULL-PRIME-V1.2-REFERENCE", + ) + ) + + self.assertEqual( + first.canonical_bytes(), + second.canonical_bytes(), + ) + + def test_factor_carrier_byte_reproducible(self): + first = ( + run_adaptive_condition( + 303, + "FACTOR-WITNESS-CARRIER-COST", + ) + ) + + second = ( + run_adaptive_condition( + 303, + "FACTOR-WITNESS-CARRIER-COST", + ) + ) + + self.assertEqual( + first.canonical_bytes(), + second.canonical_bytes(), + ) + + def test_receipts_verify(self): + result = ( + run_adaptive_condition( + 304, + "FULL-PRIME-V1.3", + ).payload + ) + + self.assertTrue( + verify_receipt_chain( + result[ + "repair_receipts" + ], + expected_count=( + result[ + "canonical_receipt_count" + ] + ), + expected_tip=( + result[ + "repair_receipt_chain_tip" + ] + ), + ) + ) + + def test_no_native_floats_all_conditions(self): + def walk(value): + self.assertNotIsInstance( + value, + float, + ) + + if isinstance( + value, + dict, + ): + for key, item in value.items(): + self.assertIsInstance( + key, + str, + ) + walk(item) + + elif isinstance( + value, + list, + ): + for item in value: + walk(item) + + for condition in ( + "ADAPTIVE-NO-VERIFIER", + "FULL-PRIME-V1.2-REFERENCE", + "FACTOR-WITNESS-CARRIER-COST", + "FULL-PRIME-V1.3", + ): + result = ( + run_adaptive_condition( + 305, + condition, + ).payload + ) + + walk(result) + + +if __name__ == "__main__": + unittest.main() diff --git a/experiments/prime_m20_universal_arena/CONTRACT.md b/experiments/prime_m20_universal_arena/CONTRACT.md new file mode 100644 index 0000000..f93e9d2 --- /dev/null +++ b/experiments/prime_m20_universal_arena/CONTRACT.md @@ -0,0 +1,95 @@ +# PRIME M20 Universal Adaptive-State Arena + +Status: + + FROZEN BEFORE DEVELOPMENT RESULTS + +Purpose: + +Test whether PRIME M20 can discover compact predictive constructions across +multiple dependency families rather than merely selecting raw memory depth. + +Development stream seeds: + + 600 through 607 inclusive + +Held-out stream seeds: + + 6000 through 6031 inclusive + +HELD-OUT SEEDS MUST NOT BE RUN DURING DEVELOPMENT. + +Scored steps per world: + + 1536 + +Candidate field: + + max raw lag: + 8 + + maximum simultaneous candidates: + 256 + + non-authoritative depth-2 scaffolds: + enabled + +Conditions: + + REACTIVE + + FIXED-H8 + + ORACLE-FEATURE + + M20-CONSTRUCTION + +Task families: + + CURRENT + + LAG-1 + LAG-4 + LAG-7 + + XOR-1-4 + XOR-2-7 + + EQ-1-4 + + AND-1-4 + + OR-2-7 + + XOR-1-2-3 + AND-1-2-4 + OR-2-3-4 + +CURRENT requires no extra constructed representation. + +Three-way tasks require proposal scaffolding. + +Primary development metrics: + + AULC ppm + + final-window accuracy ppm + + cumulative mistakes + +M20 structural diagnostics: + + number of authorized constructions + + exact target construction present in active canonical representation + + false construction in CURRENT task + + authorization event + + receipt-chain integrity + +No inferential claim may be made from development seeds. + +The held-out analysis plan must be frozen separately before seeds 6000..6031 +are ever run. diff --git a/experiments/prime_m20_universal_arena/CONTRACT.sha256 b/experiments/prime_m20_universal_arena/CONTRACT.sha256 new file mode 100644 index 0000000..faceb16 --- /dev/null +++ b/experiments/prime_m20_universal_arena/CONTRACT.sha256 @@ -0,0 +1 @@ +7ec7dd2e91bec3dd6354f89757b21095a37fce29a866bf4be034d18da664cd35 experiments/prime_m20_universal_arena/CONTRACT.md diff --git a/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.json b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.json new file mode 100644 index 0000000..4d7e3ac --- /dev/null +++ b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.json @@ -0,0 +1,7459 @@ +{ + "benchmark": "prime-m20-universal-adaptive-state-arena", + "by_task": [ + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 79, + "mean_final_window_accuracy_ppm": 954101, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 944531, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 294, + "mean_final_window_accuracy_ppm": 919921, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 699412, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 73, + "mean_final_window_accuracy_ppm": 957519, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 949380, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 75, + "mean_final_window_accuracy_ppm": 953612, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 944685, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 757, + "mean_final_window_accuracy_ppm": 497558, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 509847, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 289, + "mean_final_window_accuracy_ppm": 916991, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 707361, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 76, + "mean_final_window_accuracy_ppm": 950683, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 943833, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 101, + "mean_final_window_accuracy_ppm": 953124, + "mean_first_authorization_event": 53, + "mean_primary_aulc_ppm": 878058, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 759, + "mean_final_window_accuracy_ppm": 500488, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 509110, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 292, + "mean_final_window_accuracy_ppm": 925780, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 706847, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 73, + "mean_final_window_accuracy_ppm": 954101, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 944863, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 103, + "mean_final_window_accuracy_ppm": 950195, + "mean_first_authorization_event": 55, + "mean_primary_aulc_ppm": 877203, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 746, + "mean_final_window_accuracy_ppm": 509765, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 522640, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 297, + "mean_final_window_accuracy_ppm": 916503, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 712278, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 76, + "mean_final_window_accuracy_ppm": 951171, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 946180, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 103, + "mean_final_window_accuracy_ppm": 953124, + "mean_first_authorization_event": 58, + "mean_primary_aulc_ppm": 878640, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 770, + "mean_final_window_accuracy_ppm": 504882, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 506623, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 293, + "mean_final_window_accuracy_ppm": 922851, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 698637, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 74, + "mean_final_window_accuracy_ppm": 955077, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 945643, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 105, + "mean_final_window_accuracy_ppm": 958007, + "mean_first_authorization_event": 53, + "mean_primary_aulc_ppm": 869755, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 773, + "mean_final_window_accuracy_ppm": 504882, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 496473, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 293, + "mean_final_window_accuracy_ppm": 921874, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 700226, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 72, + "mean_final_window_accuracy_ppm": 957519, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 946375, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 0, + "mean_cumulative_mistakes": 105, + "mean_final_window_accuracy_ppm": 954589, + "mean_first_authorization_event": 48, + "mean_primary_aulc_ppm": 869214, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 770, + "mean_final_window_accuracy_ppm": 499511, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 506744, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 292, + "mean_final_window_accuracy_ppm": 924316, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 700391, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 74, + "mean_final_window_accuracy_ppm": 954101, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 942862, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 0, + "mean_cumulative_mistakes": 102, + "mean_final_window_accuracy_ppm": 948730, + "mean_first_authorization_event": 51, + "mean_primary_aulc_ppm": 875593, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 409, + "mean_final_window_accuracy_ppm": 727538, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 736437, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 181, + "mean_final_window_accuracy_ppm": 936522, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 834005, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 74, + "mean_final_window_accuracy_ppm": 954101, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 946637, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 102, + "mean_final_window_accuracy_ppm": 950683, + "mean_first_authorization_event": 114, + "mean_primary_aulc_ppm": 892315, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 439, + "mean_final_window_accuracy_ppm": 730468, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 699083, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 403, + "mean_final_window_accuracy_ppm": 909667, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 581130, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 75, + "mean_final_window_accuracy_ppm": 951659, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 944538, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 99, + "mean_final_window_accuracy_ppm": 952636, + "mean_first_authorization_event": 85, + "mean_primary_aulc_ppm": 886694, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 771, + "mean_final_window_accuracy_ppm": 498534, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 502614, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 292, + "mean_final_window_accuracy_ppm": 922851, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 700558, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 77, + "mean_final_window_accuracy_ppm": 958007, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 942494, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 101, + "mean_final_window_accuracy_ppm": 952148, + "mean_first_authorization_event": 49, + "mean_primary_aulc_ppm": 881217, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 240, + "mean_final_window_accuracy_ppm": 840331, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 846238, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 130, + "mean_final_window_accuracy_ppm": 948730, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 892309, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 72, + "mean_final_window_accuracy_ppm": 954101, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 951231, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 102, + "mean_final_window_accuracy_ppm": 955077, + "mean_first_authorization_event": 227, + "mean_primary_aulc_ppm": 903558, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 268, + "mean_final_window_accuracy_ppm": 842284, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 811302, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 455, + "mean_final_window_accuracy_ppm": 905273, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 517382, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_target_recovery": null, + "mean_cumulative_mistakes": 75, + "mean_final_window_accuracy_ppm": 950683, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 940956, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_target_recovery": 8, + "mean_cumulative_mistakes": 101, + "mean_final_window_accuracy_ppm": 948730, + "mean_first_authorization_event": 148, + "mean_primary_aulc_ppm": 891238, + "task": "OR-2-3-4", + "world_count": 8 + } + ], + "condition_count": 4, + "condition_summaries": { + "FIXED-H8": { + "mean_cumulative_mistakes": 293, + "mean_final_window_accuracy_ppm": 922607, + "mean_primary_aulc_ppm": 704211, + "world_count": 96 + }, + "M20-CONSTRUCTION": { + "mean_cumulative_mistakes": 100, + "mean_final_window_accuracy_ppm": 952555, + "mean_primary_aulc_ppm": 887347, + "world_count": 96 + }, + "ORACLE-FEATURE": { + "mean_cumulative_mistakes": 74, + "mean_final_window_accuracy_ppm": 954060, + "mean_primary_aulc_ppm": 945416, + "world_count": 96 + }, + "REACTIVE": { + "mean_cumulative_mistakes": 565, + "mean_final_window_accuracy_ppm": 634195, + "mean_primary_aulc_ppm": 632637, + "world_count": 96 + } + }, + "development_seeds": [ + 600, + 601, + 602, + 603, + 604, + 605, + 606, + 607 + ], + "evaluation_seeds_run": false, + "m20_exact_target_recovery": 80, + "m20_receipts_all_valid": true, + "m20_world_count": 96, + "row_count": 384, + "rows": [ + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 937108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 914062, + "primary_aulc_ppm": 712612, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 949421, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 75, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 955754, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 949969, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 703710, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 65, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 956656, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 70, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 941274, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 944957, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 684341, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 947229, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 71, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 946081, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 951665, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 696009, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 943550, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 78, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 953088, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 940377, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 692784, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 57, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 971977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 77, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 939486, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 956905, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 882812, + "primary_aulc_ppm": 704880, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 937361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 929445, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 935311, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 701674, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 935640, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 61, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 956017, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 939962, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 890625, + "primary_aulc_ppm": 699288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 976562, + "primary_aulc_ppm": 953209, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 81, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 936339, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "CURRENT" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 741, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 503906, + "primary_aulc_ppm": 526629, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 921875, + "primary_aulc_ppm": 720208, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 947635, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-1" + }, + { + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 881316, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 744, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 503906, + "primary_aulc_ppm": 527943, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 711242, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 956682, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-1" + }, + { + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 883646, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 492187, + "primary_aulc_ppm": 515015, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 914062, + "primary_aulc_ppm": 687612, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 950406, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-1" + }, + { + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 888841, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 742, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 500000, + "primary_aulc_ppm": 508948, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 701931, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 930435, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-1" + }, + { + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 880035, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 554687, + "primary_aulc_ppm": 507286, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 273, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 716470, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 938343, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-1" + }, + { + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 874101, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 488281, + "primary_aulc_ppm": 486503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 906250, + "primary_aulc_ppm": 711487, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 946211, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-1" + }, + { + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 860714, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 794, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 476562, + "primary_aulc_ppm": 480592, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 711718, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 933964, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-1" + }, + { + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 876155, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 460937, + "primary_aulc_ppm": 525863, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 921875, + "primary_aulc_ppm": 698225, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 946993, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-1" + }, + { + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 879660, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-1" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 738, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 488281, + "primary_aulc_ppm": 545529, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 735849, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 954626, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-4" + }, + { + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 972656, + "primary_aulc_ppm": 886871, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 769, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 496093, + "primary_aulc_ppm": 492531, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 702675, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 958860, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-4" + }, + { + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 874051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 468750, + "primary_aulc_ppm": 515018, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 902343, + "primary_aulc_ppm": 700090, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 939506, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-4" + }, + { + "authorization_events": [ + 69 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 877218, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 484375, + "primary_aulc_ppm": 493679, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 696034, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 935599, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-4" + }, + { + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 873446, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 535156, + "primary_aulc_ppm": 508451, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 710343, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 936084, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-4" + }, + { + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 876743, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 492187, + "primary_aulc_ppm": 499950, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 715695, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 931634, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-4" + }, + { + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 875321, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 765, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 535156, + "primary_aulc_ppm": 518314, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 698330, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 948947, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-4" + }, + { + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 883747, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 503906, + "primary_aulc_ppm": 499414, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 894531, + "primary_aulc_ppm": 695766, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 953648, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-4" + }, + { + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 870230, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 728, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 484375, + "primary_aulc_ppm": 555555, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 729293, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 952000, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-7" + }, + { + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 873162, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 725, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 527343, + "primary_aulc_ppm": 526096, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 311, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 906250, + "primary_aulc_ppm": 722071, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 952690, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-7" + }, + { + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 976562, + "primary_aulc_ppm": 877111, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 763, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 503906, + "primary_aulc_ppm": 511851, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 902343, + "primary_aulc_ppm": 699257, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 934188, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-7" + }, + { + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 882128, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 480468, + "primary_aulc_ppm": 514750, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 700832, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 936446, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-7" + }, + { + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 882819, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 729, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 546875, + "primary_aulc_ppm": 526734, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 716488, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 948361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-7" + }, + { + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 885847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 751, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 515625, + "primary_aulc_ppm": 526912, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 894531, + "primary_aulc_ppm": 715382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 946606, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-7" + }, + { + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 863198, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 488281, + "primary_aulc_ppm": 504017, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 700558, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 945577, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-7" + }, + { + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 879698, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 737, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 531250, + "primary_aulc_ppm": 515212, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 714345, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 953575, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-7" + }, + { + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 885158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "LAG-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 728, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 531250, + "primary_aulc_ppm": 527917, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 707260, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 955574, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 881202, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 488281, + "primary_aulc_ppm": 510122, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 906250, + "primary_aulc_ppm": 706069, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 61, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 958040, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 859799, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 468750, + "primary_aulc_ppm": 512020, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 688173, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 951331, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 868493, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 748, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 523437, + "primary_aulc_ppm": 514350, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 685591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 937795, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 869616, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 794, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 496093, + "primary_aulc_ppm": 511564, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 689459, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 945505, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 972656, + "primary_aulc_ppm": 870398, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 786, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 542968, + "primary_aulc_ppm": 497353, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 878906, + "primary_aulc_ppm": 711765, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 95, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 927729, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 870006, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 503906, + "primary_aulc_ppm": 477066, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 692329, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 938246, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 871760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 484375, + "primary_aulc_ppm": 502594, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 279, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 708454, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 950924, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-4" + }, + { + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 866770, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 453125, + "primary_aulc_ppm": 518140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 712527, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 954920, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 870327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 776, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 527343, + "primary_aulc_ppm": 488356, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 693108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 950173, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 40 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 980468, + "primary_aulc_ppm": 857275, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 730, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 566406, + "primary_aulc_ppm": 523521, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 902343, + "primary_aulc_ppm": 691416, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 950823, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 886737, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 500000, + "primary_aulc_ppm": 488506, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 284, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 708999, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 941805, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 39 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 859123, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 779, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 480468, + "primary_aulc_ppm": 486798, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 690351, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 62, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 942663, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 867221, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 511718, + "primary_aulc_ppm": 498394, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 902343, + "primary_aulc_ppm": 704438, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 948534, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 39 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 872273, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 484375, + "primary_aulc_ppm": 489632, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 695774, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 932878, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 37 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 874803, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 797, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 515625, + "primary_aulc_ppm": 478440, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 906250, + "primary_aulc_ppm": 705197, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 949204, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-2-7" + }, + { + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 865954, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 737, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 535156, + "primary_aulc_ppm": 521890, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 921875, + "primary_aulc_ppm": 707086, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 944187, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 41 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 866753, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 511718, + "primary_aulc_ppm": 487798, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 700913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 947665, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 877928, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 464843, + "primary_aulc_ppm": 513411, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 708348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 939757, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 884721, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 488281, + "primary_aulc_ppm": 517922, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 921875, + "primary_aulc_ppm": 698911, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 933184, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 881280, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 476562, + "primary_aulc_ppm": 524646, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 276, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 708461, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 51, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 953030, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 880134, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 808, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 527343, + "primary_aulc_ppm": 489187, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 697449, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 947355, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 861268, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 515625, + "primary_aulc_ppm": 492409, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 698655, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 934821, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 881909, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 768, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 476562, + "primary_aulc_ppm": 506694, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 886718, + "primary_aulc_ppm": 683311, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 942903, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "EQ-1-4" + }, + { + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": false, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 870751, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "EQ-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 419, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 699218, + "primary_aulc_ppm": 755343, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 185, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 847569, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 953409, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 156 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 902073, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 388, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 742187, + "primary_aulc_ppm": 745450, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 201, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 824155, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 957913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 128 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 86, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 902783, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 444, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 664062, + "primary_aulc_ppm": 712032, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 183, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 921875, + "primary_aulc_ppm": 828550, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 943885, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 106 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 902369, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 397, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 695312, + "primary_aulc_ppm": 735478, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 178, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 832602, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 934864, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 81 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 892783, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 383, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 769531, + "primary_aulc_ppm": 750455, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 170, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 845781, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 941264, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 144 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 889514, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 441, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 746093, + "primary_aulc_ppm": 708405, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 175, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 838902, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 952519, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 861457, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 405, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 789062, + "primary_aulc_ppm": 737333, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 175, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 833647, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 942279, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 102 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 891891, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 398, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 714843, + "primary_aulc_ppm": 747003, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 187, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 914062, + "primary_aulc_ppm": 820835, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 946967, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-4" + }, + { + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 895651, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 470, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 726562, + "primary_aulc_ppm": 656473, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 405, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 921875, + "primary_aulc_ppm": 603421, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 950416, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 877802, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 484, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 687500, + "primary_aulc_ppm": 682836, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 414, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 894531, + "primary_aulc_ppm": 593909, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 953428, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 92 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 984375, + "primary_aulc_ppm": 881520, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 393, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 812500, + "primary_aulc_ppm": 727288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 413, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 894531, + "primary_aulc_ppm": 567244, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 939836, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 896560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 440, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 769531, + "primary_aulc_ppm": 710881, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 406, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 914062, + "primary_aulc_ppm": 567097, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 939281, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 101 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 884328, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 453, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 703125, + "primary_aulc_ppm": 690376, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 391, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 580322, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 62, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 942288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 883063, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 402, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 726562, + "primary_aulc_ppm": 707854, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 410, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 875000, + "primary_aulc_ppm": 581854, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 937463, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 78 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 886953, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 423, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 687500, + "primary_aulc_ppm": 707943, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 397, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 571603, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 939121, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 102 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 896731, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 450, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 730468, + "primary_aulc_ppm": 709014, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 392, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 583591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 954472, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-7" + }, + { + "authorization_events": [ + 90 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 886602, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-7" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 531250, + "primary_aulc_ppm": 514108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 714862, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 942531, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 877017, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 757, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 496093, + "primary_aulc_ppm": 528658, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 702776, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 954667, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 876352, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 511718, + "primary_aulc_ppm": 502280, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 906250, + "primary_aulc_ppm": 706962, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 949041, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 867597, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 743, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 527343, + "primary_aulc_ppm": 509191, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 311, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 929687, + "primary_aulc_ppm": 681759, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 930777, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 882899, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 803, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 480468, + "primary_aulc_ppm": 473382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 284, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 699368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 940387, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 83, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 898540, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 781, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 472656, + "primary_aulc_ppm": 507370, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 882812, + "primary_aulc_ppm": 696789, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 946746, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 877510, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 449218, + "primary_aulc_ppm": 513233, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 279, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 698817, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 936837, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 890192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 519531, + "primary_aulc_ppm": 472695, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 284, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 917968, + "primary_aulc_ppm": 703134, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 938969, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 879629, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "XOR-1-2-3" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 253, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 816406, + "primary_aulc_ppm": 861021, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 137, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 900601, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 960687, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 398 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 968750, + "primary_aulc_ppm": 908402, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 218, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 863281, + "primary_aulc_ppm": 850643, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 154, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 876653, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 961971, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 189 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 86, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 914068, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 266, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 757812, + "primary_aulc_ppm": 832523, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 132, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 933593, + "primary_aulc_ppm": 892462, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 945946, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 205 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 906296, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 233, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 832031, + "primary_aulc_ppm": 846772, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 130, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 881251, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 938815, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 197 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 907946, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 219, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 859375, + "primary_aulc_ppm": 865061, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 118, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 904135, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 60, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 953936, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 286 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 901776, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 262, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 851562, + "primary_aulc_ppm": 827391, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 122, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 902773, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 951247, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 176 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 881757, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 246, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 878906, + "primary_aulc_ppm": 843568, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 129, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 960937, + "primary_aulc_ppm": 891064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 944675, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 209 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 937500, + "primary_aulc_ppm": 905347, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 230, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 863281, + "primary_aulc_ppm": 842926, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 119, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 889538, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 952577, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-2-4" + }, + { + "authorization_events": [ + 163 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 902879, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "AND-1-2-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 796875, + "primary_aulc_ppm": 784584, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 453, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 910156, + "primary_aulc_ppm": 541315, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 939696, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 92 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 886351, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 847656, + "primary_aulc_ppm": 780203, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 463, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 898437, + "primary_aulc_ppm": 536835, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 954984, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 870650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 245, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 867187, + "primary_aulc_ppm": 828306, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 469, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 902343, + "primary_aulc_ppm": 498572, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 925781, + "primary_aulc_ppm": 941688, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 202 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 957031, + "primary_aulc_ppm": 902032, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 890625, + "primary_aulc_ppm": 798702, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 458, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 906250, + "primary_aulc_ppm": 505336, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 937043, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 888934, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 270, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 820312, + "primary_aulc_ppm": 817019, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 450, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 953125, + "primary_aulc_ppm": 512619, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 937192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 174 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 90, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 899375, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 235, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 847656, + "primary_aulc_ppm": 834369, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 457, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 871093, + "primary_aulc_ppm": 511589, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 928407, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 115 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 889682, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 247, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 828125, + "primary_aulc_ppm": 828954, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 448, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 902343, + "primary_aulc_ppm": 508456, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 964843, + "primary_aulc_ppm": 938251, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 161 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 941406, + "primary_aulc_ppm": 910324, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 266, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 839843, + "primary_aulc_ppm": 818284, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 447, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 898437, + "primary_aulc_ppm": 524339, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-3-4" + }, + { + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "final_window_accuracy_ppm": 949218, + "primary_aulc_ppm": 950391, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-3-4" + }, + { + "authorization_events": [ + 157 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "final_window_accuracy_ppm": 945312, + "primary_aulc_ppm": 882558, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "task": "OR-2-3-4" + } + ], + "status": "DEVELOPMENT_ONLY", + "task_count": 12 +} diff --git a/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.sha256 b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.sha256 new file mode 100644 index 0000000..4a1772d --- /dev/null +++ b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.sha256 @@ -0,0 +1 @@ +d0b7f43daaa24a66acb850e160fee19a4889f44bbfd9b49920f9266499ac3555 experiments/prime_m20_universal_arena/DEVELOPMENT_V0_1_RESULT.json diff --git a/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.json b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.json new file mode 100644 index 0000000..74d33b3 --- /dev/null +++ b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.json @@ -0,0 +1,11423 @@ +{ + "benchmark": "prime-m20-universal-arena-v0.2", + "by_task": [ + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 946661, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 429768, + "mean_final_window_accuracy_ppm": 951171, + "mean_final_window_balanced_accuracy_ppm": 951542, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941685, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 806314, + "mean_balanced_accuracy_ppm": 803273, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 297, + "mean_excess_over_constant_ppm": 289469, + "mean_final_window_accuracy_ppm": 922851, + "mean_final_window_balanced_accuracy_ppm": 923054, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 699167, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 946661, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 429768, + "mean_final_window_accuracy_ppm": 951171, + "mean_final_window_balanced_accuracy_ppm": 951542, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941685, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 946661, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 429768, + "mean_final_window_accuracy_ppm": 951171, + "mean_final_window_balanced_accuracy_ppm": 951542, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941685, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": 8, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 505533, + "mean_balanced_accuracy_ppm": 497652, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 759, + "mean_excess_over_constant_ppm": -11556, + "mean_final_window_accuracy_ppm": 497558, + "mean_final_window_balanced_accuracy_ppm": 490222, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 510462, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 809244, + "mean_balanced_accuracy_ppm": 806214, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 293, + "mean_excess_over_constant_ppm": 292154, + "mean_final_window_accuracy_ppm": 921386, + "mean_final_window_balanced_accuracy_ppm": 921335, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 704924, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 948892, + "mean_balanced_accuracy_ppm": 949076, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 78, + "mean_excess_over_constant_ppm": 431803, + "mean_final_window_accuracy_ppm": 948729, + "mean_final_window_balanced_accuracy_ppm": 948970, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 943621, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 933593, + "mean_balanced_accuracy_ppm": 933668, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 102, + "mean_excess_over_constant_ppm": 416503, + "mean_final_window_accuracy_ppm": 948729, + "mean_final_window_balanced_accuracy_ppm": 948970, + "mean_first_authorization_event": 53, + "mean_primary_aulc_ppm": 881944, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 506103, + "mean_balanced_accuracy_ppm": 496078, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 758, + "mean_excess_over_constant_ppm": -11312, + "mean_final_window_accuracy_ppm": 506835, + "mean_final_window_balanced_accuracy_ppm": 502572, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 512710, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 807128, + "mean_balanced_accuracy_ppm": 803758, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 296, + "mean_excess_over_constant_ppm": 289713, + "mean_final_window_accuracy_ppm": 922362, + "mean_final_window_balanced_accuracy_ppm": 922263, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 706788, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 945719, + "mean_balanced_accuracy_ppm": 945739, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 83, + "mean_excess_over_constant_ppm": 428304, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949264, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 940302, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 929036, + "mean_balanced_accuracy_ppm": 928936, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 109, + "mean_excess_over_constant_ppm": 411621, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949264, + "mean_first_authorization_event": 55, + "mean_primary_aulc_ppm": 876690, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 510497, + "mean_balanced_accuracy_ppm": 498170, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 751, + "mean_excess_over_constant_ppm": -7406, + "mean_final_window_accuracy_ppm": 510741, + "mean_final_window_balanced_accuracy_ppm": 502809, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 519471, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 805744, + "mean_balanced_accuracy_ppm": 802132, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 298, + "mean_excess_over_constant_ppm": 287841, + "mean_final_window_accuracy_ppm": 920898, + "mean_final_window_balanced_accuracy_ppm": 920733, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 706565, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946370, + "mean_balanced_accuracy_ppm": 946508, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 428466, + "mean_final_window_accuracy_ppm": 947265, + "mean_final_window_balanced_accuracy_ppm": 947272, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 939837, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 929035, + "mean_balanced_accuracy_ppm": 928797, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 109, + "mean_excess_over_constant_ppm": 411132, + "mean_final_window_accuracy_ppm": 947265, + "mean_final_window_balanced_accuracy_ppm": 947272, + "mean_first_authorization_event": 58, + "mean_primary_aulc_ppm": 875867, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 499267, + "mean_balanced_accuracy_ppm": 497111, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 769, + "mean_excess_over_constant_ppm": -9196, + "mean_final_window_accuracy_ppm": 503905, + "mean_final_window_balanced_accuracy_ppm": 492075, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 507017, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 806558, + "mean_balanced_accuracy_ppm": 806183, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 297, + "mean_excess_over_constant_ppm": 298095, + "mean_final_window_accuracy_ppm": 920409, + "mean_final_window_balanced_accuracy_ppm": 920105, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 702827, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 948079, + "mean_balanced_accuracy_ppm": 948210, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 79, + "mean_excess_over_constant_ppm": 439615, + "mean_final_window_accuracy_ppm": 948241, + "mean_final_window_balanced_accuracy_ppm": 948178, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 943604, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 931233, + "mean_balanced_accuracy_ppm": 931294, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 105, + "mean_excess_over_constant_ppm": 422770, + "mean_final_window_accuracy_ppm": 948241, + "mean_final_window_balanced_accuracy_ppm": 948178, + "mean_first_authorization_event": 53, + "mean_primary_aulc_ppm": 877151, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 499185, + "mean_balanced_accuracy_ppm": 493070, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 769, + "mean_excess_over_constant_ppm": -13266, + "mean_final_window_accuracy_ppm": 495605, + "mean_final_window_balanced_accuracy_ppm": 487190, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 499139, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 807209, + "mean_balanced_accuracy_ppm": 807633, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 296, + "mean_excess_over_constant_ppm": 294759, + "mean_final_window_accuracy_ppm": 917480, + "mean_final_window_balanced_accuracy_ppm": 917793, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 701773, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 948241, + "mean_balanced_accuracy_ppm": 948282, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 79, + "mean_excess_over_constant_ppm": 435790, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 945481, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 942910, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 0, + "mean_accuracy_ppm": 930989, + "mean_balanced_accuracy_ppm": 930985, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 106, + "mean_excess_over_constant_ppm": 418538, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 945481, + "mean_first_authorization_event": 48, + "mean_primary_aulc_ppm": 874149, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": { + "complement": 8 + }, + "predictive_partition_recovery": 8, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 495116, + "mean_balanced_accuracy_ppm": 492744, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 775, + "mean_excess_over_constant_ppm": -13347, + "mean_final_window_accuracy_ppm": 499511, + "mean_final_window_balanced_accuracy_ppm": 487029, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 496442, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 806233, + "mean_balanced_accuracy_ppm": 806538, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 297, + "mean_excess_over_constant_ppm": 297770, + "mean_final_window_accuracy_ppm": 920409, + "mean_final_window_balanced_accuracy_ppm": 919905, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 694507, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 945718, + "mean_balanced_accuracy_ppm": 945704, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 83, + "mean_excess_over_constant_ppm": 437255, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 946522, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 936335, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 0, + "mean_accuracy_ppm": 929442, + "mean_balanced_accuracy_ppm": 929366, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 108, + "mean_excess_over_constant_ppm": 420979, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 946522, + "mean_first_authorization_event": 51, + "mean_primary_aulc_ppm": 870703, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": { + "complement": 8 + }, + "predictive_partition_recovery": 8, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 732014, + "mean_balanced_accuracy_ppm": 498638, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 411, + "mean_excess_over_constant_ppm": -28565, + "mean_final_window_accuracy_ppm": 725585, + "mean_final_window_balanced_accuracy_ppm": 499347, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 732670, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 878417, + "mean_balanced_accuracy_ppm": 804278, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 186, + "mean_excess_over_constant_ppm": 117838, + "mean_final_window_accuracy_ppm": 933593, + "mean_final_window_balanced_accuracy_ppm": 923583, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 827617, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946451, + "mean_balanced_accuracy_ppm": 946597, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 185872, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 950755, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941662, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 930419, + "mean_balanced_accuracy_ppm": 913256, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 106, + "mean_excess_over_constant_ppm": 169840, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 950755, + "mean_first_authorization_event": 114, + "mean_primary_aulc_ppm": 889698, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 714273, + "mean_balanced_accuracy_ppm": 504531, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 438, + "mean_excess_over_constant_ppm": -24577, + "mean_final_window_accuracy_ppm": 725097, + "mean_final_window_balanced_accuracy_ppm": 500378, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 701505, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 735513, + "mean_balanced_accuracy_ppm": 803363, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 406, + "mean_excess_over_constant_ppm": -3337, + "mean_final_window_accuracy_ppm": 906737, + "mean_final_window_balanced_accuracy_ppm": 916522, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 580732, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 947509, + "mean_balanced_accuracy_ppm": 946880, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 80, + "mean_excess_over_constant_ppm": 208658, + "mean_final_window_accuracy_ppm": 947753, + "mean_final_window_balanced_accuracy_ppm": 943800, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 940218, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 931640, + "mean_balanced_accuracy_ppm": 922763, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 105, + "mean_excess_over_constant_ppm": 192789, + "mean_final_window_accuracy_ppm": 947753, + "mean_final_window_balanced_accuracy_ppm": 943800, + "mean_first_authorization_event": 85, + "mean_primary_aulc_ppm": 881905, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 496337, + "mean_balanced_accuracy_ppm": 492576, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 773, + "mean_excess_over_constant_ppm": -10743, + "mean_final_window_accuracy_ppm": 496581, + "mean_final_window_balanced_accuracy_ppm": 494548, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 498970, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 805012, + "mean_balanced_accuracy_ppm": 804280, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 299, + "mean_excess_over_constant_ppm": 297932, + "mean_final_window_accuracy_ppm": 922362, + "mean_final_window_balanced_accuracy_ppm": 922193, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 694062, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 945393, + "mean_balanced_accuracy_ppm": 945428, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 83, + "mean_excess_over_constant_ppm": 438313, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949345, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 936447, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 930582, + "mean_balanced_accuracy_ppm": 930633, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 106, + "mean_excess_over_constant_ppm": 423502, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949345, + "mean_first_authorization_event": 49, + "mean_primary_aulc_ppm": 876362, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 842040, + "mean_balanced_accuracy_ppm": 501778, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 242, + "mean_excess_over_constant_ppm": -39633, + "mean_final_window_accuracy_ppm": 838378, + "mean_final_window_balanced_accuracy_ppm": 502986, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 841452, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 913329, + "mean_balanced_accuracy_ppm": 802100, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 133, + "mean_excess_over_constant_ppm": 31656, + "mean_final_window_accuracy_ppm": 940917, + "mean_final_window_balanced_accuracy_ppm": 930296, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 888566, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 947102, + "mean_balanced_accuracy_ppm": 945823, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 81, + "mean_excess_over_constant_ppm": 65429, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 949224, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 942381, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 930663, + "mean_balanced_accuracy_ppm": 877501, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 106, + "mean_excess_over_constant_ppm": 48990, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 949224, + "mean_first_authorization_event": 227, + "mean_primary_aulc_ppm": 900470, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 822427, + "mean_balanced_accuracy_ppm": 504908, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 272, + "mean_excess_over_constant_ppm": -38575, + "mean_final_window_accuracy_ppm": 837890, + "mean_final_window_balanced_accuracy_ppm": 507870, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 810665, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 700438, + "mean_balanced_accuracy_ppm": 802181, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 460, + "mean_excess_over_constant_ppm": -160564, + "mean_final_window_accuracy_ppm": 901367, + "mean_final_window_balanced_accuracy_ppm": 913274, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 518902, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 945150, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 85611, + "mean_final_window_accuracy_ppm": 950683, + "mean_final_window_balanced_accuracy_ppm": 941583, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 939346, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 930093, + "mean_balanced_accuracy_ppm": 897310, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 107, + "mean_excess_over_constant_ppm": 69091, + "mean_final_window_accuracy_ppm": 950683, + "mean_final_window_balanced_accuracy_ppm": 941583, + "mean_first_authorization_event": 148, + "mean_primary_aulc_ppm": 887743, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "OR-2-3-4", + "world_count": 8 + } + ], + "condition_count": 4, + "condition_summaries": { + "FIXED-H8": { + "mean_accuracy_ppm": 806762, + "mean_balanced_accuracy_ppm": 804328, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 296, + "mean_excess_over_constant_ppm": 194444, + "mean_final_window_accuracy_ppm": 920898, + "mean_final_window_balanced_accuracy_ppm": 920921, + "mean_primary_aulc_ppm": 702202, + "world_count": 96 + }, + "M20-CONSTRUCTION": { + "mean_accuracy_ppm": 931945, + "mean_balanced_accuracy_ppm": 922598, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 104, + "mean_excess_over_constant_ppm": 319627, + "mean_final_window_accuracy_ppm": 948119, + "mean_final_window_balanced_accuracy_ppm": 947661, + "mean_primary_aulc_ppm": 886197, + "world_count": 96 + }, + "ORACLE-FEATURE": { + "mean_accuracy_ppm": 946892, + "mean_balanced_accuracy_ppm": 946671, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 81, + "mean_excess_over_constant_ppm": 334574, + "mean_final_window_accuracy_ppm": 948119, + "mean_final_window_balanced_accuracy_ppm": 947661, + "mean_primary_aulc_ppm": 940696, + "world_count": 96 + }, + "REACTIVE": { + "mean_accuracy_ppm": 630784, + "mean_balanced_accuracy_ppm": 535326, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 567, + "mean_excess_over_constant_ppm": 18466, + "mean_final_window_accuracy_ppm": 632405, + "mean_final_window_balanced_accuracy_ppm": 534881, + "mean_primary_aulc_ppm": 631016, + "world_count": 96 + } + }, + "development_seeds": [ + 600, + 601, + 602, + 603, + 604, + 605, + 606, + 607 + ], + "evaluation_seeds_run": false, + "m20_complement_relation_worlds": 16, + "m20_exact_expression_recovery": 80, + "m20_exact_relation_worlds": 72, + "m20_predictive_partition_recovery": 96, + "m20_receipts_all_valid": true, + "m20_world_count": 96, + "paired_development": { + "m20_minus_h8_aulc_ppm": { + "mean_delta": 183994, + "negative_worlds": 0, + "positive_worlds": 96, + "ties": 0, + "world_count": 96 + }, + "m20_minus_h8_balanced_accuracy_ppm": { + "mean_delta": 118269, + "negative_worlds": 0, + "positive_worlds": 96, + "ties": 0, + "world_count": 96 + }, + "m20_minus_oracle_aulc_ppm": { + "mean_delta": -54499, + "negative_worlds": 88, + "positive_worlds": 0, + "ties": 8, + "world_count": 96 + } + }, + "row_count": 384, + "rows": [ + { + "accuracy_ppm": 945963, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946646, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 808593, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800928, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929465, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719493, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945963, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946646, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945963, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946646, + "best_constant_accuracy_ppm": 528645, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 83, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 946650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934309, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 101, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940858, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 928838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 798828, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791843, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 274089, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932728, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704666, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934309, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 101, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940858, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 928838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934309, + "best_constant_accuracy_ppm": 524739, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940858, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 928838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949888, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957785, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 809244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811604, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 929417, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 684167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949888, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957785, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949888, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 77, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957785, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 937839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951328, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941715, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 809244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803432, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911412, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 705164, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951328, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941715, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951328, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 75, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941715, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 958108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949140, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962068, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 806640, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800766, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287109, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949137, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949140, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962068, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949140, + "best_constant_accuracy_ppm": 519531, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 78, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962068, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 943361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954915, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 984312, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 810546, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815117, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293619, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949428, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693720, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954915, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 984312, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954915, + "best_constant_accuracy_ppm": 516927, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 69, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 984312, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 941681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 939453, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939488, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926715, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 797526, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796631, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 311, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 885048, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 686825, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 939453, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939488, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926715, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 939453, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939488, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 93, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926715, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 929843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947575, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 809895, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805864, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 897801, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706244, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947575, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947575, + "best_constant_accuracy_ppm": 513020, + "candidate_field": { + "active_construction_count": 0, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 80, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 947167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 518880, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493911, + "best_constant_accuracy_ppm": 529296, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 739, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 493648, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 530934, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 813151, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805578, + "best_constant_accuracy_ppm": 529296, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283855, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913648, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719514, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950806, + "best_constant_accuracy_ppm": 529296, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949648, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942350, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 931640, + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 932132, + "best_constant_accuracy_ppm": 529296, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 402344, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949648, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 521484, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513120, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 735, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 494009, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 533579, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 811848, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804832, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 286458, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924903, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711075, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948179, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945228, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 933593, + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933554, + "best_constant_accuracy_ppm": 525390, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 408203, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945228, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879555, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 503255, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502286, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 763, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 487644, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517918, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805338, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807851, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 909438, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692987, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 948567, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948696, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934086, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947077, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 934324, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934086, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890490, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 496744, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484578, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 486276, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 803385, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797747, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283203, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 907329, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696103, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942057, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942251, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933644, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941769, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 926081, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 405599, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933644, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875178, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 493489, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483924, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26693, + "final_window_accuracy_ppm": 539062, + "final_window_balanced_accuracy_ppm": 493370, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 480116, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 804036, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798004, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283854, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936848, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687435, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949293, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949891, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938009, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 933593, + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933326, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949891, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875048, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 520833, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 518500, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 736, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 511718, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512050, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 819010, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 823527, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 278, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719016, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 958984, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959088, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976562, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942708, + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 943156, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 88, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976562, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889067, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 493489, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491747, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 499264, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 492155, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 806640, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805712, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 903921, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702489, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 946614, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946603, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941421, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941180, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 932942, + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 932918, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941421, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883290, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 496093, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493151, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 774, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 455847, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 529603, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 810546, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806467, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929282, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710777, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947699, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434245, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961282, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933856, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961282, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 892357, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 531901, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505912, + "best_constant_accuracy_ppm": 529947, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 719, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1954, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 524916, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 550559, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 813151, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804768, + "best_constant_accuracy_ppm": 529947, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283204, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932916, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 725337, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 948567, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948812, + "best_constant_accuracy_ppm": 529947, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964916, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 929036, + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 928428, + "best_constant_accuracy_ppm": 529947, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 399089, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964916, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867412, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 514973, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504841, + "best_constant_accuracy_ppm": 527343, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 745, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 513725, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515001, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 807942, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800045, + "best_constant_accuracy_ppm": 527343, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 280599, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932107, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715904, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944673, + "best_constant_accuracy_ppm": 527343, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948774, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934252, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 929687, + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 929476, + "best_constant_accuracy_ppm": 527343, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 402344, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948774, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876402, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 514322, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513969, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 746, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 7812, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 460468, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 532265, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 802734, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804625, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 901387, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695193, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944728, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933302, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945653, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "authorization_events": [ + 69 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927849, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933302, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880388, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 509765, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496567, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 753, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10417, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 508968, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497755, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 808593, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802753, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 927486, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695800, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944010, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943866, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953412, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927589, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 407552, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953412, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876664, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 496744, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482736, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 475245, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514174, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 816406, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810631, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940517, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 724631, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 953125, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953101, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957758, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952070, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 938151, + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 938023, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957758, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 894727, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 503906, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497354, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 508118, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 501725, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 807942, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812512, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291666, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933741, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700337, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 950520, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950595, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434244, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960873, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 932942, + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 933401, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416666, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960873, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876471, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 487630, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485219, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 787, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 536097, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504070, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 800130, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798896, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 295573, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 896276, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702594, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 938151, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938187, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 95, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925688, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929933, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 923828, + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 923839, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925688, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875814, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 489583, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482033, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24739, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 493040, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 486137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 800130, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795840, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285808, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913674, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694508, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 942057, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941953, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427735, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949389, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935554, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 923177, + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 922889, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 408855, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949389, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865642, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 535807, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509067, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 713, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5209, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 508790, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 566866, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 814453, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805797, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283855, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917520, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 733986, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 950520, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950734, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946753, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 932942, + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 932170, + "best_constant_accuracy_ppm": 530598, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 402344, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881592, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 513671, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489069, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 471226, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516594, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 802083, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794513, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 274089, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909243, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708712, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 940755, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941409, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 412761, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934036, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930402, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 923177, + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 922935, + "best_constant_accuracy_ppm": 527994, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 395183, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934036, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 516276, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 515392, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 743, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 10417, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 515594, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 531908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 804036, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805710, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 904232, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703746, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 946614, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946637, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935700, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947530, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 929687, + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 929738, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935700, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885949, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 498046, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 481657, + "best_constant_accuracy_ppm": 520833, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22787, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 509358, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 800781, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795108, + "best_constant_accuracy_ppm": 520833, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938463, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697604, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942708, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943206, + "best_constant_accuracy_ppm": 520833, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960851, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940833, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 925923, + "best_constant_accuracy_ppm": 520833, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 404948, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960851, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877828, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 509114, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491502, + "best_constant_accuracy_ppm": 521484, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 546875, + "final_window_balanced_accuracy_ppm": 501263, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502498, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 809895, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803490, + "best_constant_accuracy_ppm": 521484, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940394, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949748, + "best_constant_accuracy_ppm": 521484, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962133, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936830, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 934895, + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 934214, + "best_constant_accuracy_ppm": 521484, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962133, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878968, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 512369, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 510936, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 749, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2604, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 507812, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520971, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 811848, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816148, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937500, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711406, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 953776, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953948, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438803, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968750, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 933593, + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 934119, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968750, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868731, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 490885, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490504, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 491520, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502451, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 794270, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 792783, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 316, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 881603, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 937500, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937520, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 96, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910529, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934032, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 919921, + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 919865, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 123, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414713, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910529, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868980, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 507812, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497234, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -8464, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 516916, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510911, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 808593, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803510, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292317, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936916, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 949218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948867, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942089, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 932291, + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 931413, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416015, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879699, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 516276, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500567, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 743, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 490147, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 526709, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 801432, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794067, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 274740, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 908251, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708398, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 943359, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943998, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938423, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942901, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 927083, + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 926944, + "best_constant_accuracy_ppm": 526692, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 400391, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938423, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878087, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 506510, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506358, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5859, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503661, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 811848, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811671, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 311197, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937190, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715910, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951175, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 450520, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972623, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943854, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 936197, + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 936199, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 435546, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972623, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882159, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 503906, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503972, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3255, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 465740, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 523576, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 815755, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813749, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913282, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 957031, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957077, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449870, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945282, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 938802, + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 938956, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 431641, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945282, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884885, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 513671, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513846, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 12369, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 504237, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518925, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802734, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803107, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 910463, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 944661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944666, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941895, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 927083, + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927099, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875528, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 489583, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487994, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 478879, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514390, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 807291, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805696, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929274, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695855, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 953776, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953723, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448568, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952699, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 936848, + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 936753, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 431640, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 483723, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484849, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 793, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24089, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 478044, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499731, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 804687, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806918, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 932161, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709527, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 946614, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946662, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944435, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 927083, + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927166, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867242, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 490885, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493955, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 524011, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 462087, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802734, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804995, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 908657, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685290, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 941406, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941534, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929636, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 926825, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 926432, + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 926607, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929636, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 862726, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 489583, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485353, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 491881, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 506100, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 805989, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809268, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921564, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 946614, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946847, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956997, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938659, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 930338, + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930635, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956997, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877907, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 501953, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496264, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 765, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 421875, + "final_window_balanced_accuracy_ppm": 440709, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 527356, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807291, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805293, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 903550, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715842, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 948567, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948622, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933179, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 931640, + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 931654, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933179, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885797, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 499348, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 488029, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 769, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 504058, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487630, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 804687, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798007, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 280599, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 910040, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706735, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944010, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944382, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935260, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 40 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 926048, + "best_constant_accuracy_ppm": 524088, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 401693, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861732, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 512369, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496828, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 749, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -6511, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 496864, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519536, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813207, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 904660, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693983, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951224, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937034, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948686, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 933593, + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 933351, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 414713, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937034, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880296, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 491536, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491345, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 781, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 493882, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499848, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 803385, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804650, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926534, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944010, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944005, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945191, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942636, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 927734, + "authorization_events": [ + 39 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 927781, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945191, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874695, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 490234, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491476, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24088, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 457627, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 486571, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 813151, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817234, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298829, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941967, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698242, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951411, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952836, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942961, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 933593, + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 933912, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952836, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874543, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 496744, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487078, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 505566, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 485730, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 809895, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806493, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948189, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949826, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972779, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938332, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 932291, + "authorization_events": [ + 39 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 932162, + "best_constant_accuracy_ppm": 511718, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972779, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 862419, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 510416, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502634, + "best_constant_accuracy_ppm": 518229, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 752, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 501588, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 495661, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 802734, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807391, + "best_constant_accuracy_ppm": 518229, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 284505, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905669, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682616, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945312, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944954, + "best_constant_accuracy_ppm": 518229, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925830, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937655, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 929687, + "authorization_events": [ + 37 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 929356, + "best_constant_accuracy_ppm": 518229, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 411458, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925830, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872168, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 490885, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490909, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 497232, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 490784, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 808593, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808795, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 901739, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708130, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 951822, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951838, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451171, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949372, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 933593, + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 933622, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881548, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 519531, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503239, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 738, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7161, + "final_window_accuracy_ppm": 550781, + "final_window_balanced_accuracy_ppm": 508004, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516232, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 812500, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 819213, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285808, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 924137, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703091, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 950520, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950239, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956280, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948667, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932291, + "authorization_events": [ + 41 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931609, + "best_constant_accuracy_ppm": 526692, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 405599, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956280, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873012, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 483723, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483588, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 793, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16928, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 456845, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 460993, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 799479, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799649, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918054, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695478, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 935546, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 935540, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 99, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434895, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925806, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 920014, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 919270, + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 919270, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 124, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418619, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925806, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 852295, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 485677, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485981, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 790, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 457740, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 796223, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798336, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 313, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 914381, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680395, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 940104, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940184, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937282, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 927083, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 922526, + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 922780, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 415365, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937282, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856867, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 513671, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513839, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 12369, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 527818, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512612, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805338, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804985, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304036, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937729, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692868, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944672, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 959468, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936541, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930989, + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931005, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 959468, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882081, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 475911, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 474857, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 805, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 468518, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493209, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 813802, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815246, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699678, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949267, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444010, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964636, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935408, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932942, + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 932982, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964636, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873479, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 486979, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487423, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 788, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20833, + "final_window_accuracy_ppm": 539062, + "final_window_balanced_accuracy_ppm": 494973, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497033, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 816406, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814204, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 933641, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692986, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 955729, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955738, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447917, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968424, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945185, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 938802, + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 938725, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 430990, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968424, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876176, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 494791, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497537, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 776, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 498390, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496711, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 796875, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794769, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289063, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 871402, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704208, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 938802, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938949, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 94, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430990, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911225, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938287, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 923177, + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 923178, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 415365, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911225, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 500651, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495489, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 483946, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503461, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 809244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805906, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910302, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687359, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 951171, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951046, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949062, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939498, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 935546, + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 935385, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949062, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875148, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 738281, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506899, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 402, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 518320, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 755615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 881510, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813306, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 182, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 115234, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 928768, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 838262, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 945963, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951189, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 179687, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 966081, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936849, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930338, + "authorization_events": [ + 156 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 917763, + "best_constant_accuracy_ppm": 766276, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 164062, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 966081, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888198, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 742838, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500321, + "best_constant_accuracy_ppm": 776041, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 395, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 734375, + "final_window_balanced_accuracy_ppm": 480842, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 734687, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 873697, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 792472, + "best_constant_accuracy_ppm": 776041, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 194, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 97656, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 929118, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 822887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 940104, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940728, + "best_constant_accuracy_ppm": 776041, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 164063, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 929118, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930717, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 922526, + "authorization_events": [ + 128 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 902518, + "best_constant_accuracy_ppm": 776041, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 146485, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 929118, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875892, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 716145, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501514, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 436, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22787, + "final_window_accuracy_ppm": 660156, + "final_window_balanced_accuracy_ppm": 491417, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 716220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 871093, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798272, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 198, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 132161, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 902810, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 813721, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 942708, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 935429, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203776, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928126, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940136, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 926432, + "authorization_events": [ + 106 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 904257, + "best_constant_accuracy_ppm": 738932, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 187500, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928126, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887912, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 737630, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496429, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 403, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 492375, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 735079, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 876302, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798986, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 190, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 105469, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 925708, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 823049, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 942057, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942451, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 171224, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 952375, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942966, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 925130, + "authorization_events": [ + 81 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 906518, + "best_constant_accuracy_ppm": 770833, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 154297, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 952375, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883633, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 736979, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489832, + "best_constant_accuracy_ppm": 767578, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 404, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 761718, + "final_window_balanced_accuracy_ppm": 503025, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 737040, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 884765, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807759, + "best_constant_accuracy_ppm": 767578, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 177, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 117187, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 947469, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 836206, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 951822, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952016, + "best_constant_accuracy_ppm": 767578, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 184244, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 956728, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943658, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 937500, + "authorization_events": [ + 144 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 921204, + "best_constant_accuracy_ppm": 767578, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 169922, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 956728, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 899261, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 721354, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508152, + "best_constant_accuracy_ppm": 737630, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 428, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 753906, + "final_window_balanced_accuracy_ppm": 499564, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715489, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 887369, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 824529, + "best_constant_accuracy_ppm": 737630, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 173, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 149739, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 947840, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 829243, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 957682, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958524, + "best_constant_accuracy_ppm": 737630, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 65, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 220052, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 982323, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950805, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 941406, + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 927507, + "best_constant_accuracy_ppm": 737630, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 90, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 203776, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 982323, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 896465, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 723307, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495524, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 425, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -34505, + "final_window_accuracy_ppm": 773437, + "final_window_balanced_accuracy_ppm": 524038, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 727574, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 871744, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801975, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 197, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 113932, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 878204, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 828055, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 941406, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945793, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 183594, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 930288, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 102 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 913534, + "best_constant_accuracy_ppm": 757812, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 167969, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 930288, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890409, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 739583, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490435, + "best_constant_accuracy_ppm": 769531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 400, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29948, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 485201, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 739659, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 880859, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796932, + "best_constant_accuracy_ppm": 769531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 183, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 111328, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 928749, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 829513, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946649, + "best_constant_accuracy_ppm": 769531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 180338, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 961007, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947799, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 912751, + "best_constant_accuracy_ppm": 769531, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 164713, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 961007, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895821, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 693359, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500704, + "best_constant_accuracy_ppm": 716145, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 471, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22786, + "final_window_accuracy_ppm": 726562, + "final_window_balanced_accuracy_ppm": 492556, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 652189, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 746744, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810721, + "best_constant_accuracy_ppm": 716145, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 389, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 30599, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 919195, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 615886, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 955729, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956630, + "best_constant_accuracy_ppm": 716145, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 239584, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952873, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952172, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 938802, + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 934428, + "best_constant_accuracy_ppm": 716145, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 222657, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952873, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885297, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 694661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509268, + "best_constant_accuracy_ppm": 710937, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 469, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 498537, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701866, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 738932, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797012, + "best_constant_accuracy_ppm": 710937, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 401, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27995, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 911549, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 598372, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947265, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943532, + "best_constant_accuracy_ppm": 710937, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 236328, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 939327, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938802, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 935546, + "authorization_events": [ + 92 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 927939, + "best_constant_accuracy_ppm": 710937, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 224609, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 939327, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 741536, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506119, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 397, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 796875, + "final_window_balanced_accuracy_ppm": 508147, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 743608, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809679, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 886577, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 570886, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949866, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 183593, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 917238, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948024, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 934244, + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 921279, + "best_constant_accuracy_ppm": 766276, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 167968, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 917238, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 892977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 708333, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503972, + "best_constant_accuracy_ppm": 731770, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 448, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23437, + "final_window_accuracy_ppm": 773437, + "final_window_balanced_accuracy_ppm": 525554, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731770, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794431, + "best_constant_accuracy_ppm": 731770, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 412, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 0, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 942017, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 566644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942708, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938559, + "best_constant_accuracy_ppm": 731770, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 210938, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961917, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 101 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 911618, + "best_constant_accuracy_ppm": 731770, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 194011, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961917, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879469, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 708333, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499217, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 448, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 691406, + "final_window_balanced_accuracy_ppm": 485204, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801843, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1302, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 927234, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 572901, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 944661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944195, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 208333, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 943538, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932340, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 929036, + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 919320, + "best_constant_accuracy_ppm": 736328, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 192708, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 943538, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 728515, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497038, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 417, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 730468, + "final_window_balanced_accuracy_ppm": 513977, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689899, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 734375, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809440, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 408, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25390, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 932637, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 575752, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 949869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951257, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 190104, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 961738, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 932291, + "authorization_events": [ + 78 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 923938, + "best_constant_accuracy_ppm": 759765, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 172526, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 961738, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863504, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 733723, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513935, + "best_constant_accuracy_ppm": 754557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 409, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20834, + "final_window_accuracy_ppm": 683593, + "final_window_balanced_accuracy_ppm": 504826, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 726436, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 729817, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796804, + "best_constant_accuracy_ppm": 754557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 415, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 899019, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 571095, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942708, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937874, + "best_constant_accuracy_ppm": 754557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 188151, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 923744, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 927734, + "authorization_events": [ + 102 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 911845, + "best_constant_accuracy_ppm": 754557, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 173177, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 923744, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886832, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 705729, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505996, + "best_constant_accuracy_ppm": 735026, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 452, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 474226, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707959, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 732421, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806981, + "best_constant_accuracy_ppm": 735026, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 411, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2605, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 913950, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 574326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947265, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953128, + "best_constant_accuracy_ppm": 735026, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 212239, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950032, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940355, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 929687, + "authorization_events": [ + 90 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 931743, + "best_constant_accuracy_ppm": 735026, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 194661, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950032, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877832, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 481119, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 480078, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 797, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 521217, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491373, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 798828, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796598, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290365, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 915967, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696117, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 936848, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936996, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942994, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 921223, + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 921278, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412760, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942994, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872270, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 503906, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503841, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 492551, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 527327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 805338, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804992, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304036, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699897, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945312, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945332, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444010, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 931640, + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 931645, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877008, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 493489, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487326, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 493162, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 488276, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 807291, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804304, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917765, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694000, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 946614, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946591, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945543, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934445, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 930989, + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 930904, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945543, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870125, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 506510, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490935, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503906, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507616, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 804036, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798758, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285156, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933593, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698334, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 940755, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940842, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949218, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927734, + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927951, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 408854, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949218, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877195, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 486328, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485452, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 460937, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 483664, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 809895, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810477, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933593, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681856, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 951822, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951852, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 937500, + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 937509, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884415, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 505859, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505579, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 499510, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 522862, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 817708, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818581, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 314453, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940248, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714953, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 955729, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955709, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 452474, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972506, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955379, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 938802, + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 938849, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972506, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889015, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 503255, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503253, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 763, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1953, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 476679, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 794921, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795291, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 315, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293619, + "final_window_accuracy_ppm": 878906, + "final_window_balanced_accuracy_ppm": 880402, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685599, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 940104, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940096, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925514, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929571, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 925773, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925514, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871526, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 490234, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484144, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20833, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 508424, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 460635, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 802083, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805244, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291016, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910561, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681745, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945963, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946009, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952868, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931405, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 930989, + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 931157, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952868, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869342, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 846354, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514555, + "best_constant_accuracy_ppm": 888671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 236, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42317, + "final_window_accuracy_ppm": 832031, + "final_window_balanced_accuracy_ppm": 529993, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 862870, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910807, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804028, + "best_constant_accuracy_ppm": 888671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 137, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 22136, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 915707, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 896686, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 943359, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950227, + "best_constant_accuracy_ppm": 888671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 54688, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 972850, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937957, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 927734, + "authorization_events": [ + 398 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 880052, + "best_constant_accuracy_ppm": 888671, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 39063, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 972850, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 905948, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 849609, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513336, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 231, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42318, + "final_window_accuracy_ppm": 855468, + "final_window_balanced_accuracy_ppm": 494501, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 837891, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910807, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796468, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 137, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 18880, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 920426, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 882464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 942708, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944059, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 50781, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 920426, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933097, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 927083, + "authorization_events": [ + 189 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 871769, + "best_constant_accuracy_ppm": 891927, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 35156, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 920426, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 891887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 837239, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511229, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31901, + "final_window_accuracy_ppm": 761718, + "final_window_balanced_accuracy_ppm": 497704, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831914, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 914062, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804762, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 132, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 44922, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 919272, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 883120, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 931627, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938880, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940202, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 931640, + "authorization_events": [ + 205 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 871926, + "best_constant_accuracy_ppm": 869140, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 62500, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938880, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 899438, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 837890, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487505, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 249, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -48828, + "final_window_accuracy_ppm": 824218, + "final_window_balanced_accuracy_ppm": 487678, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831320, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 906250, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 789229, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 144, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 19532, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 943560, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 874294, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 940104, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938654, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 53386, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 958266, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938227, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 922526, + "authorization_events": [ + 197 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 863575, + "best_constant_accuracy_ppm": 886718, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 35808, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 958266, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 852864, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485749, + "best_constant_accuracy_ppm": 892578, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 226, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 494025, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 859223, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919921, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797871, + "best_constant_accuracy_ppm": 892578, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 123, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27343, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 914025, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 900363, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953125, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952416, + "best_constant_accuracy_ppm": 892578, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 60547, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 934025, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936848, + "authorization_events": [ + 286 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 876659, + "best_constant_accuracy_ppm": 892578, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 44270, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 934025, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 913069, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 827473, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504671, + "best_constant_accuracy_ppm": 859375, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 265, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31902, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 499619, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 820835, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 918619, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 828745, + "best_constant_accuracy_ppm": 859375, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 125, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 59244, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965137, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 887786, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 955078, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958374, + "best_constant_accuracy_ppm": 859375, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 95703, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 982378, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947762, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936197, + "authorization_events": [ + 176 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 898989, + "best_constant_accuracy_ppm": 859375, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 76822, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 982378, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 896592, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 826822, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497630, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 266, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -46224, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 500559, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 843889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 906901, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813015, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 143, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 33855, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 935342, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 892193, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 941406, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948912, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 68360, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 935342, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 209 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 887374, + "best_constant_accuracy_ppm": 873046, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 52735, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 935342, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 904664, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 858072, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499551, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 218, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33855, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 519813, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 843675, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919270, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 782683, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 124, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27343, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 928903, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 891625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953776, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942322, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 951631, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949501, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 937500, + "authorization_events": [ + 163 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 869668, + "best_constant_accuracy_ppm": 891927, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 45573, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 951631, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 903321, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 809244, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497954, + "best_constant_accuracy_ppm": 844401, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35157, + "final_window_accuracy_ppm": 820312, + "final_window_balanced_accuracy_ppm": 504903, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 782887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 707682, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804722, + "best_constant_accuracy_ppm": 844401, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 449, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -136719, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 931879, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 542209, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 952473, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949672, + "best_constant_accuracy_ppm": 844401, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 108072, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 966441, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946310, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 936197, + "authorization_events": [ + 92 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 909317, + "best_constant_accuracy_ppm": 844401, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 91796, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 966441, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887264, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 807942, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502061, + "best_constant_accuracy_ppm": 845052, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37110, + "final_window_accuracy_ppm": 832031, + "final_window_balanced_accuracy_ppm": 517970, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 783503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 708984, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808939, + "best_constant_accuracy_ppm": 845052, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 447, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -136068, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 909631, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 553821, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 948567, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950696, + "best_constant_accuracy_ppm": 845052, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 103515, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 932255, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 931640, + "authorization_events": [ + 98 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 908083, + "best_constant_accuracy_ppm": 845052, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 86588, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 932255, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883154, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 843098, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501403, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 241, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -40365, + "final_window_accuracy_ppm": 851562, + "final_window_balanced_accuracy_ppm": 509398, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 849515, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697265, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806842, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 465, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -186198, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 875939, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499787, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948699, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 64453, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 902255, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947397, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 930989, + "authorization_events": [ + 202 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 885773, + "best_constant_accuracy_ppm": 883463, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 47526, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 902255, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 903445, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 802083, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493981, + "best_constant_accuracy_ppm": 843750, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -41667, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 497085, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 796309, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697265, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791743, + "best_constant_accuracy_ppm": 843750, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 465, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -146485, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 903262, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 941406, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936419, + "best_constant_accuracy_ppm": 843750, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 97656, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 928903, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935761, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 925781, + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 894907, + "best_constant_accuracy_ppm": 843750, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 82031, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 928903, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890874, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 830078, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507475, + "best_constant_accuracy_ppm": 867838, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 261, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37760, + "final_window_accuracy_ppm": 808593, + "final_window_balanced_accuracy_ppm": 493212, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 835245, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 699218, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797474, + "best_constant_accuracy_ppm": 867838, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 462, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -168620, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 917333, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514992, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 944661, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938885, + "best_constant_accuracy_ppm": 867838, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 76823, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 933688, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937925, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 929036, + "authorization_events": [ + 174 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 888123, + "best_constant_accuracy_ppm": 867838, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 61198, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 933688, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 893506, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 837239, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505019, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -38412, + "final_window_accuracy_ppm": 851562, + "final_window_balanced_accuracy_ppm": 513392, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 819983, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697265, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797938, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 465, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -178386, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 919642, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502413, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 947916, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941061, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 72265, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 950892, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937663, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 930989, + "authorization_events": [ + 115 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 888720, + "best_constant_accuracy_ppm": 875651, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 55338, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 950892, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879734, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 829427, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 518053, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 262, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35807, + "final_window_accuracy_ppm": 824218, + "final_window_balanced_accuracy_ppm": 549130, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 818633, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 695963, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793715, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 467, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -169271, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 924915, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511705, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 943359, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936679, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 957025, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934132, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 927083, + "authorization_events": [ + 161 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 888528, + "best_constant_accuracy_ppm": 865234, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 957025, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 820312, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513325, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 276, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42318, + "final_window_accuracy_ppm": 843750, + "final_window_balanced_accuracy_ppm": 477876, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 799250, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 699869, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816076, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 461, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -162761, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 923598, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517652, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 946614, + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959094, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 83984, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 961209, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935967, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 929036, + "authorization_events": [ + 157 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 915036, + "best_constant_accuracy_ppm": 862630, + "candidate_field": { + "active_construction_count": 1, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 16384 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 66406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 961209, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + } + ], + "status": "DEVELOPMENT_ONLY", + "task_count": 12 +} diff --git a/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.sha256 b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.sha256 new file mode 100644 index 0000000..ff16fd9 --- /dev/null +++ b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.sha256 @@ -0,0 +1 @@ +a9ae0db65558a7afbb2fb3d434d6e9f8e4f5003067f88e99d27fe98290b0f87a experiments/prime_m20_universal_arena/DEVELOPMENT_V0_2_RESULT.json diff --git a/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.json b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.json new file mode 100644 index 0000000..149936c --- /dev/null +++ b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.json @@ -0,0 +1,12287 @@ +{ + "benchmark": "prime-m20-universal-arena-v0.3", + "by_task": [ + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 946661, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 429768, + "mean_final_window_accuracy_ppm": 951171, + "mean_final_window_balanced_accuracy_ppm": 951542, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941685, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 806314, + "mean_balanced_accuracy_ppm": 803273, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 297, + "mean_excess_over_constant_ppm": 289469, + "mean_final_window_accuracy_ppm": 922851, + "mean_final_window_balanced_accuracy_ppm": 923054, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 699167, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 946661, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 429768, + "mean_final_window_accuracy_ppm": 951171, + "mean_final_window_balanced_accuracy_ppm": 951542, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941685, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 946661, + "mean_best_constant_accuracy_ppm": 516845, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 429768, + "mean_final_window_accuracy_ppm": 951171, + "mean_final_window_balanced_accuracy_ppm": 951542, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941685, + "mean_target_prevalence_ppm": 489501, + "partition_relation_counts": {}, + "predictive_partition_recovery": 8, + "task": "CURRENT", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 505533, + "mean_balanced_accuracy_ppm": 497652, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 759, + "mean_excess_over_constant_ppm": -11556, + "mean_final_window_accuracy_ppm": 497558, + "mean_final_window_balanced_accuracy_ppm": 490222, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 510462, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 809244, + "mean_balanced_accuracy_ppm": 806214, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 293, + "mean_excess_over_constant_ppm": 292154, + "mean_final_window_accuracy_ppm": 921386, + "mean_final_window_balanced_accuracy_ppm": 921335, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 704924, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 948892, + "mean_balanced_accuracy_ppm": 949076, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 78, + "mean_excess_over_constant_ppm": 431803, + "mean_final_window_accuracy_ppm": 948729, + "mean_final_window_balanced_accuracy_ppm": 948970, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 943621, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 932779, + "mean_balanced_accuracy_ppm": 932855, + "mean_best_constant_accuracy_ppm": 517089, + "mean_cumulative_mistakes": 103, + "mean_excess_over_constant_ppm": 415690, + "mean_final_window_accuracy_ppm": 948729, + "mean_final_window_balanced_accuracy_ppm": 948970, + "mean_first_authorization_event": 56, + "mean_primary_aulc_ppm": 879382, + "mean_target_prevalence_ppm": 489094, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "LAG-1", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 506103, + "mean_balanced_accuracy_ppm": 496078, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 758, + "mean_excess_over_constant_ppm": -11312, + "mean_final_window_accuracy_ppm": 506835, + "mean_final_window_balanced_accuracy_ppm": 502572, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 512710, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 807128, + "mean_balanced_accuracy_ppm": 803758, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 296, + "mean_excess_over_constant_ppm": 289713, + "mean_final_window_accuracy_ppm": 922362, + "mean_final_window_balanced_accuracy_ppm": 922263, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 706788, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 945719, + "mean_balanced_accuracy_ppm": 945739, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 83, + "mean_excess_over_constant_ppm": 428304, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949264, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 940302, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 927978, + "mean_balanced_accuracy_ppm": 927858, + "mean_best_constant_accuracy_ppm": 517414, + "mean_cumulative_mistakes": 110, + "mean_excess_over_constant_ppm": 410563, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949264, + "mean_first_authorization_event": 58, + "mean_primary_aulc_ppm": 873241, + "mean_target_prevalence_ppm": 488280, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "LAG-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 510497, + "mean_balanced_accuracy_ppm": 498170, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 751, + "mean_excess_over_constant_ppm": -7406, + "mean_final_window_accuracy_ppm": 510741, + "mean_final_window_balanced_accuracy_ppm": 502809, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 519471, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 805744, + "mean_balanced_accuracy_ppm": 802132, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 298, + "mean_excess_over_constant_ppm": 287841, + "mean_final_window_accuracy_ppm": 920898, + "mean_final_window_balanced_accuracy_ppm": 920733, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 706565, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946370, + "mean_balanced_accuracy_ppm": 946508, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 428466, + "mean_final_window_accuracy_ppm": 947265, + "mean_final_window_balanced_accuracy_ppm": 947272, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 939837, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 927164, + "mean_balanced_accuracy_ppm": 926901, + "mean_best_constant_accuracy_ppm": 517903, + "mean_cumulative_mistakes": 111, + "mean_excess_over_constant_ppm": 409261, + "mean_final_window_accuracy_ppm": 947265, + "mean_final_window_balanced_accuracy_ppm": 947272, + "mean_first_authorization_event": 62, + "mean_primary_aulc_ppm": 870108, + "mean_target_prevalence_ppm": 487304, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "LAG-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 499267, + "mean_balanced_accuracy_ppm": 497111, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 769, + "mean_excess_over_constant_ppm": -9196, + "mean_final_window_accuracy_ppm": 503905, + "mean_final_window_balanced_accuracy_ppm": 492075, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 507017, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 806558, + "mean_balanced_accuracy_ppm": 806183, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 297, + "mean_excess_over_constant_ppm": 298095, + "mean_final_window_accuracy_ppm": 920409, + "mean_final_window_balanced_accuracy_ppm": 920105, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 702827, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 948079, + "mean_balanced_accuracy_ppm": 948210, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 79, + "mean_excess_over_constant_ppm": 439615, + "mean_final_window_accuracy_ppm": 948241, + "mean_final_window_balanced_accuracy_ppm": 948178, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 943604, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 931151, + "mean_balanced_accuracy_ppm": 931204, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 105, + "mean_excess_over_constant_ppm": 422688, + "mean_final_window_accuracy_ppm": 948241, + "mean_final_window_balanced_accuracy_ppm": 948178, + "mean_first_authorization_event": 57, + "mean_primary_aulc_ppm": 876894, + "mean_target_prevalence_ppm": 498534, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "XOR-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 499185, + "mean_balanced_accuracy_ppm": 493070, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 769, + "mean_excess_over_constant_ppm": -13266, + "mean_final_window_accuracy_ppm": 495605, + "mean_final_window_balanced_accuracy_ppm": 487190, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 499139, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 807209, + "mean_balanced_accuracy_ppm": 807633, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 296, + "mean_excess_over_constant_ppm": 294759, + "mean_final_window_accuracy_ppm": 917480, + "mean_final_window_balanced_accuracy_ppm": 917793, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 701773, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 948241, + "mean_balanced_accuracy_ppm": 948282, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 79, + "mean_excess_over_constant_ppm": 435790, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 945481, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 942910, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 0, + "mean_accuracy_ppm": 930012, + "mean_balanced_accuracy_ppm": 929977, + "mean_best_constant_accuracy_ppm": 512450, + "mean_cumulative_mistakes": 107, + "mean_excess_over_constant_ppm": 417561, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 945481, + "mean_first_authorization_event": 51, + "mean_primary_aulc_ppm": 871209, + "mean_target_prevalence_ppm": 501708, + "partition_relation_counts": { + "complement": 8 + }, + "predictive_partition_recovery": 8, + "task": "XOR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 495116, + "mean_balanced_accuracy_ppm": 492744, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 775, + "mean_excess_over_constant_ppm": -13347, + "mean_final_window_accuracy_ppm": 499511, + "mean_final_window_balanced_accuracy_ppm": 487029, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 496442, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 806233, + "mean_balanced_accuracy_ppm": 806538, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 297, + "mean_excess_over_constant_ppm": 297770, + "mean_final_window_accuracy_ppm": 920409, + "mean_final_window_balanced_accuracy_ppm": 919905, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 694507, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 945718, + "mean_balanced_accuracy_ppm": 945704, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 83, + "mean_excess_over_constant_ppm": 437255, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 946522, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 936335, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 0, + "mean_accuracy_ppm": 928140, + "mean_balanced_accuracy_ppm": 928064, + "mean_best_constant_accuracy_ppm": 508463, + "mean_cumulative_mistakes": 110, + "mean_excess_over_constant_ppm": 419677, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 946522, + "mean_first_authorization_event": 55, + "mean_primary_aulc_ppm": 866716, + "mean_target_prevalence_ppm": 501464, + "partition_relation_counts": { + "complement": 8 + }, + "predictive_partition_recovery": 8, + "task": "EQ-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 732014, + "mean_balanced_accuracy_ppm": 498638, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 411, + "mean_excess_over_constant_ppm": -28565, + "mean_final_window_accuracy_ppm": 725585, + "mean_final_window_balanced_accuracy_ppm": 499347, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 732670, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 878417, + "mean_balanced_accuracy_ppm": 804278, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 186, + "mean_excess_over_constant_ppm": 117838, + "mean_final_window_accuracy_ppm": 933593, + "mean_final_window_balanced_accuracy_ppm": 923583, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 827617, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946451, + "mean_balanced_accuracy_ppm": 946597, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 185872, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 950755, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 941662, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 928710, + "mean_balanced_accuracy_ppm": 910033, + "mean_best_constant_accuracy_ppm": 760579, + "mean_cumulative_mistakes": 109, + "mean_excess_over_constant_ppm": 168131, + "mean_final_window_accuracy_ppm": 946777, + "mean_final_window_balanced_accuracy_ppm": 950755, + "mean_first_authorization_event": 123, + "mean_primary_aulc_ppm": 885556, + "mean_target_prevalence_ppm": 239419, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "AND-1-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 714273, + "mean_balanced_accuracy_ppm": 504531, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 438, + "mean_excess_over_constant_ppm": -24577, + "mean_final_window_accuracy_ppm": 725097, + "mean_final_window_balanced_accuracy_ppm": 500378, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 701505, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 735513, + "mean_balanced_accuracy_ppm": 803363, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 406, + "mean_excess_over_constant_ppm": -3337, + "mean_final_window_accuracy_ppm": 906737, + "mean_final_window_balanced_accuracy_ppm": 916522, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 580732, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 947509, + "mean_balanced_accuracy_ppm": 946880, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 80, + "mean_excess_over_constant_ppm": 208658, + "mean_final_window_accuracy_ppm": 947753, + "mean_final_window_balanced_accuracy_ppm": 943800, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 940218, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 930256, + "mean_balanced_accuracy_ppm": 920270, + "mean_best_constant_accuracy_ppm": 738850, + "mean_cumulative_mistakes": 107, + "mean_excess_over_constant_ppm": 191406, + "mean_final_window_accuracy_ppm": 947753, + "mean_final_window_balanced_accuracy_ppm": 943800, + "mean_first_authorization_event": 92, + "mean_primary_aulc_ppm": 878053, + "mean_target_prevalence_ppm": 738850, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "OR-2-7", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 496337, + "mean_balanced_accuracy_ppm": 492576, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 773, + "mean_excess_over_constant_ppm": -10743, + "mean_final_window_accuracy_ppm": 496581, + "mean_final_window_balanced_accuracy_ppm": 494548, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 498970, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 805012, + "mean_balanced_accuracy_ppm": 804280, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 299, + "mean_excess_over_constant_ppm": 297932, + "mean_final_window_accuracy_ppm": 922362, + "mean_final_window_balanced_accuracy_ppm": 922193, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 694062, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 945393, + "mean_balanced_accuracy_ppm": 945428, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 83, + "mean_excess_over_constant_ppm": 438313, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949345, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 936447, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 928384, + "mean_balanced_accuracy_ppm": 928447, + "mean_best_constant_accuracy_ppm": 507079, + "mean_cumulative_mistakes": 110, + "mean_excess_over_constant_ppm": 421305, + "mean_final_window_accuracy_ppm": 949218, + "mean_final_window_balanced_accuracy_ppm": 949345, + "mean_first_authorization_event": 53, + "mean_primary_aulc_ppm": 869120, + "mean_target_prevalence_ppm": 497314, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "XOR-1-2-3", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 842040, + "mean_balanced_accuracy_ppm": 501778, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 242, + "mean_excess_over_constant_ppm": -39633, + "mean_final_window_accuracy_ppm": 838378, + "mean_final_window_balanced_accuracy_ppm": 502986, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 841452, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 913329, + "mean_balanced_accuracy_ppm": 802100, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 133, + "mean_excess_over_constant_ppm": 31656, + "mean_final_window_accuracy_ppm": 940917, + "mean_final_window_balanced_accuracy_ppm": 930296, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 888566, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 947102, + "mean_balanced_accuracy_ppm": 945823, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 81, + "mean_excess_over_constant_ppm": 65429, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 949224, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 942381, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 929280, + "mean_balanced_accuracy_ppm": 871938, + "mean_best_constant_accuracy_ppm": 881672, + "mean_cumulative_mistakes": 108, + "mean_excess_over_constant_ppm": 47607, + "mean_final_window_accuracy_ppm": 945800, + "mean_final_window_balanced_accuracy_ppm": 949224, + "mean_first_authorization_event": 245, + "mean_primary_aulc_ppm": 898036, + "mean_target_prevalence_ppm": 118326, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "AND-1-2-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "REACTIVE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 822427, + "mean_balanced_accuracy_ppm": 504908, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 272, + "mean_excess_over_constant_ppm": -38575, + "mean_final_window_accuracy_ppm": 837890, + "mean_final_window_balanced_accuracy_ppm": 507870, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 810665, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "FIXED-H8", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 700438, + "mean_balanced_accuracy_ppm": 802181, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 460, + "mean_excess_over_constant_ppm": -160564, + "mean_final_window_accuracy_ppm": 901367, + "mean_final_window_balanced_accuracy_ppm": 913274, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 518902, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": null, + "condition": "ORACLE-FEATURE", + "exact_expression_recovery": null, + "mean_accuracy_ppm": 946614, + "mean_balanced_accuracy_ppm": 945150, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 82, + "mean_excess_over_constant_ppm": 85611, + "mean_final_window_accuracy_ppm": 950683, + "mean_final_window_balanced_accuracy_ppm": 941583, + "mean_first_authorization_event": null, + "mean_primary_aulc_ppm": 939346, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": {}, + "predictive_partition_recovery": null, + "task": "OR-2-3-4", + "world_count": 8 + }, + { + "all_receipts_valid": true, + "condition": "M20-CONSTRUCTION", + "exact_expression_recovery": 8, + "mean_accuracy_ppm": 929198, + "mean_balanced_accuracy_ppm": 893231, + "mean_best_constant_accuracy_ppm": 861002, + "mean_cumulative_mistakes": 108, + "mean_excess_over_constant_ppm": 68196, + "mean_final_window_accuracy_ppm": 950683, + "mean_final_window_balanced_accuracy_ppm": 941583, + "mean_first_authorization_event": 171, + "mean_primary_aulc_ppm": 886107, + "mean_target_prevalence_ppm": 861002, + "partition_relation_counts": { + "exact": 8 + }, + "predictive_partition_recovery": 8, + "task": "OR-2-3-4", + "world_count": 8 + } + ], + "condition_count": 4, + "condition_summaries": { + "FIXED-H8": { + "mean_accuracy_ppm": 806762, + "mean_balanced_accuracy_ppm": 804328, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 296, + "mean_excess_over_constant_ppm": 194444, + "mean_final_window_accuracy_ppm": 920898, + "mean_final_window_balanced_accuracy_ppm": 920921, + "mean_primary_aulc_ppm": 702202, + "world_count": 96 + }, + "M20-CONSTRUCTION": { + "mean_accuracy_ppm": 930805, + "mean_balanced_accuracy_ppm": 920620, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 106, + "mean_excess_over_constant_ppm": 318488, + "mean_final_window_accuracy_ppm": 948119, + "mean_final_window_balanced_accuracy_ppm": 947661, + "mean_primary_aulc_ppm": 883009, + "world_count": 96 + }, + "ORACLE-FEATURE": { + "mean_accuracy_ppm": 946892, + "mean_balanced_accuracy_ppm": 946671, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 81, + "mean_excess_over_constant_ppm": 334574, + "mean_final_window_accuracy_ppm": 948119, + "mean_final_window_balanced_accuracy_ppm": 947661, + "mean_primary_aulc_ppm": 940696, + "world_count": 96 + }, + "REACTIVE": { + "mean_accuracy_ppm": 630784, + "mean_balanced_accuracy_ppm": 535326, + "mean_best_constant_accuracy_ppm": 612317, + "mean_cumulative_mistakes": 567, + "mean_excess_over_constant_ppm": 18466, + "mean_final_window_accuracy_ppm": 632405, + "mean_final_window_balanced_accuracy_ppm": 534881, + "mean_primary_aulc_ppm": 631016, + "world_count": 96 + } + }, + "development_seeds": [ + 600, + 601, + 602, + 603, + 604, + 605, + 606, + 607 + ], + "evaluation_seeds_run": false, + "m20_complement_relation_worlds": 16, + "m20_exact_expression_recovery": 80, + "m20_exact_relation_worlds": 72, + "m20_predictive_partition_recovery": 96, + "m20_receipts_all_valid": true, + "m20_world_count": 96, + "paired_development": { + "m20_minus_h8_aulc_ppm": { + "mean_delta": 180806, + "negative_worlds": 0, + "positive_worlds": 96, + "ties": 0, + "world_count": 96 + }, + "m20_minus_h8_balanced_accuracy_ppm": { + "mean_delta": 116292, + "negative_worlds": 0, + "positive_worlds": 96, + "ties": 0, + "world_count": 96 + }, + "m20_minus_oracle_aulc_ppm": { + "mean_delta": -57687, + "negative_worlds": 88, + "positive_worlds": 0, + "ties": 8, + "world_count": 96 + } + }, + "row_count": 384, + "rows": [ + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946646, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800928, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719493, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946646, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946646, + "best_constant_accuracy_ppm": 528645, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 83, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 946650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 471354, + "task": "CURRENT" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934309, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 101, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940858, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 928838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791843, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 274089, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932728, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704666, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934309, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 101, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940858, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 928838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934309, + "best_constant_accuracy_ppm": 524739, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940858, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 928838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475260, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949888, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957785, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811604, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 929417, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 684167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949888, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957785, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949888, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 77, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957785, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 937839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951328, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803432, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911412, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 705164, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951328, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951328, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 75, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 958108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949140, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962068, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800766, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287109, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949137, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949140, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962068, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949140, + "best_constant_accuracy_ppm": 519531, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 78, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962068, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 943361, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 480468, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954915, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 984312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815117, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293619, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949428, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693720, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954915, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 984312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954915, + "best_constant_accuracy_ppm": 516927, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 69, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 984312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 941681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516927, + "task": "CURRENT" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939488, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 797526, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796631, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 311, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 885048, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 686825, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939488, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939488, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 93, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 929843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947575, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805864, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 897801, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706244, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947575, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947575, + "best_constant_accuracy_ppm": 513020, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 80, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 947167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486979, + "task": "CURRENT" + }, + { + "accuracy_ppm": 518880, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493911, + "best_constant_accuracy_ppm": 529296, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 739, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 493648, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 530934, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805578, + "best_constant_accuracy_ppm": 529296, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283855, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913648, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719514, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950806, + "best_constant_accuracy_ppm": 529296, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949648, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942350, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 930825, + "best_constant_accuracy_ppm": 529296, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 401042, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949648, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866544, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470703, + "task": "LAG-1" + }, + { + "accuracy_ppm": 521484, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513120, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 735, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 494009, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 533579, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804832, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 286458, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924903, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711075, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948179, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945228, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 932868, + "best_constant_accuracy_ppm": 525390, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 407552, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945228, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877369, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 474609, + "task": "LAG-1" + }, + { + "accuracy_ppm": 503255, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502286, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 763, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 487644, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517918, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807851, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 909438, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692987, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948696, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934086, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947077, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 932382, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934086, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884450, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484578, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 486276, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797747, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283203, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 907329, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696103, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942251, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933644, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941769, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 926133, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 405599, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933644, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875543, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 493489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483924, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26693, + "final_window_accuracy_ppm": 539062, + "final_window_balanced_accuracy_ppm": 493370, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 480116, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798004, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283854, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936848, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687435, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949293, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949891, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938009, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933274, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949891, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875060, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-1" + }, + { + "accuracy_ppm": 520833, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 518500, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 736, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 511718, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512050, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 819010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 823527, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 278, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719016, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959088, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976562, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 942526, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 89, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976562, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886905, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 493489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491747, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 499264, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 492155, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805712, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 903921, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702489, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946603, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941421, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941180, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 931616, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941421, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878917, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 496744, + "task": "LAG-1" + }, + { + "accuracy_ppm": 496093, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493151, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 774, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 455847, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 529603, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806467, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710777, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947699, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434245, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933223, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961282, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890271, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 486328, + "task": "LAG-1" + }, + { + "accuracy_ppm": 531901, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505912, + "best_constant_accuracy_ppm": 529947, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 719, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1954, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 524916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 550559, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804768, + "best_constant_accuracy_ppm": 529947, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283204, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 725337, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948812, + "best_constant_accuracy_ppm": 529947, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927735, + "best_constant_accuracy_ppm": 529947, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 398438, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964916, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865404, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 470052, + "task": "LAG-4" + }, + { + "accuracy_ppm": 514973, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504841, + "best_constant_accuracy_ppm": 527343, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 745, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 513725, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515001, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800045, + "best_constant_accuracy_ppm": 527343, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 280599, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932107, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715904, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944673, + "best_constant_accuracy_ppm": 527343, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948774, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934252, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 928099, + "best_constant_accuracy_ppm": 527343, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 401042, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948774, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872221, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472656, + "task": "LAG-4" + }, + { + "accuracy_ppm": 514322, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513969, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 746, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 7812, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 460468, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 532265, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804625, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 901387, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695193, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944728, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933302, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945653, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 71 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 929168, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933302, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884204, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 509765, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496567, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 753, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10417, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 508968, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497755, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802753, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 927486, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695800, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943866, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953412, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 926232, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 406250, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953412, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482736, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 475245, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514174, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 816406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810631, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940517, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 724631, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953101, + "best_constant_accuracy_ppm": 520182, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957758, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952070, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 936719, + "best_constant_accuracy_ppm": 520182, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416666, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957758, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890491, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 479817, + "task": "LAG-4" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497354, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 508118, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 501725, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812512, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291666, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933741, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700337, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950595, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434244, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 930837, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414062, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960873, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868118, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 487630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485219, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 787, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 536097, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504070, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 800130, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798896, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 295573, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 896276, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702594, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938187, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 95, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925688, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929933, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 921892, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925688, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869818, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482033, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24739, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 493040, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 486137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 800130, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795840, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285808, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913674, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694508, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941953, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427735, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949389, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935554, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 922182, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 408204, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949389, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863446, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 485677, + "task": "LAG-4" + }, + { + "accuracy_ppm": 535807, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509067, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 713, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5209, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 508790, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 566866, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 814453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805797, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283855, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917520, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 733986, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950734, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946753, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 69 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 931477, + "best_constant_accuracy_ppm": 530598, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 401693, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879690, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 469401, + "task": "LAG-7" + }, + { + "accuracy_ppm": 513671, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489069, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 471226, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516594, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794513, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 274089, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909243, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708712, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941409, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 412761, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934036, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930402, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 920939, + "best_constant_accuracy_ppm": 527994, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 393229, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934036, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859272, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 472005, + "task": "LAG-7" + }, + { + "accuracy_ppm": 516276, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 515392, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 743, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 10417, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 515594, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 531908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805710, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 904232, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703746, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946637, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935700, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947530, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 927762, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935700, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879786, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 498046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 481657, + "best_constant_accuracy_ppm": 520833, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22787, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 509358, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795108, + "best_constant_accuracy_ppm": 520833, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938463, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697604, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943206, + "best_constant_accuracy_ppm": 520833, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960851, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940833, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 923940, + "best_constant_accuracy_ppm": 520833, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 402995, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960851, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 479166, + "task": "LAG-7" + }, + { + "accuracy_ppm": 509114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491502, + "best_constant_accuracy_ppm": 521484, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 546875, + "final_window_balanced_accuracy_ppm": 501263, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502498, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803490, + "best_constant_accuracy_ppm": 521484, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940394, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949748, + "best_constant_accuracy_ppm": 521484, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962133, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936830, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 930869, + "best_constant_accuracy_ppm": 521484, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 410156, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962133, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868994, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 478515, + "task": "LAG-7" + }, + { + "accuracy_ppm": 512369, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 510936, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 749, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2604, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 507812, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520971, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816148, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937500, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711406, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953948, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438803, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968750, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 933526, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968750, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866590, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 490885, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490504, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 491520, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502451, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 794270, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 792783, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 316, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 881603, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 937500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937520, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 96, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910529, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934032, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 917317, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 917261, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 127, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412109, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910529, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861094, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 507812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497234, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -8464, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 516916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510911, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803510, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292317, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948867, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942089, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 929436, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414062, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873494, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 483723, + "task": "LAG-7" + }, + { + "accuracy_ppm": 516276, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500567, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 743, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 490147, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 526709, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794067, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 274740, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 908251, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708398, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943998, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938423, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942901, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 924950, + "best_constant_accuracy_ppm": 526692, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 398438, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938423, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871573, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 473307, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506358, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5859, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503661, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811671, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 311197, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937190, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715910, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951175, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 450520, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972623, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943854, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 934897, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 434244, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972623, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877867, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 499348, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503972, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3255, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 465740, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 523576, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 815755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813749, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957077, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449870, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 940240, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 92, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945282, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889265, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 513671, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513846, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 12369, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 504237, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518925, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803107, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 910463, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944666, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941895, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929706, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883621, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487994, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 478879, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514390, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805696, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929274, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695855, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953723, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448568, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952699, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 936095, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886809, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 483723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484849, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 793, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24089, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 478044, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499731, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806918, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 932161, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709527, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946662, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944435, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927166, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867208, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 490885, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493955, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 524011, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 462087, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804995, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 908657, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685290, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941534, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 926825, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 925945, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929636, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 860711, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 507812, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485353, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 491881, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 506100, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809268, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921564, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946847, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956997, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938659, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930635, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956997, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878098, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 501953, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496264, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 765, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 421875, + "final_window_balanced_accuracy_ppm": 440709, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 527356, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805293, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 903550, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715842, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948622, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933179, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 929691, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933179, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879994, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 492838, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 499348, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 488029, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 769, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 504058, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487630, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798007, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 280599, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 910040, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706735, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944382, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935260, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 43 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 925985, + "best_constant_accuracy_ppm": 524088, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 401693, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861612, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 475911, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 512369, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496828, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 749, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -6511, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 496864, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519536, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813207, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 904660, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693983, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951224, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937034, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948686, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 931321, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 412760, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937034, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874364, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 518880, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 491536, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491345, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 781, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 493882, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499848, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804650, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926534, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944005, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945191, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942636, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 929083, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945191, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879159, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 490234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491476, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24088, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 457627, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 486571, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817234, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298829, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941967, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698242, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951411, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952836, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942961, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 931864, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952836, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868470, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 514322, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487078, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 505566, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 485730, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806493, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948189, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949826, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972779, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938332, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 928223, + "best_constant_accuracy_ppm": 511718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972779, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 849959, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 488281, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 510416, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502634, + "best_constant_accuracy_ppm": 518229, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 752, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 501588, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 495661, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807391, + "best_constant_accuracy_ppm": 518229, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 284505, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905669, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682616, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944954, + "best_constant_accuracy_ppm": 518229, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925830, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937655, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 41 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 930031, + "best_constant_accuracy_ppm": 518229, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 412109, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925830, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874916, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 518229, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 490885, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490909, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 497232, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 490784, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808795, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 901739, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708130, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951838, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451171, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949372, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 933625, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948502, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881200, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 500651, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 519531, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503239, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 738, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7161, + "final_window_accuracy_ppm": 550781, + "final_window_balanced_accuracy_ppm": 508004, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516232, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 812500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 819213, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285808, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 924137, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703091, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950239, + "best_constant_accuracy_ppm": 526692, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948667, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 43 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931609, + "best_constant_accuracy_ppm": 526692, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 405599, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956280, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873012, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 526692, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 483723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483588, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 793, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16928, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 456845, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 460993, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799649, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918054, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695478, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 935540, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 99, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434895, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925806, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 920014, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 918619, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 918620, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 125, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 417968, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925806, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 850121, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 500651, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 485677, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485981, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 790, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 457740, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 796223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798336, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 313, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 914381, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680395, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940184, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 927083, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 921496, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 414062, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937282, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 852864, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 513671, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513839, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 12369, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 527818, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512612, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804985, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304036, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937729, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692868, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944672, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 959468, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936541, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927745, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 959468, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 475911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 474857, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 805, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 468518, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493209, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 813802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815246, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699678, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949267, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444010, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935408, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931022, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964636, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867328, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 486979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487423, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 788, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20833, + "final_window_accuracy_ppm": 539062, + "final_window_balanced_accuracy_ppm": 494973, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497033, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 816406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814204, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 933641, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692986, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 955729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955738, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447917, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968424, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945185, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 936782, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968424, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870135, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 494791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497537, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 776, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 498390, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496711, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794769, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289063, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 871402, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704208, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938949, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 94, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430990, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911225, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938287, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 921194, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911225, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 492187, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495489, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 483946, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503461, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805906, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910302, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687359, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951046, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949062, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939498, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 936051, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949062, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877430, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 738281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506899, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 402, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 518320, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 755615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 881510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813306, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 182, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 115234, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 928768, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 838262, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951189, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 179687, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 966081, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936849, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 171 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 913584, + "best_constant_accuracy_ppm": 766276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 162109, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 966081, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884003, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 233723, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 742838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500321, + "best_constant_accuracy_ppm": 776041, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 395, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 734375, + "final_window_balanced_accuracy_ppm": 480842, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 734687, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 873697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 792472, + "best_constant_accuracy_ppm": 776041, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 194, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 97656, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 929118, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 822887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940728, + "best_constant_accuracy_ppm": 776041, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 164063, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 929118, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930717, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 131 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 899611, + "best_constant_accuracy_ppm": 776041, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 145182, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 929118, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872840, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 223958, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 716145, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501514, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 436, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22787, + "final_window_accuracy_ppm": 660156, + "final_window_balanced_accuracy_ppm": 491417, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 716220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 871093, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798272, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 198, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 132161, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 902810, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 813721, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 935429, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203776, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928126, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940136, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 117 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 899636, + "best_constant_accuracy_ppm": 738932, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 184245, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928126, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879667, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 737630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496429, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 403, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 492375, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 735079, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 876302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798986, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 190, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 105469, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 925708, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 823049, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942451, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 171224, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 952375, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942966, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 84 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 905098, + "best_constant_accuracy_ppm": 770833, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 153646, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 952375, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881797, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 229166, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 736979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489832, + "best_constant_accuracy_ppm": 767578, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 404, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 761718, + "final_window_balanced_accuracy_ppm": 503025, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 737040, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 884765, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807759, + "best_constant_accuracy_ppm": 767578, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 177, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 117187, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 947469, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 836206, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952016, + "best_constant_accuracy_ppm": 767578, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 184244, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 956728, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943658, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 151 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 917002, + "best_constant_accuracy_ppm": 767578, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 167968, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 956728, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 894815, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 232421, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 721354, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508152, + "best_constant_accuracy_ppm": 737630, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 428, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 753906, + "final_window_balanced_accuracy_ppm": 499564, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715489, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 887369, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 824529, + "best_constant_accuracy_ppm": 737630, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 173, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 149739, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 947840, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 829243, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 957682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958524, + "best_constant_accuracy_ppm": 737630, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 65, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 220052, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 982323, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950805, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [ + 102 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 926266, + "best_constant_accuracy_ppm": 737630, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 203125, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 982323, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 894839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 262369, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 723307, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495524, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 425, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -34505, + "final_window_accuracy_ppm": 773437, + "final_window_balanced_accuracy_ppm": 524038, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 727574, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 871744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801975, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 197, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 113932, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 878204, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 828055, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945793, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 183594, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 930288, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 124 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 907729, + "best_constant_accuracy_ppm": 757812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 164714, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 930288, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882365, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 739583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490435, + "best_constant_accuracy_ppm": 769531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 400, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29948, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 485201, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 739659, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 880859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796932, + "best_constant_accuracy_ppm": 769531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 183, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 111328, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 928749, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 829513, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946649, + "best_constant_accuracy_ppm": 769531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 180338, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 961007, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947799, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 104 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 911339, + "best_constant_accuracy_ppm": 769531, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 164062, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 961007, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 894125, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 230468, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 693359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500704, + "best_constant_accuracy_ppm": 716145, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 471, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22786, + "final_window_accuracy_ppm": 726562, + "final_window_balanced_accuracy_ppm": 492556, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 652189, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 746744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810721, + "best_constant_accuracy_ppm": 716145, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 389, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 30599, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 919195, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 615886, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 955729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956630, + "best_constant_accuracy_ppm": 716145, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 239584, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952172, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 930533, + "best_constant_accuracy_ppm": 716145, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 220052, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952873, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876893, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 716145, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 694661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509268, + "best_constant_accuracy_ppm": 710937, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 469, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 498537, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701866, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 738932, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797012, + "best_constant_accuracy_ppm": 710937, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 401, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27995, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 911549, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 598372, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943532, + "best_constant_accuracy_ppm": 710937, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 236328, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 939327, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938802, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 95 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 927271, + "best_constant_accuracy_ppm": 710937, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 224609, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 939327, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895148, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 710937, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 741536, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506119, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 397, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 796875, + "final_window_balanced_accuracy_ppm": 508147, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 743608, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809679, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 886577, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 570886, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949866, + "best_constant_accuracy_ppm": 766276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 183593, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 917238, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948024, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 113 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 915708, + "best_constant_accuracy_ppm": 766276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 165364, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 917238, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886514, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 766276, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 708333, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503972, + "best_constant_accuracy_ppm": 731770, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 448, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23437, + "final_window_accuracy_ppm": 773437, + "final_window_balanced_accuracy_ppm": 525554, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794431, + "best_constant_accuracy_ppm": 731770, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 412, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 0, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 942017, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 566644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938559, + "best_constant_accuracy_ppm": 731770, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 210938, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961917, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 110 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 908747, + "best_constant_accuracy_ppm": 731770, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 192058, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961917, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874462, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 731770, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 708333, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499217, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 448, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 691406, + "final_window_balanced_accuracy_ppm": 485204, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801843, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1302, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 927234, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 572901, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944195, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 208333, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 943538, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932340, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 73 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 915175, + "best_constant_accuracy_ppm": 736328, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 190104, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 943538, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866519, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 736328, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 728515, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497038, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 417, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 730468, + "final_window_balanced_accuracy_ppm": 513977, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689899, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 734375, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809440, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 408, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25390, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 932637, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 575752, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951257, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 190104, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 961738, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 80 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 921228, + "best_constant_accuracy_ppm": 759765, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 171224, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 961738, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859656, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 759765, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 733723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513935, + "best_constant_accuracy_ppm": 754557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 409, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20834, + "final_window_accuracy_ppm": 683593, + "final_window_balanced_accuracy_ppm": 504826, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 726436, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 729817, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796804, + "best_constant_accuracy_ppm": 754557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 415, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 899019, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 571095, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937874, + "best_constant_accuracy_ppm": 754557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 188151, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 923744, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 107 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 910087, + "best_constant_accuracy_ppm": 754557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 171875, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 923744, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 754557, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 705729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505996, + "best_constant_accuracy_ppm": 735026, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 452, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 474226, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707959, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 732421, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806981, + "best_constant_accuracy_ppm": 735026, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 411, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2605, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 913950, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 574326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953128, + "best_constant_accuracy_ppm": 735026, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 212239, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950032, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940355, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 106 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 933414, + "best_constant_accuracy_ppm": 735026, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 195963, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950032, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881770, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 735026, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 481119, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 480078, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 797, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 521217, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491373, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796598, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290365, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 915967, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696117, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936996, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942994, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 917968, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 918033, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 126, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942994, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861346, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 491536, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503841, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 492551, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 527327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804992, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304036, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945420, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699897, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945332, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444010, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 929686, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870689, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 493489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487326, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 493162, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 488276, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804304, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917765, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694000, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946591, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945543, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934445, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 926997, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945543, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 857188, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490935, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503906, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507616, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798758, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285156, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933593, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698334, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940842, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949218, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 926696, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 407552, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949218, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872735, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 481119, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485452, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 460937, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 483664, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810477, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933593, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681856, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951852, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 936860, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 434895, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882511, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505579, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 499510, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 522862, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 817708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818581, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 314453, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940248, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714953, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 955729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955709, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 452474, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972506, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955379, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 936909, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972506, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882824, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 503255, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 503255, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503253, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 763, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1953, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 476679, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 794921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795291, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 315, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293619, + "final_window_accuracy_ppm": 878906, + "final_window_balanced_accuracy_ppm": 880402, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685599, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940096, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925514, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929571, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 925117, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925514, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 490234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484144, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20833, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 508424, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 460635, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805244, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291016, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910561, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681745, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946009, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952868, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931405, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927278, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416016, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952868, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856445, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 511067, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 846354, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514555, + "best_constant_accuracy_ppm": 888671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 236, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42317, + "final_window_accuracy_ppm": 832031, + "final_window_balanced_accuracy_ppm": 529993, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 862870, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910807, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804028, + "best_constant_accuracy_ppm": 888671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 137, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 22136, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 915707, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 896686, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950227, + "best_constant_accuracy_ppm": 888671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 54688, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 972850, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937957, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 435 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 874204, + "best_constant_accuracy_ppm": 888671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 37761, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 972850, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 904318, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 111328, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 849609, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513336, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 231, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42318, + "final_window_accuracy_ppm": 855468, + "final_window_balanced_accuracy_ppm": 494501, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 837891, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910807, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796468, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 137, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 18880, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 920426, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 882464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944059, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 50781, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 920426, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933097, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 197 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 865745, + "best_constant_accuracy_ppm": 891927, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 33854, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 920426, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889362, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 837239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511229, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31901, + "final_window_accuracy_ppm": 761718, + "final_window_balanced_accuracy_ppm": 497704, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831914, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 914062, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804762, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 132, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 44922, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 919272, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 883120, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 931627, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938880, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940202, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 231 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 869438, + "best_constant_accuracy_ppm": 869140, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938880, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 898206, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 837890, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487505, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 249, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -48828, + "final_window_accuracy_ppm": 824218, + "final_window_balanced_accuracy_ppm": 487678, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831320, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 906250, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 789229, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 144, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 19532, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 943560, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 874294, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938654, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 53386, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 958266, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938227, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919921, + "arena_version": "v0.3", + "authorization_events": [ + 219 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 854587, + "best_constant_accuracy_ppm": 886718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 123, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 33203, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 958266, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883963, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 852864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485749, + "best_constant_accuracy_ppm": 892578, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 226, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 494025, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 859223, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797871, + "best_constant_accuracy_ppm": 892578, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 123, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27343, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 914025, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 900363, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952416, + "best_constant_accuracy_ppm": 892578, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 60547, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 934025, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 293 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 867203, + "best_constant_accuracy_ppm": 892578, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 41666, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 934025, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 908857, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 107421, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 827473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504671, + "best_constant_accuracy_ppm": 859375, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 265, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31902, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 499619, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 820835, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 918619, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 828745, + "best_constant_accuracy_ppm": 859375, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 125, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 59244, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965137, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 887786, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958374, + "best_constant_accuracy_ppm": 859375, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 95703, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 982378, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947762, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 178 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 892424, + "best_constant_accuracy_ppm": 859375, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 75520, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 982378, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 893806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 140625, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 826822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497630, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 266, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -46224, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 500559, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 843889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 906901, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813015, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 143, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 33855, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 935342, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 892193, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948912, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 68360, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 935342, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 225 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 881873, + "best_constant_accuracy_ppm": 873046, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 50782, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 935342, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 901006, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 858072, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499551, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 218, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33855, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 519813, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 843675, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919270, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 782683, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 124, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27343, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 928903, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 891625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942322, + "best_constant_accuracy_ppm": 891927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 951631, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949501, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [ + 183 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 870033, + "best_constant_accuracy_ppm": 891927, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 46224, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 951631, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 904771, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 108072, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497954, + "best_constant_accuracy_ppm": 844401, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35157, + "final_window_accuracy_ppm": 820312, + "final_window_balanced_accuracy_ppm": 504903, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 782887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 707682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804722, + "best_constant_accuracy_ppm": 844401, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 449, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -136719, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 931879, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 542209, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949672, + "best_constant_accuracy_ppm": 844401, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 108072, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 966441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946310, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 94 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 900178, + "best_constant_accuracy_ppm": 844401, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 87890, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 966441, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877074, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 600, + "target_prevalence_ppm": 844401, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502061, + "best_constant_accuracy_ppm": 845052, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37110, + "final_window_accuracy_ppm": 832031, + "final_window_balanced_accuracy_ppm": 517970, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 783503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 708984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808939, + "best_constant_accuracy_ppm": 845052, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 447, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -136068, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 909631, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 553821, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950696, + "best_constant_accuracy_ppm": 845052, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 103515, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 932255, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 113 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 908854, + "best_constant_accuracy_ppm": 845052, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 87890, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 932255, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886850, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 601, + "target_prevalence_ppm": 845052, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 843098, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501403, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 241, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -40365, + "final_window_accuracy_ppm": 851562, + "final_window_balanced_accuracy_ppm": 509398, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 849515, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806842, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 465, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -186198, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 875939, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499787, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948699, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 64453, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 902255, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947397, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 255 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 877024, + "best_constant_accuracy_ppm": 883463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 44922, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 902255, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 899425, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 602, + "target_prevalence_ppm": 883463, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493981, + "best_constant_accuracy_ppm": 843750, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -41667, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 497085, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 796309, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791743, + "best_constant_accuracy_ppm": 843750, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 465, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -146485, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 903262, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936419, + "best_constant_accuracy_ppm": 843750, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 97656, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 928903, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935761, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 206 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 891126, + "best_constant_accuracy_ppm": 843750, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 81380, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 928903, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889741, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 603, + "target_prevalence_ppm": 843750, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 830078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507475, + "best_constant_accuracy_ppm": 867838, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 261, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37760, + "final_window_accuracy_ppm": 808593, + "final_window_balanced_accuracy_ppm": 493212, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 835245, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 699218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797474, + "best_constant_accuracy_ppm": 867838, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 462, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -168620, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 917333, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514992, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938885, + "best_constant_accuracy_ppm": 867838, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 76823, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 933688, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937925, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 883197, + "best_constant_accuracy_ppm": 867838, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 59896, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 933688, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890834, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 604, + "target_prevalence_ppm": 867838, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 837239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505019, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -38412, + "final_window_accuracy_ppm": 851562, + "final_window_balanced_accuracy_ppm": 513392, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 819983, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797938, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 465, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -178386, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 919642, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502413, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941061, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 72265, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 950892, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937663, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 154 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 880495, + "best_constant_accuracy_ppm": 875651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 52734, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 950892, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874750, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 605, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 829427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 518053, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 262, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35807, + "final_window_accuracy_ppm": 824218, + "final_window_balanced_accuracy_ppm": 549130, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 818633, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 695963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793715, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 467, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -169271, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 924915, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511705, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936679, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 957025, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934132, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 192 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 884450, + "best_constant_accuracy_ppm": 865234, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 957025, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887053, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 606, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 820312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513325, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 276, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42318, + "final_window_accuracy_ppm": 843750, + "final_window_balanced_accuracy_ppm": 477876, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 799250, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 699869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816076, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 461, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -162761, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 923598, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517652, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959094, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 83984, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 961209, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935967, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 169 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 920531, + "best_constant_accuracy_ppm": 862630, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 69010, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 961209, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883133, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 607, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + } + ], + "status": "DEVELOPMENT_ONLY", + "task_count": 12 +} diff --git a/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.sha256 b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.sha256 new file mode 100644 index 0000000..76b3ba9 --- /dev/null +++ b/experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.sha256 @@ -0,0 +1 @@ +79e1442d898d263948e9c4fc60c709681a1a5a06cfdb70b6c2442609980f5941 experiments/prime_m20_universal_arena/DEVELOPMENT_V0_3_RESULT.json diff --git a/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.md b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.md new file mode 100644 index 0000000..78a16d9 --- /dev/null +++ b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.md @@ -0,0 +1,157 @@ +# PRIME M20 Universal Adaptive-State Arena v0.2 +## Frozen Held-Out Evaluation Plan + +Status: + + FROZEN BEFORE HELD-OUT EXECUTION + +Held-out seeds: + + 6000..6031 inclusive + +Task families: + + 12 + +Paired task/seed worlds: + + 384 + +Conditions: + + REACTIVE + FIXED-H8 + ORACLE-FEATURE + M20-CONSTRUCTION + +Total condition-world rows: + + 1536 + +--- + +# Primary held-out comparison + +For every task/seed world i: + + D_i = + AULC(M20-CONSTRUCTION, i) + - + AULC(FIXED-H8, i) + +Primary claim: + + M20-CONSTRUCTION improves online learning efficiency over FIXED-H8. + +SUPPORTED iff all are true: + +1. observed paired mean D_i > 0; +2. frozen deterministic paired-bootstrap lower bound > 0; +3. mean final-window accuracy delta >= 0; +4. mean final-window balanced-accuracy delta >= 0; +5. predictive-partition recovery = 384/384; +6. CURRENT unnecessary-construction count = 0/32; +7. all M20 receipt chains verify; +8. all integrity checks pass. + +Otherwise: + + NOT SUPPORTED + +--- + +# Predictive representation recovery + +Exact-expression recovery is reported. + +Predictive-partition recovery is also reported. + +For binary constructed features, exact complement: + + q(h) = 1 - f(h) + +counts as the same predictive partition because both induce the same two-cell +partition of the history space. + +This equivalence rule was frozen before v0.2 development. + +--- + +# Oracle comparison + +M20-CONSTRUCTION versus ORACLE-FEATURE is diagnostic. + +Report: + +- paired AULC delta; +- final-window accuracy delta; +- final-window balanced-accuracy delta. + +No superiority claim against the oracle is preregistered. + +The oracle comparison primarily measures remaining construction/authorization +latency. + +--- + +# Deterministic paired bootstrap + +Replicates: + + 16384 + +Paired sample size: + + 384 + +Sampling: + + with replacement + +Seed: + + 0x4D32305630324556 + +For bootstrap replicate r and draw j: + + index = + splitmix64( + seed + XOR splitmix64(r) + XOR splitmix64(j) + ) + mod 384 + +Store sampled SUMS. + +Sort the 16384 sums. + +Frozen interval indices: + + lower = 409 + upper = 15974 + +The lower confidence bound is positive iff: + + sorted_sums[409] > 0 + +No alternative interval or test may be selected after evaluation. + +--- + +# Claim boundary + +A supported result would establish controlled held-out evidence that the frozen +M20 construction architecture achieves better online learning efficiency than +the frozen raw H8 representation on this arena while recovering the required +predictive representation class. + +It would not establish: + +- AGI; +- universal representation learning; +- superiority over recurrent learned state; +- universal POMDP superiority; +- broad real-world generality. + +A separately frozen recurrent-memory confrontation remains required. diff --git a/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.sha256 b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.sha256 new file mode 100644 index 0000000..7461135 --- /dev/null +++ b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.sha256 @@ -0,0 +1 @@ +609032c0f1b64aedca9ab3b4b66e226b18528694f91275eeb5ca349dd9d4a77e experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_2.md diff --git a/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.md b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.md new file mode 100644 index 0000000..870c710 --- /dev/null +++ b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.md @@ -0,0 +1,204 @@ +# PRIME M20 Universal Adaptive-State Arena v0.3 +## Frozen Held-Out Evaluation Plan + +Status: + + FROZEN BEFORE HELD-OUT EXECUTION + +Held-out stream seeds: + + 6000..6031 inclusive + +Number of independent stream-seed clusters: + + 32 + +Tasks per seed: + + 12 + +Paired task/seed worlds: + + 384 + +Conditions: + + REACTIVE + FIXED-H8 + ORACLE-FEATURE + M20-CONSTRUCTION + +Total rows: + + 1536 + +No held-out seed had been executed when this plan was frozen. + +--- + +# Primary comparison + +For task t and stream seed s: + + D(s,t) = + AULC(M20-CONSTRUCTION,s,t) + - + AULC(FIXED-H8,s,t) + +Overall observed effect: + + mean over all 384 paired task/seed worlds. + +--- + +# Dependence structure + +All 12 tasks belonging to the same stream seed reuse the same underlying +binary observation stream. + +Therefore task/seed worlds sharing a seed are not treated as independent +bootstrap sampling units. + +The bootstrap resamples the 32 stream seeds as clusters. + +Whenever seed s is sampled, all 12 paired task differences D(s,t) are included. + +This preserves within-stream dependence across task families. + +--- + +# Deterministic cluster bootstrap + +Bootstrap replicates: + + 16384 + +Cluster count: + + 32 + +Tasks per cluster: + + 12 + +Sampling: + + 32 stream-seed clusters with replacement per replicate + +Bootstrap RNG seed: + + 0x4D3230563033434C + +For replicate r and draw j: + + index = + splitmix64( + BOOTSTRAP_SEED + XOR splitmix64(r) + XOR splitmix64(j) + ) + mod 32 + +For every selected cluster, include all 12 task differences. + +Sort the 16384 bootstrap mean differences. + +Frozen interval indices: + + lower = 409 + upper = 15974 + +No alternate confidence interval or inferential test may be selected after +held-out evaluation. + +--- + +# Primary claim + +Claim: + + Frozen PRIME M20 v0.3 improves online learning efficiency over FIXED-H8 + on the held-out Universal Adaptive-State Arena. + +SUPPORTED iff ALL of the following hold: + +1. observed mean M20-H8 AULC delta > 0; + +2. deterministic seed-cluster bootstrap lower bound > 0; + +3. mean final-window accuracy delta M20-H8 >= 0; + +4. mean final-window balanced-accuracy delta M20-H8 >= 0; + +5. predictive-partition recovery = 384/384; + +6. all 32 CURRENT worlds authorize zero unnecessary constructions; + +7. every M20 receipt chain verifies; + +8. row/seed/task/condition integrity checks all pass. + +Otherwise: + + NOT SUPPORTED + +--- + +# Secondary descriptive results + +Report without changing the primary decision rule: + + exact-expression recovery; + + exact versus complement quotient relations; + + task-family AULC; + + authorization latency; + + number of M20-H8 positive/tied/negative task-seed worlds; + + M20-ORACLE AULC gap; + + M20-ORACLE final-window gap; + + target prevalence and balanced accuracy; + + active construction counts. + +--- + +# Oracle interpretation + +ORACLE-FEATURE receives the correct predictive representation immediately. + +M20-versus-ORACLE therefore measures the cost of online construction and +authorization. + +No superiority claim against ORACLE-FEATURE is preregistered. + +--- + +# Claim boundary + +A SUPPORTED result would establish controlled held-out evidence that the frozen +M20 v0.3 architecture learns more efficiently than a frozen raw H8 state on +this arena while recovering the required predictive representation class under +a globally alpha-spent verifier. + +It would NOT establish: + + AGI; + + universal representation learning; + + superiority on arbitrary POMDPs; + + superiority over learned recurrent state; + + language understanding; + + real-world generality. + +A recurrent-memory confrontation and transfer experiments remain separate +future tests. diff --git a/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.sha256 b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.sha256 new file mode 100644 index 0000000..c62c781 --- /dev/null +++ b/experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.sha256 @@ -0,0 +1 @@ +fc1965bb7a33206ea47abf250d54a2194b8aa389154cc5b16b93f6f00b73b5c0 experiments/prime_m20_universal_arena/EVALUATION_PLAN_V0_3.md diff --git a/experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.json b/experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.json new file mode 100644 index 0000000..4d70512 --- /dev/null +++ b/experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.json @@ -0,0 +1,45288 @@ +{ + "benchmark": "prime-m20-universal-arena-v0.3", + "by_task": [ + { + "exact_recovery": 32, + "mean_first_authorization_event": null, + "mean_m20_minus_h8_aulc_ppm": 250014, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "CURRENT", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 54, + "mean_m20_minus_h8_aulc_ppm": 177004, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "LAG-1", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 59, + "mean_m20_minus_h8_aulc_ppm": 174557, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "LAG-4", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 62, + "mean_m20_minus_h8_aulc_ppm": 168544, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "LAG-7", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 54, + "mean_m20_minus_h8_aulc_ppm": 175572, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "XOR-1-4", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 0, + "mean_first_authorization_event": 54, + "mean_m20_minus_h8_aulc_ppm": 169126, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "XOR-2-7", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 0, + "mean_first_authorization_event": 52, + "mean_m20_minus_h8_aulc_ppm": 171445, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "EQ-1-4", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 113, + "mean_m20_minus_h8_aulc_ppm": 61707, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "AND-1-4", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 89, + "mean_m20_minus_h8_aulc_ppm": 299504, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "OR-2-7", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 56, + "mean_m20_minus_h8_aulc_ppm": 178705, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "XOR-1-2-3", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 235, + "mean_m20_minus_h8_aulc_ppm": 11411, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "AND-1-2-4", + "ties": 0, + "world_count": 32 + }, + { + "exact_recovery": 32, + "mean_first_authorization_event": 193, + "mean_m20_minus_h8_aulc_ppm": 379251, + "negative_worlds": 0, + "positive_worlds": 32, + "predictive_recovery": 32, + "task": "OR-2-3-4", + "ties": 0, + "world_count": 32 + } + ], + "claim_gates": { + "cluster_bootstrap_lower_positive": true, + "current_no_unnecessary_construction": true, + "final_accuracy_noninferior": true, + "final_balanced_accuracy_noninferior": true, + "observed_mean_positive": true, + "predictive_partition_recovery_complete": true, + "receipt_integrity": true, + "row_integrity": true + }, + "claim_supported": true, + "condition_summaries": { + "FIXED-H8": { + "mean_accuracy_ppm": 806151, + "mean_balanced_accuracy_ppm": 806049, + "mean_cumulative_mistakes": 297, + "mean_final_window_accuracy_ppm": 921254, + "mean_final_window_balanced_accuracy_ppm": 921318, + "mean_primary_aulc_ppm": 699044, + "world_count": 384 + }, + "M20-CONSTRUCTION": { + "mean_accuracy_ppm": 931641, + "mean_balanced_accuracy_ppm": 921171, + "mean_cumulative_mistakes": 104, + "mean_final_window_accuracy_ppm": 948414, + "mean_final_window_balanced_accuracy_ppm": 948443, + "mean_primary_aulc_ppm": 883781, + "world_count": 384 + }, + "ORACLE-FEATURE": { + "mean_accuracy_ppm": 948255, + "mean_balanced_accuracy_ppm": 947869, + "mean_cumulative_mistakes": 79, + "mean_final_window_accuracy_ppm": 948414, + "mean_final_window_balanced_accuracy_ppm": 948443, + "mean_primary_aulc_ppm": 943999, + "world_count": 384 + }, + "REACTIVE": { + "mean_accuracy_ppm": 630755, + "mean_balanced_accuracy_ppm": 535381, + "mean_cumulative_mistakes": 567, + "mean_final_window_accuracy_ppm": 630604, + "mean_final_window_balanced_accuracy_ppm": 534406, + "mean_primary_aulc_ppm": 631148, + "world_count": 384 + } + }, + "development_seeds_run": false, + "evaluation_seeds": [ + 6000, + 6001, + 6002, + 6003, + 6004, + 6005, + 6006, + 6007, + 6008, + 6009, + 6010, + 6011, + 6012, + 6013, + 6014, + 6015, + 6016, + 6017, + 6018, + 6019, + 6020, + 6021, + 6022, + 6023, + 6024, + 6025, + 6026, + 6027, + 6028, + 6029, + 6030, + 6031 + ], + "integrity": { + "receipt_chains_valid": true, + "unique_complete_row_set": true, + "v03_global_alpha_flags_valid": true + }, + "oracle_diagnostic": { + "mean_m20_minus_oracle_aulc_ppm": -60218 + }, + "paired_world_count": 384, + "primary": { + "cluster_bootstrap": { + "bootstrap_seed": 5562561636489970508, + "cluster_count": 32, + "lower_index": 409, + "lower_ppm": 181945, + "method": "deterministic-seed-cluster-bootstrap", + "replicates": 16384, + "tasks_per_cluster": 12, + "upper_index": 15974, + "upper_ppm": 187493 + }, + "comparison": "M20-CONSTRUCTION minus FIXED-H8", + "mean_final_window_accuracy_delta_ppm": 27160, + "mean_final_window_balanced_accuracy_delta_ppm": 27125, + "negative_worlds": 0, + "observed_mean_aulc_delta_ppm": 184737, + "positive_worlds": 384, + "ties": 0 + }, + "representation": { + "complement_relation_worlds": 64, + "current_unnecessary_construction_count": 0, + "current_world_count": 32, + "exact_recovery": 320, + "exact_relation_worlds": 288, + "predictive_partition_recovery": 384 + }, + "row_count": 1536, + "rows": [ + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953509, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 947796, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "CURRENT" + }, + { + "accuracy_ppm": 814453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803859, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 933090, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707467, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953509, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 947796, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953509, + "best_constant_accuracy_ppm": 534505, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 71, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 947796, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 947913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951821, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932878, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959985, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807377, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305989, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918385, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700100, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951821, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932878, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959985, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951821, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 74, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932878, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 959985, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949122, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941321, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809147, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941452, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 683883, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949122, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941321, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949122, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 78, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 432942, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 941321, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941463, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932283, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 493489, + "task": "CURRENT" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803600, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 916543, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681500, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 493489, + "task": "CURRENT" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941463, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932283, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 493489, + "task": "CURRENT" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941463, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 90, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 932283, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 493489, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940755, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 926737, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 794270, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794270, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 316, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294270, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910156, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 677138, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940755, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 926737, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940755, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 926737, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949744, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "CURRENT" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801941, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 891857, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710621, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949744, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "CURRENT" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949744, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 77, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 949944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940040, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428386, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933895, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 924099, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 488281, + "task": "CURRENT" + }, + { + "accuracy_ppm": 800130, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796707, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288412, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911167, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 488281, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940040, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428386, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933895, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 924099, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 488281, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940040, + "best_constant_accuracy_ppm": 511718, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 92, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428386, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933895, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 924099, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 488281, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950520, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 450520, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807291, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307291, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938169, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699207, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950520, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 450520, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950520, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 76, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 450520, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 948220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 500000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952594, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960819, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956369, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "CURRENT" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811949, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305989, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934894, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "CURRENT" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952594, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960819, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956369, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "CURRENT" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952594, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 73, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960819, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 956369, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "CURRENT" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936893, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922099, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937035, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505859, + "task": "CURRENT" + }, + { + "accuracy_ppm": 791666, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793392, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 320, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285807, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 874480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685471, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505859, + "task": "CURRENT" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936893, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922099, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937035, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505859, + "task": "CURRENT" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936893, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922099, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 937035, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505859, + "task": "CURRENT" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942058, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929682, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951154, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "CURRENT" + }, + { + "accuracy_ppm": 795572, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796521, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 314, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292317, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 914178, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "CURRENT" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942058, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929682, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951154, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "CURRENT" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942058, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 89, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929682, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 951154, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945490, + "best_constant_accuracy_ppm": 538411, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942982, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "CURRENT" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816711, + "best_constant_accuracy_ppm": 538411, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 268229, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934905, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696716, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945490, + "best_constant_accuracy_ppm": 538411, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942982, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "CURRENT" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945490, + "best_constant_accuracy_ppm": 538411, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 84, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 942982, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "CURRENT" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942596, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935376, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798637, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290365, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 920916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682126, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942596, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935376, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942596, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 88, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 935376, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 931621, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 105, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 917158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "CURRENT" + }, + { + "accuracy_ppm": 789062, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 789413, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 324, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287760, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921395, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 653882, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "CURRENT" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 931621, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 105, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 917158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "CURRENT" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 931621, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935887, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 917158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953150, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933033, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952547, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805335, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 912708, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 678660, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953150, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933033, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952547, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953150, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 72, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933033, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 952547, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947865, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960819, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942036, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "CURRENT" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807082, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287109, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931190, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 684382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947865, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960819, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942036, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947865, + "best_constant_accuracy_ppm": 515625, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 80, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960819, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 942036, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "CURRENT" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948803, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925781, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "CURRENT" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811047, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910156, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700128, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "CURRENT" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948803, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925781, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "CURRENT" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948803, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 79, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925781, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 950464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "CURRENT" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952588, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922590, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950733, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 813802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811341, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304688, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 889744, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704756, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952588, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922590, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950733, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952588, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 73, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922590, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 950733, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958888, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444011, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957058, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 813802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817927, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298829, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 925069, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706166, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958888, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444011, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957058, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958888, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 63, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 444011, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956983, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 957058, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955098, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949046, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954101, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "CURRENT" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808078, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918743, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704611, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955098, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949046, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954101, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "CURRENT" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955098, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 69, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949046, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 954101, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "CURRENT" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948566, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968808, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500651, + "task": "CURRENT" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812025, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 311197, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710000, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500651, + "task": "CURRENT" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948566, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968808, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500651, + "task": "CURRENT" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948566, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 79, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968808, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 943807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500651, + "task": "CURRENT" + }, + { + "accuracy_ppm": 961588, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 961503, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 59, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956812, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 961751, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "CURRENT" + }, + { + "accuracy_ppm": 818359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815227, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 279, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307943, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928357, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 718524, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "CURRENT" + }, + { + "accuracy_ppm": 961588, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 961503, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 59, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956812, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 961751, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "CURRENT" + }, + { + "accuracy_ppm": 961588, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 961503, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 59, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956812, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 961751, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "CURRENT" + }, + { + "accuracy_ppm": 962239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 962084, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 58, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 453125, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953182, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959981, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 819010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816195, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 278, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309896, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905938, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 712700, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 962239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 962084, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 58, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 453125, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953182, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959981, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 962239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 962084, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 58, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 453125, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953182, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 959981, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950484, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937058, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 814453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816681, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305990, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930762, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685280, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950484, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937058, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950484, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 76, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 937058, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "CURRENT" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943294, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938557, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507812, + "task": "CURRENT" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806755, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917079, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 679085, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507812, + "task": "CURRENT" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943294, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938557, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507812, + "task": "CURRENT" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943294, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 87, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 938557, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507812, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940863, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928152, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941173, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 507161, + "task": "CURRENT" + }, + { + "accuracy_ppm": 796223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798373, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 313, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910422, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 683203, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 507161, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940863, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928152, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941173, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 507161, + "task": "CURRENT" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940863, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928152, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 941173, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 507161, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953103, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956366, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808005, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 306640, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928366, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 690792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953103, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956366, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953103, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 72, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956366, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 948560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951225, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953078, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952627, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810896, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291667, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 915199, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701148, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951225, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953078, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952627, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951225, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 75, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953078, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 952627, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957030, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 455078, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 817057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817600, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 281, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 315104, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910381, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 716790, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957030, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 455078, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957030, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 66, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 455078, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 950650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946600, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945581, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809147, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938387, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 679258, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946600, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945581, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946600, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 82, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945581, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 929760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947915, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945558, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948071, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802001, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919439, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696523, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947915, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945558, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948071, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947915, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 80, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945558, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 948071, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950632, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 935466, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951231, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814728, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 295573, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 917480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950632, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 935466, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951231, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950632, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 0, + "alpha_denominator": 128, + "candidate_count": 256, + "composed_candidate_count": 0, + "epoch": 0, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 136, + "threshold": 32768 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 76, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 935466, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 951231, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "CURRENT" + }, + { + "accuracy_ppm": 522786, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492649, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 733, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -11719, + "final_window_accuracy_ppm": 597656, + "final_window_balanced_accuracy_ppm": 501718, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 492159, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-1" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799505, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 275390, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 947796, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697991, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-1" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948456, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 414062, + "final_window_accuracy_ppm": 980468, + "final_window_balanced_accuracy_ppm": 982110, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930815, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-1" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 38 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 932305, + "best_constant_accuracy_ppm": 534505, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 398437, + "final_window_accuracy_ppm": 980468, + "final_window_balanced_accuracy_ppm": 982110, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 862052, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-1" + }, + { + "accuracy_ppm": 473307, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 473662, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 809, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 453125, + "final_window_balanced_accuracy_ppm": 464208, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 474646, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 497395, + "task": "LAG-1" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796116, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930442, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680704, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 497395, + "task": "LAG-1" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941404, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948690, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940474, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 497395, + "task": "LAG-1" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 924429, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948690, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872687, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 497395, + "task": "LAG-1" + }, + { + "accuracy_ppm": 507161, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503477, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 757, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 507386, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497153, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 815755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 820120, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 957682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957573, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 65, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955638, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 939367, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 93, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880406, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491884, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 518115, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513515, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492838, + "task": "LAG-1" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794948, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289714, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 904445, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687018, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492838, + "task": "LAG-1" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936956, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 955293, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932426, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492838, + "task": "LAG-1" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 920649, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 955293, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871215, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492838, + "task": "LAG-1" + }, + { + "accuracy_ppm": 505208, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505166, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 760, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 492278, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503733, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805154, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304687, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 902062, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706712, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945962, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445312, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953243, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946558, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 929021, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953243, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872511, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 496093, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486907, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 774, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 465928, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508398, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800580, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292969, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 916136, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710704, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949715, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953021, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948918, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 930666, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953021, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871950, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495345, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5859, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 494990, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 536960, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 487630, + "task": "LAG-1" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804424, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 295573, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934383, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714998, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 487630, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942608, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430339, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957111, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931078, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 487630, + "task": "LAG-1" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 925284, + "best_constant_accuracy_ppm": 512369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413412, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957111, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 487630, + "task": "LAG-1" + }, + { + "accuracy_ppm": 471354, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 471190, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 812, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 437500, + "final_window_balanced_accuracy_ppm": 452953, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491293, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803196, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930333, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695196, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951175, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 450520, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956259, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949863, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 934237, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956259, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 499348, + "task": "LAG-1" + }, + { + "accuracy_ppm": 494791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496347, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 776, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 472656, + "final_window_balanced_accuracy_ppm": 473002, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 494946, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503906, + "task": "LAG-1" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805188, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919222, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713953, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503906, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942785, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948387, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503906, + "task": "LAG-1" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 923879, + "best_constant_accuracy_ppm": 503906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872394, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503906, + "task": "LAG-1" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501017, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1302, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 512854, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 501666, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505208, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807596, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 908732, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708282, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505208, + "task": "LAG-1" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953859, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448568, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952732, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958438, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505208, + "task": "LAG-1" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 936929, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 431640, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952732, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888706, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 505208, + "task": "LAG-1" + }, + { + "accuracy_ppm": 487630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487510, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 787, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 441406, + "final_window_balanced_accuracy_ppm": 440425, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514657, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806275, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918237, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696810, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "LAG-1" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944050, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933741, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "LAG-1" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 927752, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933741, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886859, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "LAG-1" + }, + { + "accuracy_ppm": 525390, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500083, + "best_constant_accuracy_ppm": 538411, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 729, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 550781, + "final_window_balanced_accuracy_ppm": 500802, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516440, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "LAG-1" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808954, + "best_constant_accuracy_ppm": 538411, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 261068, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930565, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 678004, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "LAG-1" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936524, + "best_constant_accuracy_ppm": 538411, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 398437, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948171, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929741, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "LAG-1" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 920505, + "best_constant_accuracy_ppm": 538411, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 383464, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948171, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870490, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 538411, + "task": "LAG-1" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501997, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503846, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503016, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810916, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929059, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710708, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951018, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951269, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933446, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960805, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882039, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 503255, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503244, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 763, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 486229, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515052, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 500651, + "task": "LAG-1" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803563, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922590, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681315, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 500651, + "task": "LAG-1" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945955, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445312, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944488, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946318, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 500651, + "task": "LAG-1" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 930320, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944488, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881608, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 500651, + "task": "LAG-1" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484417, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20182, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 509041, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 468498, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802782, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905425, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 679509, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949954, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933650, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948968, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 931874, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933650, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875563, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 490234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 480877, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 502570, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493799, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "LAG-1" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812418, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292317, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946862, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700874, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949413, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965380, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949045, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "LAG-1" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 931125, + "best_constant_accuracy_ppm": 515625, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 415364, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965380, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876429, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 515625, + "task": "LAG-1" + }, + { + "accuracy_ppm": 510416, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509932, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 752, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 0, + "final_window_accuracy_ppm": 562500, + "final_window_balanced_accuracy_ppm": 561679, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504153, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "LAG-1" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812214, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925745, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708295, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "LAG-1" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952521, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941249, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954978, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "LAG-1" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 934582, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941249, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881899, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 510416, + "task": "LAG-1" + }, + { + "accuracy_ppm": 480468, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 477992, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 798, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -28646, + "final_window_accuracy_ppm": 445312, + "final_window_balanced_accuracy_ppm": 460942, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 468881, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798790, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 890628, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 676627, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946004, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 923237, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 928336, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 930184, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 923237, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865867, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 485677, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484317, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 790, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29296, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 522941, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 461592, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814767, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 295573, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 933765, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696980, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955095, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440105, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965679, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948093, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 41 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 937045, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965679, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 509114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502601, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 651, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 515028, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 523113, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "LAG-1" + }, + { + "accuracy_ppm": 811197, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808718, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922286, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719083, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "LAG-1" + }, + { + "accuracy_ppm": 956380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956400, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447917, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948802, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "LAG-1" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 940682, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948802, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 891843, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 491536, + "task": "LAG-1" + }, + { + "accuracy_ppm": 507161, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507161, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 757, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 7161, + "final_window_accuracy_ppm": 566406, + "final_window_balanced_accuracy_ppm": 566471, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505650, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 817708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817708, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 317708, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937251, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 722060, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 955729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955729, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 455729, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968747, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954147, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 938150, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968747, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880460, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 500000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496068, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9765, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 492022, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 524545, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 814453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811262, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303386, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924903, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713533, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959065, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447917, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957423, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 939901, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 92, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429037, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957423, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888201, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488932, + "task": "LAG-1" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499141, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7812, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 490569, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 489156, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 821614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818872, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 274, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 312500, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945003, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958792, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449870, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968625, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952210, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 942380, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 88, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968625, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885347, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 490885, + "task": "LAG-1" + }, + { + "accuracy_ppm": 490885, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492062, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 782, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 485766, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 490894, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812818, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922497, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699556, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947901, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952127, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939081, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 43 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 930197, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952127, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866070, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 508463, + "task": "LAG-1" + }, + { + "accuracy_ppm": 513671, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511977, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 6510, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 456045, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 537948, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507161, + "task": "LAG-1" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806549, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 886164, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681770, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507161, + "task": "LAG-1" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943263, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919222, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942252, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507161, + "task": "LAG-1" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 924220, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417318, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919222, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869601, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 507161, + "task": "LAG-1" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502617, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2604, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 474991, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515551, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808481, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924606, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947299, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 931698, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946728, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 929641, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 931698, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876559, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 506510, + "task": "LAG-1" + }, + { + "accuracy_ppm": 492838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492258, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 779, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 526442, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487339, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-1" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800218, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680473, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-1" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946623, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940331, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-1" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 928997, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952916, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871706, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-1" + }, + { + "accuracy_ppm": 509114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499080, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 509286, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500609, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514322, + "task": "LAG-1" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812654, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919476, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699028, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514322, + "task": "LAG-1" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954426, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440105, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964931, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514322, + "task": "LAG-1" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [ + 41 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 938268, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423829, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964931, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882299, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 514322, + "task": "LAG-1" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501744, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1302, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 491725, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 528581, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799999, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 901832, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708307, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939429, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 437500, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 920916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942970, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 923200, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 920916, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879784, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 500000, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494547, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 768, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 489669, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505154, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815204, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294270, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 958402, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682186, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950134, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961999, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936445, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 933735, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417317, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961999, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872409, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-1" + }, + { + "accuracy_ppm": 507812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507865, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5859, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 479552, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 506626, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803303, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 924211, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700360, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945326, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953841, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941212, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 928465, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953841, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875356, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501953, + "task": "LAG-1" + }, + { + "accuracy_ppm": 504557, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508268, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 761, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10416, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 482265, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496683, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809437, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290365, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 907019, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 718585, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943444, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428386, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939162, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "balanced_accuracy_ppm": 925472, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 410157, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939162, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 862897, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 514973, + "task": "LAG-1" + }, + { + "accuracy_ppm": 521484, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491250, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 735, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 597656, + "final_window_balanced_accuracy_ppm": 509362, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518827, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-4" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800656, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 276041, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 922823, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709283, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949607, + "best_constant_accuracy_ppm": 534505, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 414713, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 956477, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937888, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 932057, + "best_constant_accuracy_ppm": 534505, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 397786, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 956477, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874573, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 465494, + "task": "LAG-4" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500666, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3255, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 512518, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 494653, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805229, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911814, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688261, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950433, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944666, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 930124, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867950, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 495442, + "task": "LAG-4" + }, + { + "accuracy_ppm": 508463, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503971, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7162, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 488827, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 509380, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 515625, + "task": "LAG-4" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813681, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293619, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938095, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698511, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 515625, + "task": "LAG-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955095, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965018, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951911, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 515625, + "task": "LAG-4" + }, + { + "accuracy_ppm": 937500, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 937723, + "best_constant_accuracy_ppm": 515625, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965018, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881872, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 515625, + "task": "LAG-4" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490435, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18229, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 541697, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491208, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492187, + "task": "LAG-4" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801882, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946204, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492187, + "task": "LAG-4" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942755, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 963153, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932340, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492187, + "task": "LAG-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 923738, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416016, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 963153, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859938, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 492187, + "task": "LAG-4" + }, + { + "accuracy_ppm": 490234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489774, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 783, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -11068, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503968, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500951, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810211, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309244, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 894322, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711421, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949245, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941941, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944038, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 931624, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941941, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876558, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490810, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -11067, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 522326, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505026, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 487630, + "task": "LAG-4" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802131, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293620, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 919500, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715123, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 487630, + "task": "LAG-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951664, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952287, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948081, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 487630, + "task": "LAG-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 931131, + "best_constant_accuracy_ppm": 512369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952287, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873737, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 487630, + "task": "LAG-4" + }, + { + "accuracy_ppm": 511067, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503830, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 751, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1953, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 489369, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 551332, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 486979, + "task": "LAG-4" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802057, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292969, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934383, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 726667, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 486979, + "task": "LAG-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943100, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430339, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941959, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940386, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 486979, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 71 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927091, + "best_constant_accuracy_ppm": 513020, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414714, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941959, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884597, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 486979, + "task": "LAG-4" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506243, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 508333, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 813802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813203, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 311849, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942401, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702750, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 960286, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 960262, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 61, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 458333, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 971813, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958567, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 939378, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 93, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 437500, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 971813, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878335, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 504557, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506015, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 761, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1302, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 482828, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508826, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800496, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926629, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710896, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944739, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948851, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949564, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 925905, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948851, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875535, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 507812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507418, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 521119, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511812, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806292, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929274, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697776, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952475, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449218, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957729, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948476, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 933616, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957729, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874822, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 503255, + "task": "LAG-4" + }, + { + "accuracy_ppm": 499348, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499730, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 769, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2605, + "final_window_accuracy_ppm": 558593, + "final_window_balanced_accuracy_ppm": 558593, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504884, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-4" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802644, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941406, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685068, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945965, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444010, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953124, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944188, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 929721, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953124, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882279, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-4" + }, + { + "accuracy_ppm": 524739, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500947, + "best_constant_accuracy_ppm": 537760, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 730, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 546875, + "final_window_balanced_accuracy_ppm": 493223, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520703, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537760, + "task": "LAG-4" + }, + { + "accuracy_ppm": 794921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804970, + "best_constant_accuracy_ppm": 537760, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 315, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 257161, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922643, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537760, + "task": "LAG-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938747, + "best_constant_accuracy_ppm": 537760, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 94, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 401042, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940125, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936375, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537760, + "task": "LAG-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 921933, + "best_constant_accuracy_ppm": 537760, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 384766, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940125, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871285, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537760, + "task": "LAG-4" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499460, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 460937, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808413, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921875, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702782, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951087, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964843, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945101, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 933092, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964843, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876617, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 481770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 481669, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 796, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18881, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 473529, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487271, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 499348, + "task": "LAG-4" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801257, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 899509, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687793, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 499348, + "task": "LAG-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941414, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928921, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934659, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 499348, + "task": "LAG-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 923832, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928921, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866330, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 499348, + "task": "LAG-4" + }, + { + "accuracy_ppm": 487630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487353, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 787, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18229, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 534090, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 488848, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 798177, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799904, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 310, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917277, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680798, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947265, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937438, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942467, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 928527, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937438, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871388, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 511718, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504048, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 750, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1953, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 525306, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 529847, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812476, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946145, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701083, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953160, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439454, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972461, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944404, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 76 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 931678, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972461, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868844, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 493489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494175, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 473661, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510579, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 509114, + "task": "LAG-4" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808702, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 906304, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706362, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 509114, + "task": "LAG-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947449, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929560, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951273, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 509114, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 928078, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929560, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877897, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 509114, + "task": "LAG-4" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497140, + "best_constant_accuracy_ppm": 509765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9114, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 471812, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514278, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490234, + "task": "LAG-4" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809067, + "best_constant_accuracy_ppm": 509765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 897260, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490234, + "task": "LAG-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952493, + "best_constant_accuracy_ppm": 509765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926246, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943264, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490234, + "task": "LAG-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 934667, + "best_constant_accuracy_ppm": 509765, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926246, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875109, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 490234, + "task": "LAG-4" + }, + { + "accuracy_ppm": 517578, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 518659, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 741, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 3907, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 538546, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 501482, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809236, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291667, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 910303, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 684042, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949287, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941993, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932831, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 929990, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416016, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941993, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 857542, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 511718, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503459, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 750, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 502077, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 538707, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490885, + "task": "LAG-4" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807765, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 899804, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 722413, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490885, + "task": "LAG-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954980, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445964, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941470, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956607, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490885, + "task": "LAG-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 938425, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429688, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941470, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895366, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490885, + "task": "LAG-4" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485644, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 515725, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504968, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803673, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711383, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947277, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940774, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 929017, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870829, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 498697, + "task": "LAG-4" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489414, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 490249, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519024, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488281, + "task": "LAG-4" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800737, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933339, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702523, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488281, + "task": "LAG-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948737, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957729, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947607, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488281, + "task": "LAG-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 928101, + "best_constant_accuracy_ppm": 511718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957729, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874674, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 488281, + "task": "LAG-4" + }, + { + "accuracy_ppm": 513020, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511289, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 748, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 527411, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512169, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 489583, + "task": "LAG-4" + }, + { + "accuracy_ppm": 819010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815864, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 278, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308594, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940842, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714123, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 489583, + "task": "LAG-4" + }, + { + "accuracy_ppm": 959635, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959481, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 62, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449219, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968620, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 953389, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 489583, + "task": "LAG-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 942995, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 87, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968620, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887861, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 489583, + "task": "LAG-4" + }, + { + "accuracy_ppm": 466796, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 467766, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 819, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 476740, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 467801, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805808, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934561, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 670893, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946554, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957118, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930705, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927713, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957118, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856596, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 506510, + "task": "LAG-4" + }, + { + "accuracy_ppm": 497395, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493358, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 772, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -8464, + "final_window_accuracy_ppm": 441406, + "final_window_balanced_accuracy_ppm": 460912, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519679, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814735, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307292, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 893381, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699793, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951800, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926168, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948851, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 931562, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926168, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 505859, + "task": "LAG-4" + }, + { + "accuracy_ppm": 485026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483077, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 791, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20182, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 497467, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 483353, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 505208, + "task": "LAG-4" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800345, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293620, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 917345, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692687, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 505208, + "task": "LAG-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944675, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938472, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941633, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 505208, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927170, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938472, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869671, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 505208, + "task": "LAG-4" + }, + { + "accuracy_ppm": 488281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487281, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 786, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13672, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 468749, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510350, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807367, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305989, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949218, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695149, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953772, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451823, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968749, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946061, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 934185, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968749, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874255, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 498046, + "task": "LAG-4" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489473, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 517106, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 492868, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810397, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292969, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 923264, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702812, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951715, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968718, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948256, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 933650, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968718, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876643, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 485026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 485025, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 791, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 515139, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518622, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 500000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804687, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304687, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925945, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706545, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 500000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948567, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448567, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960561, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943980, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 500000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 930338, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960561, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876594, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 500000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 482421, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 479178, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 795, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33855, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 469688, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 484298, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803472, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 282552, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 929417, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687530, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943447, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 943601, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940331, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927848, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 411458, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 943601, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879241, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 516276, + "task": "LAG-4" + }, + { + "accuracy_ppm": 498046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498156, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3256, + "final_window_accuracy_ppm": 441406, + "final_window_balanced_accuracy_ppm": 450244, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 525082, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501302, + "task": "LAG-4" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803107, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 923038, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698250, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501302, + "task": "LAG-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945964, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952450, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949666, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501302, + "task": "LAG-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 927779, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952450, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881437, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 501302, + "task": "LAG-4" + }, + { + "accuracy_ppm": 512369, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 516868, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 749, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1302, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 467684, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 533633, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809165, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291667, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 902991, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 722619, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939076, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 94, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 425131, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 927813, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb" + ], + "balanced_accuracy_ppm": 923162, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 408855, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 927813, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:0e4f28ec0ddc00769463fb35a1ea4f26965d86adf5e2e3666fad03d1ca2869cb", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878634, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513671, + "task": "LAG-4" + }, + { + "accuracy_ppm": 530598, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499146, + "best_constant_accuracy_ppm": 535156, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 721, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -4558, + "final_window_accuracy_ppm": 574218, + "final_window_balanced_accuracy_ppm": 485070, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 547384, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 464843, + "task": "LAG-7" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800174, + "best_constant_accuracy_ppm": 535156, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 275390, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 912955, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720595, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 464843, + "task": "LAG-7" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952135, + "best_constant_accuracy_ppm": 535156, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 416666, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 951416, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944936, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 464843, + "task": "LAG-7" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 934112, + "best_constant_accuracy_ppm": 535156, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 399739, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 951416, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883142, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 464843, + "task": "LAG-7" + }, + { + "accuracy_ppm": 492187, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490409, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 780, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 484068, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507558, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797951, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 888480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942030, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921568, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945370, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 923073, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921568, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876235, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494791, + "task": "LAG-7" + }, + { + "accuracy_ppm": 501953, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497700, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 765, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13020, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 520366, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 509837, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806276, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287110, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 686018, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948501, + "best_constant_accuracy_ppm": 514973, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972366, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941778, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 76 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 927883, + "best_constant_accuracy_ppm": 514973, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412761, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 972366, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869177, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 514973, + "task": "LAG-7" + }, + { + "accuracy_ppm": 485677, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486146, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 790, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22786, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 474544, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 498543, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 491536, + "task": "LAG-7" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805009, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917837, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697242, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 491536, + "task": "LAG-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945406, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 943047, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941395, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 491536, + "task": "LAG-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 927017, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 943047, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874583, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 491536, + "task": "LAG-7" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506079, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5208, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 496093, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504831, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-7" + }, + { + "accuracy_ppm": 814453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814073, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 313151, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929687, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710289, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-7" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957024, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 455729, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968749, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943882, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-7" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 936809, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 435546, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968749, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867391, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 498697, + "task": "LAG-7" + }, + { + "accuracy_ppm": 509765, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497302, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 753, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 472058, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 530264, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 486328, + "task": "LAG-7" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801853, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 892891, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713983, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 486328, + "task": "LAG-7" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946432, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943769, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 486328, + "task": "LAG-7" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 925717, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412761, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930391, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871712, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 486328, + "task": "LAG-7" + }, + { + "accuracy_ppm": 516927, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506115, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 742, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2605, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 485092, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 551833, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 485677, + "task": "LAG-7" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798930, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289063, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 915444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 485677, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941692, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427735, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934383, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935698, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 485677, + "task": "LAG-7" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 74 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 922999, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 409506, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934383, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873536, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 485677, + "task": "LAG-7" + }, + { + "accuracy_ppm": 477864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 477294, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 802, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 441406, + "final_window_balanced_accuracy_ppm": 444979, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 479563, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 497395, + "task": "LAG-7" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804576, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911641, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694677, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 497395, + "task": "LAG-7" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951173, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448567, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944488, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942620, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 497395, + "task": "LAG-7" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 928956, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944488, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 862047, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 497395, + "task": "LAG-7" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487255, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 462609, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511848, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 501302, + "task": "LAG-7" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806381, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304687, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910923, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 725716, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 501302, + "task": "LAG-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950537, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449218, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945014, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958041, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 501302, + "task": "LAG-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 927129, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945014, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871476, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 501302, + "task": "LAG-7" + }, + { + "accuracy_ppm": 499348, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499304, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 769, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3256, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 508064, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487427, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 502604, + "task": "LAG-7" + }, + { + "accuracy_ppm": 792968, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793769, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 318, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290364, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 900903, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695557, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 502604, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942733, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941226, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944212, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 502604, + "task": "LAG-7" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 924571, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941226, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874241, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 502604, + "task": "LAG-7" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486775, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 472656, + "final_window_balanced_accuracy_ppm": 473321, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 495908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-7" + }, + { + "accuracy_ppm": 794921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795470, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 315, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292968, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918253, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685408, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-7" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940736, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937484, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939294, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-7" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 920591, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418619, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937484, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865281, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 501953, + "task": "LAG-7" + }, + { + "accuracy_ppm": 532552, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508195, + "best_constant_accuracy_ppm": 537109, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 718, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -4557, + "final_window_accuracy_ppm": 578125, + "final_window_balanced_accuracy_ppm": 524908, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 530704, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537109, + "task": "LAG-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818708, + "best_constant_accuracy_ppm": 537109, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 271484, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957824, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692906, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537109, + "task": "LAG-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950829, + "best_constant_accuracy_ppm": 537109, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 971810, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943433, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537109, + "task": "LAG-7" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 935821, + "best_constant_accuracy_ppm": 537109, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 398437, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 971810, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885586, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 537109, + "task": "LAG-7" + }, + { + "accuracy_ppm": 495442, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495991, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 775, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10417, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 519654, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500556, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802401, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918237, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698645, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941397, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945369, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935256, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 924023, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945369, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 524739, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 524360, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 730, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 22786, + "final_window_accuracy_ppm": 550781, + "final_window_balanced_accuracy_ppm": 552695, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503551, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498046, + "task": "LAG-7" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811299, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309895, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934558, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 690402, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498046, + "task": "LAG-7" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953129, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451172, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952941, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941463, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498046, + "task": "LAG-7" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 932928, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952941, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 864615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498046, + "task": "LAG-7" + }, + { + "accuracy_ppm": 481770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 480920, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 796, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22787, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 495201, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809309, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921144, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950599, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929274, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954667, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 929930, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929274, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878544, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 486979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 480991, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 788, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25390, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 455223, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 480238, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 512369, + "task": "LAG-7" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814153, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934867, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699315, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 512369, + "task": "LAG-7" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953289, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440756, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957423, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951344, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 512369, + "task": "LAG-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 932097, + "best_constant_accuracy_ppm": 512369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957423, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867602, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 512369, + "task": "LAG-7" + }, + { + "accuracy_ppm": 500000, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500549, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 768, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7812, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 508179, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519757, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "LAG-7" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806399, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921930, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707511, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "LAG-7" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947425, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945186, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950211, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "LAG-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 927533, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945186, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877584, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "LAG-7" + }, + { + "accuracy_ppm": 508463, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503595, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1953, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 535740, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511830, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 489583, + "task": "LAG-7" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806244, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 902112, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703932, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 489583, + "task": "LAG-7" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946537, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931097, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939003, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 489583, + "task": "LAG-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 927974, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931097, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872778, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 489583, + "task": "LAG-7" + }, + { + "accuracy_ppm": 472656, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 472488, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 810, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39062, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 483348, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 469887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 511718, + "task": "LAG-7" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807363, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 917175, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700037, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 511718, + "task": "LAG-7" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947948, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945544, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939199, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 511718, + "task": "LAG-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 928773, + "best_constant_accuracy_ppm": 511718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945544, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867072, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 511718, + "task": "LAG-7" + }, + { + "accuracy_ppm": 510416, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504225, + "best_constant_accuracy_ppm": 509765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 752, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 651, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 488438, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 532352, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490234, + "task": "LAG-7" + }, + { + "accuracy_ppm": 815104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812183, + "best_constant_accuracy_ppm": 509765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 284, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305339, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919072, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 721697, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490234, + "task": "LAG-7" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958930, + "best_constant_accuracy_ppm": 509765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449219, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960116, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 953752, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490234, + "task": "LAG-7" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 71 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 938422, + "best_constant_accuracy_ppm": 509765, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429037, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960116, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882171, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 490234, + "task": "LAG-7" + }, + { + "accuracy_ppm": 488281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486207, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 786, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 474828, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515504, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802461, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945014, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713056, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942697, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961143, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 926331, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961143, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871193, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 517578, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508370, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 741, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5209, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 544110, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 540717, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 487630, + "task": "LAG-7" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808300, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905669, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 723494, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 487630, + "task": "LAG-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950490, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937927, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954987, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 487630, + "task": "LAG-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 69 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 931163, + "best_constant_accuracy_ppm": 512369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937927, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888234, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 487630, + "task": "LAG-7" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490377, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 496642, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496151, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488932, + "task": "LAG-7" + }, + { + "accuracy_ppm": 812500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809120, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301433, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917276, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 712314, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488932, + "task": "LAG-7" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954926, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444011, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952991, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488932, + "task": "LAG-7" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 936341, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952991, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881787, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488932, + "task": "LAG-7" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498872, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7162, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 468441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520232, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810184, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919222, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704104, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944032, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936178, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 65 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 924529, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941444, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 864169, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 505859, + "task": "LAG-7" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494026, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 489592, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518115, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807195, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 897704, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692572, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949776, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445312, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926629, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951061, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 928379, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926629, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869828, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 504557, + "task": "LAG-7" + }, + { + "accuracy_ppm": 496093, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496113, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 774, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 478873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504781, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 503906, + "task": "LAG-7" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804522, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 915616, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700191, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 503906, + "task": "LAG-7" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946641, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933221, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945185, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 503906, + "task": "LAG-7" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 922607, + "best_constant_accuracy_ppm": 503906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933221, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 854823, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 503906, + "task": "LAG-7" + }, + { + "accuracy_ppm": 492187, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489961, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 780, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -11068, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 480468, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513520, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805031, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941406, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 690543, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949854, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446614, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945580, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 928961, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871913, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 496744, + "task": "LAG-7" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495031, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 482505, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 506386, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-7" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806979, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289714, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 908245, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 716749, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-7" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945762, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945558, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951778, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 928509, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414714, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945558, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886796, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "LAG-7" + }, + { + "accuracy_ppm": 480468, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 480104, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 798, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20183, + "final_window_accuracy_ppm": 410156, + "final_window_balanced_accuracy_ppm": 412026, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517660, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 499348, + "task": "LAG-7" + }, + { + "accuracy_ppm": 794270, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794092, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 316, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293619, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 871001, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 705282, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 499348, + "task": "LAG-7" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940767, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909462, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 499348, + "task": "LAG-7" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 923178, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909462, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876426, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 499348, + "task": "LAG-7" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501975, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 554687, + "final_window_balanced_accuracy_ppm": 502072, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 526367, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 515625, + "task": "LAG-7" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809689, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289713, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 964106, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687888, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 515625, + "task": "LAG-7" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946052, + "best_constant_accuracy_ppm": 515625, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430338, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 971099, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931959, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 515625, + "task": "LAG-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 928559, + "best_constant_accuracy_ppm": 515625, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412760, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 971099, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869025, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 515625, + "task": "LAG-7" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496744, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3256, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 521323, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505512, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 500000, + "task": "LAG-7" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804687, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304687, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938235, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710201, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 500000, + "task": "LAG-7" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945963, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945588, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945223, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 500000, + "task": "LAG-7" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 926432, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945588, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875434, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 500000, + "task": "LAG-7" + }, + { + "accuracy_ppm": 488932, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491113, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 785, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24088, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 482731, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513020, + "task": "LAG-7" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810224, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293620, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 912488, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 721882, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513020, + "task": "LAG-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942838, + "best_constant_accuracy_ppm": 513020, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429688, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 947949, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938157, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513020, + "task": "LAG-7" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad" + ], + "balanced_accuracy_ppm": 925072, + "best_constant_accuracy_ppm": 513020, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 411459, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 947949, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7d16d1b4d6e15e45615d45d863b9234acc1c4ea1c83bac648035676b9e48d5ad", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871213, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 513020, + "task": "LAG-7" + }, + { + "accuracy_ppm": 483723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 481963, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 793, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18881, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 475579, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 476632, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808524, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 306640, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695671, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951194, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448567, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961049, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934001, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 43 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 933611, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961049, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 860222, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 488932, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491219, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 785, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 472656, + "final_window_balanced_accuracy_ppm": 477228, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505759, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 796223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797943, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 313, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290364, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 882295, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703291, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941443, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918009, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 922720, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918009, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868710, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 496744, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497054, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 773, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5209, + "final_window_accuracy_ppm": 441406, + "final_window_balanced_accuracy_ppm": 452838, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512431, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 498046, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809328, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931367, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 498046, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954426, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 452474, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968681, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 498046, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 73 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 935487, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968681, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873277, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 498046, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 485026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483528, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 791, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19531, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 495112, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 481078, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802046, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905913, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688309, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940756, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946236, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932947, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 923768, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946236, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866227, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 509765, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499760, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 753, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 494153, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513603, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 513671, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807050, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289714, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 902264, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689026, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 513671, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945833, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931190, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941786, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 513671, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929492, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416016, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931190, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874106, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 513671, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 519531, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499078, + "best_constant_accuracy_ppm": 539062, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 738, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19531, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 483178, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 539062, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816885, + "best_constant_accuracy_ppm": 539062, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 266276, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 920173, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 539062, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948528, + "best_constant_accuracy_ppm": 539062, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 408203, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946293, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946956, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 539062, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930299, + "best_constant_accuracy_ppm": 539062, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 389323, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946293, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872502, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 539062, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 475260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 475474, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 806, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 527343, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 483098, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 500651, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797070, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917968, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693903, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 500651, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 937500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937513, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 96, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941406, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 920381, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 500651, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 919921, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 919942, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 123, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419270, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941406, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 850201, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 500651, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 491536, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492378, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 781, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 453125, + "final_window_balanced_accuracy_ppm": 461448, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499240, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810287, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 308593, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931546, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 957682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957690, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 65, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 456380, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964392, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945307, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 938855, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 437500, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964392, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872181, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 501302, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502464, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1302, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 506597, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518597, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806023, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925586, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687490, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949249, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949779, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945291, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 71 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929752, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949779, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870826, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 526041, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 528022, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 728, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 17578, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 536014, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 525468, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803347, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 899740, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710717, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947393, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941993, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949446, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 69 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 928121, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941993, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874079, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 527994, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511906, + "best_constant_accuracy_ppm": 522135, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 725, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5859, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 504425, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 529195, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 522135, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808613, + "best_constant_accuracy_ppm": 522135, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 280599, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937678, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692109, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 522135, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949510, + "best_constant_accuracy_ppm": 522135, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949306, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949250, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 522135, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 932781, + "best_constant_accuracy_ppm": 522135, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 410807, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949306, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884713, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 522135, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 518229, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506502, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 740, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4558, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 501479, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 538348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 486328, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 818359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814606, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 279, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304688, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937650, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 727467, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 486328, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949814, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 951834, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941857, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 486328, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 934882, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 951834, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878438, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 486328, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498209, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5209, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 457074, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 488122, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 503906, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812890, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 932325, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700148, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 503906, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952425, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 448567, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957688, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948358, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 503906, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931015, + "best_constant_accuracy_ppm": 503906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957688, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 864745, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 503906, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 494791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494835, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 776, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -6511, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 499081, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 462493, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498697, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806304, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305338, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945576, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 683324, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498697, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945991, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962105, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934405, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498697, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 925828, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962105, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 851770, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 498697, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 481119, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 479239, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 797, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 468474, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 490177, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801338, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290365, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 906157, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 691281, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948585, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922286, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956182, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929357, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922286, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883126, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 508463, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 468750, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 467422, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 816, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42317, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 469362, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 456551, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800062, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285808, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 915685, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 677557, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942737, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 431641, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945097, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938006, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 924413, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413412, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945097, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 511067, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 494140, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493986, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 777, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13672, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 476108, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 489259, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 492187, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800294, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 912561, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 683492, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 492187, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950427, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938423, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948874, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 492187, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931511, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938423, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867961, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 492187, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502777, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -6510, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 481343, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 492707, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797460, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 872889, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 684288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942110, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 901577, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 44 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 925217, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 901577, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865553, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 492838, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 495442, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486796, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 775, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18880, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 496490, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 482050, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514322, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817234, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298829, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926111, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693016, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514322, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 955729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955841, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441407, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957119, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941828, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514322, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 938603, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423829, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957119, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872277, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 514322, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 481770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 472480, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 796, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -34506, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 488949, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 464762, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 516276, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806164, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285156, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910561, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688229, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 516276, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948030, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 431640, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941330, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943163, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 516276, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929194, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412760, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941330, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869215, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 516276, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 486979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 488496, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 788, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18229, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 509725, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 494817, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 505208, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806775, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926534, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703835, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 505208, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947239, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948922, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942286, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 505208, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 928431, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948922, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868437, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 505208, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 518229, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499314, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 740, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5859, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 498164, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 521295, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 524088, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 819852, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289063, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925801, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693832, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 524088, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 957682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957740, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 65, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433594, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942194, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958589, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 524088, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 940900, + "best_constant_accuracy_ppm": 524088, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 91, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 416667, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942194, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890762, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 524088, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 500000, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499511, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 768, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 523721, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 483001, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805751, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936455, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694272, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951146, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957116, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931585, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957116, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 494791, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495273, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20183, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 464224, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 498579, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 481119, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803679, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290364, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 901892, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 481119, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948469, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941574, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933866, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 481119, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 43 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931370, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 412760, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941574, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 862469, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 481119, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506309, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -651, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 503036, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496338, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 493489, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 812500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810823, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305990, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 901582, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 493489, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948026, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 935195, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942950, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 493489, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929641, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 935195, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870710, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 493489, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 538411, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 538245, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 709, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 29297, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 530076, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 559974, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 490885, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806462, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713266, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 490885, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950361, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947465, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 490885, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 79 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 932102, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945282, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880247, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 490885, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 477864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 477639, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 802, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 437500, + "final_window_balanced_accuracy_ppm": 440308, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491189, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807167, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305338, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930802, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680428, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952455, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 933517, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430989, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949599, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875378, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 497395, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 493489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492259, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -12370, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 494256, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507077, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 797526, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799123, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 311, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291667, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921065, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693111, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943910, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953323, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937952, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927179, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953323, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874645, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 505859, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 509114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509085, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 516089, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 523476, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 792968, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794185, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 318, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288411, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910297, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 673626, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941927, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 437500, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 945262, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934691, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 923780, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 945262, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 864840, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 504557, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 511067, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492839, + "best_constant_accuracy_ppm": 526041, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 751, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 499999, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515503, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 473958, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799762, + "best_constant_accuracy_ppm": 526041, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 281250, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 679263, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 473958, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948114, + "best_constant_accuracy_ppm": 526041, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936151, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 473958, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 933610, + "best_constant_accuracy_ppm": 526041, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880828, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 473958, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 498046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 481868, + "best_constant_accuracy_ppm": 522786, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24740, + "final_window_accuracy_ppm": 589843, + "final_window_balanced_accuracy_ppm": 524277, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491582, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 522786, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 800130, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806403, + "best_constant_accuracy_ppm": 522786, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 277344, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 944236, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 672890, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 522786, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942767, + "best_constant_accuracy_ppm": 522786, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964644, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934878, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 522786, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 921771, + "best_constant_accuracy_ppm": 522786, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 399089, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964644, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 853221, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 522786, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489773, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 519531, + "final_window_balanced_accuracy_ppm": 480446, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487842, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 483072, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797266, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285156, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 907796, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 483072, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940797, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950531, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 483072, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 922502, + "best_constant_accuracy_ppm": 516927, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 405599, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 950531, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865764, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 483072, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 481770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 475112, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 796, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31901, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 471655, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 475771, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 794921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798669, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 315, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 281250, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 913100, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 672014, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934917, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 100, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942730, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 922969, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 918619, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 918612, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 125, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 404948, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942730, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856950, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 498046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490634, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 480555, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505345, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 488932, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795398, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287761, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 900140, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697545, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 488932, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945864, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434896, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929337, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945451, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 488932, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 926902, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 416016, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929337, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873380, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 488932, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 513020, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512325, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 748, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5860, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 489054, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520183, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 481119, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802953, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289713, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 941164, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693219, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 481119, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950450, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 431640, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 973875, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939499, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 481119, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 930066, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 411458, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 973875, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 858768, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 481119, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 497395, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493893, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 772, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 425781, + "final_window_balanced_accuracy_ppm": 473946, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515568, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797899, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 290365, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 908440, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 685016, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939521, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429037, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 932916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932754, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 74 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 920619, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 410156, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 932916, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863928, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 521484, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497329, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 735, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9114, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 500152, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519845, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 469401, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799715, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 277995, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909243, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 717740, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 469401, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944653, + "best_constant_accuracy_ppm": 530598, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 414063, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 954698, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931652, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 469401, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 925182, + "best_constant_accuracy_ppm": 530598, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 395183, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 954698, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859575, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 469401, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498712, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 523437, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 502789, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800331, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 886718, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703938, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946576, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929687, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941673, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 67 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 925556, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929687, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865250, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 509114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508421, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 3255, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 514809, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497656, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804881, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928732, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698783, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945197, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944732, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937909, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 924208, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944732, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859623, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 494140, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 508463, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506658, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1953, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 540931, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 501671, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 506510, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809868, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938725, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688967, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 506510, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953184, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964460, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949492, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 506510, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 934935, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964460, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877930, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 506510, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 508463, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505649, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -11068, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 494908, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503746, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 519531, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814006, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289062, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929890, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709694, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 519531, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948091, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944488, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946151, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 519531, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 929615, + "best_constant_accuracy_ppm": 519531, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944488, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874681, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 519531, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 501953, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493046, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 765, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -11718, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 506837, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 800130, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795936, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 286459, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 891452, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707620, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945199, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 431641, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941452, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 925333, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 412110, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941452, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872776, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 474609, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 474285, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 807, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -28646, + "final_window_accuracy_ppm": 550781, + "final_window_balanced_accuracy_ppm": 553242, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 463345, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797815, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 293620, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 908744, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 683273, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940764, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 437500, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934106, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942222, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 920578, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 417317, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 934106, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861879, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 509765, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508617, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 753, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 651, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 485808, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514886, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 812500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814835, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303386, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926534, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696462, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945909, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937728, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941350, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 927698, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937728, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871936, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 512369, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493686, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 749, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 539062, + "final_window_balanced_accuracy_ppm": 487644, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504710, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 472005, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799769, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 908697, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 717586, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 472005, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949424, + "best_constant_accuracy_ppm": 527994, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952557, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952764, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 472005, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 928086, + "best_constant_accuracy_ppm": 527994, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 400391, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952557, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870424, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 472005, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499041, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7812, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 507175, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 506544, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 508463, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 798177, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800588, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 310, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289714, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 678165, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 508463, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 940755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940793, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 91, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949282, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931900, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 508463, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 922712, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 414063, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949282, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859947, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 508463, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 514973, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512081, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 745, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 515517, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 535149, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 487630, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 811848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807978, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 289, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 920331, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694794, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 487630, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 958333, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958178, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445964, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948557, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955516, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 487630, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 941047, + "best_constant_accuracy_ppm": 512369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 90, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429037, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948557, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890285, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 487630, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492836, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10417, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 495941, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512421, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 516927, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812730, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291015, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 954343, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697131, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 516927, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950640, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 967164, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947387, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 516927, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 930103, + "best_constant_accuracy_ppm": 516927, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 967164, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868075, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 516927, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494034, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7812, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 503387, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804352, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 914239, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707831, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949600, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941371, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951194, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 929313, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 416016, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941371, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875203, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 486328, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 483723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483723, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 793, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16277, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 460899, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487522, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809244, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309244, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 872555, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 684301, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947916, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447916, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910434, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934802, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 929036, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910434, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859533, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 506510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497882, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 758, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 480468, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519718, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 815755, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812730, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 283, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305339, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925781, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 715105, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957012, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953124, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 950051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 938504, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 428386, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953124, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879604, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 487630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486590, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 787, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13672, + "final_window_accuracy_ppm": 445312, + "final_window_balanced_accuracy_ppm": 471428, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504958, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 498697, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 809244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808861, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 293, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307942, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 897659, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710792, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 498697, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957034, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 455729, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940517, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948836, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 498697, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 940069, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 92, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940517, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884713, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 498697, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487761, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18880, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 487908, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 485905, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805517, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696095, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944590, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 436198, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935613, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 923816, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 415365, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968916, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 855440, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 486979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482793, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 788, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23437, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 473400, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493478, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 815104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812011, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 284, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304688, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703120, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 956380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956293, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445964, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953841, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952010, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 935817, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425781, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953841, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873631, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 489583, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 513020, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491134, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 748, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 539062, + "final_window_balanced_accuracy_ppm": 524682, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493960, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 528645, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 816406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 824558, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287761, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953567, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700197, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 528645, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957562, + "best_constant_accuracy_ppm": 528645, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 428386, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976294, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952739, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 528645, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 44 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 935970, + "best_constant_accuracy_ppm": 528645, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976294, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865047, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 528645, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 477864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 476223, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 802, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 449218, + "final_window_balanced_accuracy_ppm": 471599, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 480742, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 813802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814650, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 286, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 310547, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 915076, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700270, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947897, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952891, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936079, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 928399, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952891, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 858431, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 503255, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 507812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507886, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1302, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 474717, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 522270, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 816406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818885, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 282, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307292, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 897832, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 719896, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953156, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444011, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925832, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945785, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 932009, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925832, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 864861, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 509114, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 516927, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502536, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 742, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2604, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 520573, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517568, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 480468, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801036, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287760, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933272, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713053, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 480468, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946700, + "best_constant_accuracy_ppm": 519531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941208, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944195, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 480468, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 927241, + "best_constant_accuracy_ppm": 519531, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 408203, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941208, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866632, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 480468, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 502604, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502603, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 2604, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 517494, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 485821, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804036, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304036, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919806, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949869, + "best_constant_accuracy_ppm": 500000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449869, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949657, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956091, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 931640, + "best_constant_accuracy_ppm": 500000, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 431640, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949657, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883017, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 500000, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 509114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509032, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 754, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -4557, + "final_window_accuracy_ppm": 437500, + "final_window_balanced_accuracy_ppm": 437728, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511488, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 804687, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808496, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 300, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291016, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 917276, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710104, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952349, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956959, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957334, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 48 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 933686, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956959, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880926, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 513671, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 515625, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 515088, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 744, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 7162, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 536432, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507702, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 796875, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794435, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 312, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 288412, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909560, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688233, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944104, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 435547, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942080, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940767, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 927658, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942080, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874587, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 491536, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 483072, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 481795, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 794, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21485, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 471441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 469890, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802129, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296224, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 943862, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 674827, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942774, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956259, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932214, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 923336, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956259, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 854202, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 504557, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 486979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484882, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 788, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 488949, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 484819, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 495442, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800737, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913552, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 495442, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942656, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940042, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 495442, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 923004, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949266, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 495442, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 487630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487919, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 787, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13672, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 482878, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496469, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 501302, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808295, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 306640, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929987, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710561, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 501302, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945957, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960995, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935474, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 501302, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39" + ], + "balanced_accuracy_ppm": 926436, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960995, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1d66237319d1d67ddbd73d7b9efe318a8a8bc3ddef077fe4bfa60b0fb67f8b39", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 855838, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 501302, + "task": "XOR-2-7" + }, + { + "accuracy_ppm": 477213, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 475595, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 803, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 472656, + "final_window_balanced_accuracy_ppm": 478693, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 480543, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806082, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 932905, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688478, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944035, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956715, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935299, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927789, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956715, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866626, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 492838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494714, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 779, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 520390, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 498141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801633, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941574, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 678217, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948537, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956959, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 49 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929064, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956959, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865304, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486724, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 417968, + "final_window_balanced_accuracy_ppm": 427880, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497948, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 501953, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807194, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 304687, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949290, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687692, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 501953, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948569, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446614, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953388, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948103, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 501953, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930957, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953388, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872935, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 501953, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 489583, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487843, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 784, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14974, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 483748, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 482196, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806745, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941470, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944721, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956622, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931795, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927029, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956622, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861775, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 515625, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505463, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 744, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1954, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 523354, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 522506, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 486328, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 811197, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807314, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 904836, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710702, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 486328, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947877, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 434245, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935164, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 486328, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931920, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960391, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872800, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 486328, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 521484, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498945, + "best_constant_accuracy_ppm": 539062, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 735, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 479079, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513286, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 460937, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793948, + "best_constant_accuracy_ppm": 539062, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 266927, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909407, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682440, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 460937, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949315, + "best_constant_accuracy_ppm": 539062, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 410156, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942194, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943917, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 460937, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930370, + "best_constant_accuracy_ppm": 539062, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 391276, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942194, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 868542, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 460937, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 492838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492972, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 779, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 542968, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499782, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 499348, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 812500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812314, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 288, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 311849, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937500, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699287, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 499348, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949863, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449218, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944019, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 499348, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 934237, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957031, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876499, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 499348, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 475911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 476641, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 805, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 445312, + "final_window_balanced_accuracy_ppm": 451389, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 481777, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810173, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309244, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945592, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698489, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950513, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449218, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962399, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949389, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930349, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962399, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866689, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 498697, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500303, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -651, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 509896, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803915, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 922775, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713595, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947148, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953078, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951727, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 926970, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953078, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871870, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 519531, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 521311, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 738, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 11068, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 532492, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508513, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 796223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793707, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 313, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287760, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 898999, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 688175, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941389, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938472, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937516, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 922006, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 413412, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938472, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 859682, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 519531, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503165, + "best_constant_accuracy_ppm": 522135, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 738, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2604, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 484801, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 477864, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793920, + "best_constant_accuracy_ppm": 522135, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 278646, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 906060, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689453, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 477864, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939697, + "best_constant_accuracy_ppm": 522135, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 417969, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929682, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940321, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 477864, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 921432, + "best_constant_accuracy_ppm": 522135, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 399740, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929682, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870347, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 477864, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489142, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13020, + "final_window_accuracy_ppm": 445312, + "final_window_balanced_accuracy_ppm": 491643, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514292, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 513671, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 794921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798669, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 315, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 281250, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924606, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 673449, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 513671, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934917, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 100, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421224, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941998, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930146, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 513671, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 917968, + "arena_version": "v0.3", + "authorization_events": [ + 45 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 918192, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 126, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 404297, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941998, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856390, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 513671, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 494791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494190, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 776, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 459468, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 484128, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 496093, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802243, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 917710, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695068, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 496093, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947257, + "best_constant_accuracy_ppm": 503906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960083, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941531, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 496093, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 927734, + "best_constant_accuracy_ppm": 503906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960083, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 496093, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500740, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -651, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 477991, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 494675, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 800781, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801149, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 306, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918793, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695791, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942058, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440755, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941016, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938099, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 923862, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941016, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866722, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 501302, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 486328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483766, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 789, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22135, + "final_window_accuracy_ppm": 480468, + "final_window_balanced_accuracy_ppm": 489125, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 469755, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804788, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 907380, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 682107, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950484, + "best_constant_accuracy_ppm": 508463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941905, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931167, + "best_constant_accuracy_ppm": 508463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937683, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863488, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 491536, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 485026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482394, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 791, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26041, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 498284, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 479083, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 820312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817081, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 276, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309245, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 947303, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 726109, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 960286, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 960223, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 61, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 449219, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968137, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957416, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 941754, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 89, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 430990, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968137, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 488932, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 498697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499083, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 770, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 479679, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 811197, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813532, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926970, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 707158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950070, + "best_constant_accuracy_ppm": 507812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948398, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949942, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 57 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 932641, + "best_constant_accuracy_ppm": 507812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948398, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880099, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 507812, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 511718, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514192, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 750, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 531250, + "final_window_balanced_accuracy_ppm": 533887, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496117, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 817708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 819685, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 310547, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931734, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696461, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953831, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 954122, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937219, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 938371, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 95, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 430990, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 954122, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869793, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 507161, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 494140, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484672, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 777, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20182, + "final_window_accuracy_ppm": 500000, + "final_window_balanced_accuracy_ppm": 496368, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 488081, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 485677, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 811197, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807085, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 296875, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937312, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697731, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 485677, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952527, + "best_constant_accuracy_ppm": 514322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438151, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956997, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944048, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 485677, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 933204, + "best_constant_accuracy_ppm": 514322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 418620, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956997, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 866178, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 485677, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495639, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -10417, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 504822, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 483723, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 817057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812259, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 281, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913552, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710412, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 483723, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 962890, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 962999, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 57, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446614, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957203, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959060, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 483723, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 943950, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 86, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957203, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882937, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 483723, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 485677, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486719, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 790, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19531, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 533214, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 477105, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 494791, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811672, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 307943, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956385, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698550, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 494791, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949830, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976877, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939232, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 494791, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930256, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 976877, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 857141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 494791, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 510416, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490728, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 752, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13672, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 525017, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500511, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 475911, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801483, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 284505, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939197, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701798, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 475911, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949226, + "best_constant_accuracy_ppm": 524088, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969047, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940209, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 475911, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 932754, + "best_constant_accuracy_ppm": 524088, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 408854, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969047, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873126, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 475911, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 507161, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507073, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 757, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 1953, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 535689, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 473336, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 821614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 823154, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 274, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 316406, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 920936, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713729, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 962239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 962330, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 58, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 457031, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969084, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951666, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 944166, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 86, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969084, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875510, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 505208, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 502604, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500022, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 484432, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 498695, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 518880, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 814453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 819038, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 285, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 295573, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945298, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697184, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 518880, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950782, + "best_constant_accuracy_ppm": 518880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432291, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936775, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 518880, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 44 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 931997, + "best_constant_accuracy_ppm": 518880, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 413411, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960683, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 857336, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 518880, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501912, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 512880, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 478304, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 506510, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807128, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298828, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 901244, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699106, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 506510, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948516, + "best_constant_accuracy_ppm": 506510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945040, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941257, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 506510, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 43 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 928288, + "best_constant_accuracy_ppm": 506510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945040, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 858687, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 506510, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 527343, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 527376, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 726, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 18229, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 514259, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 547887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 509114, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 795572, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798211, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 314, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 286458, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 910381, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687293, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 509114, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939515, + "best_constant_accuracy_ppm": 509114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430339, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936150, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 509114, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 79 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 921943, + "best_constant_accuracy_ppm": 509114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 412761, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929465, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870079, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 509114, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 468750, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 468796, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 816, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33854, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 464178, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 472409, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804132, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300781, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 940246, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689568, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947914, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445312, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960571, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941036, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 40 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 930326, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 427734, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 960571, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867251, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 502604, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 496093, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494803, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 774, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9766, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 510385, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500039, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 807942, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806199, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 295, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 911900, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701854, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953102, + "best_constant_accuracy_ppm": 505859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 447266, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957355, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951330, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 935667, + "best_constant_accuracy_ppm": 505859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 957355, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879929, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 494140, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 509765, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509707, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 753, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 5208, + "final_window_accuracy_ppm": 492187, + "final_window_balanced_accuracy_ppm": 494399, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 514572, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802720, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 901447, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698723, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942010, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 437500, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 923571, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938984, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 923803, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 419271, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 923571, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865535, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 495442, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 507161, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490350, + "best_constant_accuracy_ppm": 526041, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 757, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18880, + "final_window_accuracy_ppm": 496093, + "final_window_balanced_accuracy_ppm": 496093, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 503076, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 526041, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812731, + "best_constant_accuracy_ppm": 526041, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279297, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937499, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 695657, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 526041, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948250, + "best_constant_accuracy_ppm": 526041, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953124, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936105, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 526041, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 933882, + "best_constant_accuracy_ppm": 526041, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953124, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879483, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 526041, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 513671, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496217, + "best_constant_accuracy_ppm": 522786, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 747, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 562500, + "final_window_balanced_accuracy_ppm": 494538, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517302, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 477213, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796256, + "best_constant_accuracy_ppm": 522786, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 280599, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 898208, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714227, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 477213, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949735, + "best_constant_accuracy_ppm": 522786, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 934905, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 953675, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 477213, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 929747, + "best_constant_accuracy_ppm": 522786, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 407552, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 934905, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874349, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 477213, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 492838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 483055, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 779, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24089, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 473928, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 461755, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 516927, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 806640, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811206, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 297, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289713, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 918833, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698898, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 516927, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944078, + "best_constant_accuracy_ppm": 516927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 944013, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933529, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 516927, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 47 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "balanced_accuracy_ppm": 924789, + "best_constant_accuracy_ppm": 516927, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": false, + "excess_over_constant_ppm": 407552, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 944013, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd", + "relation": "complement" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 850689, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 516927, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 753255, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499340, + "best_constant_accuracy_ppm": 783203, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 379, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29948, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 514847, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 751430, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 216796, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 879557, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 790631, + "best_constant_accuracy_ppm": 783203, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 185, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 96354, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 935900, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 828426, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 216796, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945286, + "best_constant_accuracy_ppm": 783203, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 163411, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 975374, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936908, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 216796, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 121 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 907333, + "best_constant_accuracy_ppm": 783203, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 146484, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 975374, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884548, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 216796, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 734375, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506221, + "best_constant_accuracy_ppm": 756510, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 408, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22135, + "final_window_accuracy_ppm": 703125, + "final_window_balanced_accuracy_ppm": 520622, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713934, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 243489, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 877604, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800339, + "best_constant_accuracy_ppm": 756510, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 188, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 121094, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 807935, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 243489, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946061, + "best_constant_accuracy_ppm": 756510, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 192057, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 958978, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943727, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 243489, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 82 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 909964, + "best_constant_accuracy_ppm": 756510, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 174479, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 958978, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882371, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 243489, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 712239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502074, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 442, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20833, + "final_window_accuracy_ppm": 734375, + "final_window_balanced_accuracy_ppm": 503084, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720550, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 883463, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 822806, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 179, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 150391, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 955464, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 824188, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955733, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 221355, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 955464, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 953046, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 88 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 921586, + "best_constant_accuracy_ppm": 733072, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 203125, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 955464, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888515, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 722656, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492256, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 426, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37109, + "final_window_accuracy_ppm": 750000, + "final_window_balanced_accuracy_ppm": 512142, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 716288, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 869791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798489, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 200, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 110026, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 940714, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 814005, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942120, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 94, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 179037, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 967500, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937789, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 104 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 909600, + "best_constant_accuracy_ppm": 759765, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 163412, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 967500, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886432, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 729166, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499390, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 416, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -28646, + "final_window_accuracy_ppm": 714843, + "final_window_balanced_accuracy_ppm": 511243, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 750407, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 878906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808530, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 186, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 121094, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 890031, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 838050, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948314, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 188802, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 958213, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945039, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 126 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 916056, + "best_constant_accuracy_ppm": 757812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 173177, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 958213, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895866, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 242187, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 753906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496428, + "best_constant_accuracy_ppm": 781250, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 378, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 761718, + "final_window_balanced_accuracy_ppm": 511487, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 757859, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 218750, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 880208, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 785118, + "best_constant_accuracy_ppm": 781250, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 184, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 98958, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 911487, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 833283, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 218750, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954761, + "best_constant_accuracy_ppm": 781250, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 173177, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 956942, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949738, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 218750, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 110 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 914583, + "best_constant_accuracy_ppm": 781250, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 155598, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 956942, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 894114, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 218750, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 737630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500407, + "best_constant_accuracy_ppm": 763020, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 403, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25390, + "final_window_accuracy_ppm": 714843, + "final_window_balanced_accuracy_ppm": 496088, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 765110, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 236979, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 884114, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809473, + "best_constant_accuracy_ppm": 763020, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 178, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 121094, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 951970, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 845941, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 236979, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946836, + "best_constant_accuracy_ppm": 763020, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 186198, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 959323, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944903, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 236979, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 154 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 912495, + "best_constant_accuracy_ppm": 763020, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 169922, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 959323, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 899393, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 236979, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 727864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497174, + "best_constant_accuracy_ppm": 751953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 418, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24089, + "final_window_accuracy_ppm": 710937, + "final_window_balanced_accuracy_ppm": 495932, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 727295, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 248046, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 882161, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807318, + "best_constant_accuracy_ppm": 751953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 181, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 130208, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 943693, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 827252, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 248046, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954299, + "best_constant_accuracy_ppm": 751953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203125, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 966081, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 960078, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 248046, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 83 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 919313, + "best_constant_accuracy_ppm": 751953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 184895, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 966081, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 896747, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 248046, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 727213, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500281, + "best_constant_accuracy_ppm": 748697, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 419, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 695312, + "final_window_balanced_accuracy_ppm": 506924, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 767122, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 251302, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 877604, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799504, + "best_constant_accuracy_ppm": 748697, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 188, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 128907, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 917882, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 852140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 251302, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936809, + "best_constant_accuracy_ppm": 748697, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 197917, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 938430, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956457, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 251302, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 125 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 905721, + "best_constant_accuracy_ppm": 748697, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 182292, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 938430, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 903338, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 251302, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 728515, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506510, + "best_constant_accuracy_ppm": 750000, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 417, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21485, + "final_window_accuracy_ppm": 769531, + "final_window_balanced_accuracy_ppm": 520075, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 712451, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 250000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 879557, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806857, + "best_constant_accuracy_ppm": 750000, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 185, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 129557, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 935170, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 827546, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 250000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953992, + "best_constant_accuracy_ppm": 750000, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203125, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 963472, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954978, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 250000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 917968, + "best_constant_accuracy_ppm": 750000, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 184244, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 963472, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884916, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 250000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 735026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506593, + "best_constant_accuracy_ppm": 758463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23437, + "final_window_accuracy_ppm": 726562, + "final_window_balanced_accuracy_ppm": 505208, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 742348, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 241536, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 875000, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796350, + "best_constant_accuracy_ppm": 758463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 192, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 116537, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 919270, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 820074, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 241536, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 935164, + "best_constant_accuracy_ppm": 758463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 183594, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 934895, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944985, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 241536, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 103 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 901472, + "best_constant_accuracy_ppm": 758463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 167318, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 934895, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887944, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 241536, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 668619, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484419, + "best_constant_accuracy_ppm": 705078, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 509, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -36459, + "final_window_accuracy_ppm": 687500, + "final_window_balanced_accuracy_ppm": 495168, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 652932, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 294921, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 860026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807637, + "best_constant_accuracy_ppm": 705078, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 215, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 154948, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 918779, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 791566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 294921, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 933465, + "best_constant_accuracy_ppm": 705078, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 101, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 229166, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939613, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931410, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 294921, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 914713, + "arena_version": "v0.3", + "authorization_events": [ + 91 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 901637, + "best_constant_accuracy_ppm": 705078, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 131, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 209635, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939613, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 858018, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 294921, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 714843, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493791, + "best_constant_accuracy_ppm": 745442, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 438, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 757812, + "final_window_balanced_accuracy_ppm": 502089, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 725948, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 254557, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 875651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809647, + "best_constant_accuracy_ppm": 745442, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 191, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 130209, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 915882, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 828487, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 254557, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951591, + "best_constant_accuracy_ppm": 745442, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 202474, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 967606, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942566, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 254557, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 134 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 918343, + "best_constant_accuracy_ppm": 745442, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 185547, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 967606, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890461, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 254557, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 719401, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500760, + "best_constant_accuracy_ppm": 749348, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 431, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29947, + "final_window_accuracy_ppm": 664062, + "final_window_balanced_accuracy_ppm": 483625, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 724959, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 250651, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 868489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798162, + "best_constant_accuracy_ppm": 749348, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 202, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 119141, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 891520, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 814185, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 250651, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939721, + "best_constant_accuracy_ppm": 749348, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 190105, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924414, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941467, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 250651, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 96 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 906384, + "best_constant_accuracy_ppm": 749348, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 172527, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 924414, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880965, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 250651, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 725260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501905, + "best_constant_accuracy_ppm": 748046, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 422, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22786, + "final_window_accuracy_ppm": 738281, + "final_window_balanced_accuracy_ppm": 525523, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720595, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 251953, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 875651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800355, + "best_constant_accuracy_ppm": 748046, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 191, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 127605, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 904555, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 815315, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 251953, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946350, + "best_constant_accuracy_ppm": 748046, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 201172, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936813, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944940, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 251953, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 107 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 913614, + "best_constant_accuracy_ppm": 748046, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 184245, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936813, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888850, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 251953, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 724609, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507804, + "best_constant_accuracy_ppm": 740885, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 423, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 742187, + "final_window_balanced_accuracy_ppm": 524720, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 724108, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 259114, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 886718, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 820618, + "best_constant_accuracy_ppm": 740885, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 174, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 145833, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 964114, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 841961, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 259114, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 956380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955040, + "best_constant_accuracy_ppm": 740885, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 215495, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 979266, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955585, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 259114, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [ + 92 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 922377, + "best_constant_accuracy_ppm": 740885, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 93, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 198568, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 979266, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 898464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 259114, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 715494, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497740, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 437, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20834, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 483288, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 748547, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 263671, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 886067, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 821196, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 175, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 149739, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 926950, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 851629, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 263671, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949591, + "best_constant_accuracy_ppm": 736328, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 217448, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 941035, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 962307, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 263671, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 912905, + "best_constant_accuracy_ppm": 736328, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 197265, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 941035, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 907982, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 263671, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 733723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506118, + "best_constant_accuracy_ppm": 755859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 409, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -22136, + "final_window_accuracy_ppm": 683593, + "final_window_balanced_accuracy_ppm": 507327, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 732233, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 244140, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 880859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807452, + "best_constant_accuracy_ppm": 755859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 183, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 125000, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 909924, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 814676, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 244140, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951452, + "best_constant_accuracy_ppm": 755859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 195312, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 942392, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931669, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 244140, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 122 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 914590, + "best_constant_accuracy_ppm": 755859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 176432, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 942392, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876698, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 244140, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 717447, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495323, + "best_constant_accuracy_ppm": 742838, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 434, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 493433, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720979, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 257161, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 878906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809247, + "best_constant_accuracy_ppm": 742838, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 186, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 136068, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 922004, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 817420, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 257161, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949754, + "best_constant_accuracy_ppm": 742838, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 208333, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 954472, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939956, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 257161, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 125 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 915577, + "best_constant_accuracy_ppm": 742838, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 190755, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 954472, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882823, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 257161, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 747395, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505738, + "best_constant_accuracy_ppm": 766927, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 388, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19532, + "final_window_accuracy_ppm": 710937, + "final_window_balanced_accuracy_ppm": 500749, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 780236, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 233072, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 888020, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807414, + "best_constant_accuracy_ppm": 766927, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 172, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 121093, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 911197, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 858440, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 233072, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 958984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959648, + "best_constant_accuracy_ppm": 766927, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 63, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 192057, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 948510, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 963289, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 233072, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [ + 146 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 923883, + "best_constant_accuracy_ppm": 766927, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 90, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 174479, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 948510, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 913460, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 233072, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 729817, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503071, + "best_constant_accuracy_ppm": 753255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 415, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 750000, + "final_window_balanced_accuracy_ppm": 505118, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 746093, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 246744, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 882812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813097, + "best_constant_accuracy_ppm": 753255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 180, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 129557, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 945796, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 843342, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 246744, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952939, + "best_constant_accuracy_ppm": 753255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 198567, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 971220, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951599, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 246744, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 160 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 918206, + "best_constant_accuracy_ppm": 753255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 180989, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 971220, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 897245, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 246744, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 740234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 488694, + "best_constant_accuracy_ppm": 773437, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 399, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 738281, + "final_window_balanced_accuracy_ppm": 509062, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 759820, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 226562, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 879557, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796165, + "best_constant_accuracy_ppm": 773437, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 185, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 106120, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 928416, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 840158, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 226562, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954211, + "best_constant_accuracy_ppm": 773437, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 177734, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 968739, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951291, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 226562, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 143 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 913560, + "best_constant_accuracy_ppm": 773437, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 158854, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 968739, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 897299, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 226562, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 748046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514013, + "best_constant_accuracy_ppm": 757161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 387, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 746093, + "final_window_balanced_accuracy_ppm": 527352, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 752423, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 242838, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 897786, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 822324, + "best_constant_accuracy_ppm": 757161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 157, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 140625, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 936443, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 846861, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 242838, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 964192, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959053, + "best_constant_accuracy_ppm": 757161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 55, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 207031, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 966746, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957970, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 242838, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [ + 111 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 926881, + "best_constant_accuracy_ppm": 757161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 79, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 191406, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 966746, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 908067, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 242838, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 703125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494307, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 456, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29947, + "final_window_accuracy_ppm": 707031, + "final_window_balanced_accuracy_ppm": 515226, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700881, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 875651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816702, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 191, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 142579, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944803, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 803407, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947190, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 212240, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 958887, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931724, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 95 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 918697, + "best_constant_accuracy_ppm": 733072, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 196615, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 958887, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 266927, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 713541, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502304, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 440, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26693, + "final_window_accuracy_ppm": 707031, + "final_window_balanced_accuracy_ppm": 482956, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689433, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 259765, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 873697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808948, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 194, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 133463, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 886181, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 808767, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 259765, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944286, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203776, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918439, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 259765, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 909132, + "best_constant_accuracy_ppm": 740234, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 184245, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918439, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867155, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 259765, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 708984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490651, + "best_constant_accuracy_ppm": 739583, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 447, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 656250, + "final_window_balanced_accuracy_ppm": 488592, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706947, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 260416, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 873697, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806901, + "best_constant_accuracy_ppm": 739583, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 194, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 134114, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 918972, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 815383, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 260416, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945651, + "best_constant_accuracy_ppm": 739583, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 206380, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931630, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946747, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 260416, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 75 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 908961, + "best_constant_accuracy_ppm": 739583, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 186849, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931630, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875619, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 260416, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 722005, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493996, + "best_constant_accuracy_ppm": 750651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 427, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -28646, + "final_window_accuracy_ppm": 753906, + "final_window_balanced_accuracy_ppm": 509693, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 731937, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 249348, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 876302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803396, + "best_constant_accuracy_ppm": 750651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 190, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 125651, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 951360, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 821356, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 249348, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949610, + "best_constant_accuracy_ppm": 750651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 198567, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968026, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939380, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 249348, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 114 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 915667, + "best_constant_accuracy_ppm": 750651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 181640, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 968026, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885922, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 249348, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 723307, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 513617, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 425, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 519584, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 717733, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 881510, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816610, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 182, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 142578, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 912441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 828186, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953767, + "best_constant_accuracy_ppm": 738932, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 214193, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969584, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951168, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 80 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 919660, + "best_constant_accuracy_ppm": 738932, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 195963, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969584, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887739, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 261067, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 722656, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503701, + "best_constant_accuracy_ppm": 751302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 426, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -28646, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 496687, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 750776, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 248697, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 874348, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 808675, + "best_constant_accuracy_ppm": 751302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 193, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 123046, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 920416, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 839658, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 248697, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943492, + "best_constant_accuracy_ppm": 751302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 190104, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 937365, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943396, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 248697, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 164 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 910336, + "best_constant_accuracy_ppm": 751302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 173177, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 937365, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 896850, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 248697, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 703125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506364, + "best_constant_accuracy_ppm": 720703, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 456, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 695312, + "final_window_balanced_accuracy_ppm": 509648, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710700, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 279296, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 875651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814508, + "best_constant_accuracy_ppm": 720703, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 191, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 154948, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 937280, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 815127, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 279296, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942713, + "best_constant_accuracy_ppm": 720703, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 226562, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 943859, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940354, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 279296, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 119 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 914289, + "best_constant_accuracy_ppm": 720703, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 210286, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 943859, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887749, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 279296, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 734375, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501821, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 408, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25390, + "final_window_accuracy_ppm": 730468, + "final_window_balanced_accuracy_ppm": 492933, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 752824, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 876953, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798569, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 189, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 117188, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 904223, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 840799, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946266, + "best_constant_accuracy_ppm": 759765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 188151, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 944545, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 953126, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 124 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 909680, + "best_constant_accuracy_ppm": 759765, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 170573, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 944545, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 900287, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 240234, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 707682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508195, + "best_constant_accuracy_ppm": 727213, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 449, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19531, + "final_window_accuracy_ppm": 671875, + "final_window_balanced_accuracy_ppm": 510372, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 737620, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 272786, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 875651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816071, + "best_constant_accuracy_ppm": 727213, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 191, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 148438, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 900616, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 839064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 272786, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936596, + "best_constant_accuracy_ppm": 727213, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 214193, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 918909, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937289, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 272786, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 126 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "balanced_accuracy_ppm": 908702, + "best_constant_accuracy_ppm": 727213, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 198568, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 918909, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888871, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 272786, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 694661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496186, + "best_constant_accuracy_ppm": 722005, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 469, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 628906, + "final_window_balanced_accuracy_ppm": 476676, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680696, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 722005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 729817, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791291, + "best_constant_accuracy_ppm": 722005, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 415, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 7812, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 906295, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 575664, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 722005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937819, + "best_constant_accuracy_ppm": 722005, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 219401, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 941382, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932483, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 722005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 71 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 904669, + "best_constant_accuracy_ppm": 722005, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 198567, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 941382, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856452, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 722005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 709635, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503732, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 446, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 765625, + "final_window_balanced_accuracy_ppm": 500143, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713260, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 722005, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793516, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 427, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18229, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 882639, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 557559, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941713, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 201172, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 911907, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941201, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 104 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 915947, + "best_constant_accuracy_ppm": 740234, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 182292, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 911907, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877011, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 728515, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500868, + "best_constant_accuracy_ppm": 755859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 417, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 523852, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720171, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 755859, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 732421, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805846, + "best_constant_accuracy_ppm": 755859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 411, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 967391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 556538, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 755859, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950118, + "best_constant_accuracy_ppm": 755859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 194661, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 989130, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940191, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 755859, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 103 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 922673, + "best_constant_accuracy_ppm": 755859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 177734, + "final_window_accuracy_ppm": 984375, + "final_window_balanced_accuracy_ppm": 989130, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877987, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 755859, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 716145, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508151, + "best_constant_accuracy_ppm": 736979, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 436, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20834, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 491786, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 720318, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 736979, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 736328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798030, + "best_constant_accuracy_ppm": 736979, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 405, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -651, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 899919, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 562647, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 736979, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939373, + "best_constant_accuracy_ppm": 736979, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 207682, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 923604, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936396, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 736979, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 112 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 909849, + "best_constant_accuracy_ppm": 736979, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 188802, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 923604, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870002, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 736979, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 707031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502838, + "best_constant_accuracy_ppm": 733723, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 450, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26692, + "final_window_accuracy_ppm": 746093, + "final_window_balanced_accuracy_ppm": 536138, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 686325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 742838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813073, + "best_constant_accuracy_ppm": 733723, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 395, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 9115, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 934762, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 592653, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 955043, + "best_constant_accuracy_ppm": 733723, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 217448, + "final_window_accuracy_ppm": 980468, + "final_window_balanced_accuracy_ppm": 977315, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933893, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 102 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 931381, + "best_constant_accuracy_ppm": 733723, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 199870, + "final_window_accuracy_ppm": 980468, + "final_window_balanced_accuracy_ppm": 977315, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872620, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 702473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504093, + "best_constant_accuracy_ppm": 734375, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 457, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31902, + "final_window_accuracy_ppm": 695312, + "final_window_balanced_accuracy_ppm": 498439, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 675098, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 734375, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 726562, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796620, + "best_constant_accuracy_ppm": 734375, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 420, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 876093, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 581519, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 734375, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943340, + "best_constant_accuracy_ppm": 734375, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 207682, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 913931, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938562, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 734375, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 917761, + "best_constant_accuracy_ppm": 734375, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 186197, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 913931, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 856064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 734375, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 696614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498076, + "best_constant_accuracy_ppm": 733723, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 466, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37109, + "final_window_accuracy_ppm": 710937, + "final_window_balanced_accuracy_ppm": 477931, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 666949, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 729817, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801084, + "best_constant_accuracy_ppm": 733723, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 415, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 924632, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 596624, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943941, + "best_constant_accuracy_ppm": 733723, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 93, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 205730, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 945144, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937385, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [ + 52 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 920172, + "best_constant_accuracy_ppm": 733723, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 122, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 186849, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 945144, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863421, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 733723, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 724609, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501499, + "best_constant_accuracy_ppm": 751302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 423, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26693, + "final_window_accuracy_ppm": 773437, + "final_window_balanced_accuracy_ppm": 485294, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 712105, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 751302, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803977, + "best_constant_accuracy_ppm": 751302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 412, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19532, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 919871, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 559315, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 751302, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949558, + "best_constant_accuracy_ppm": 751302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 199218, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 946832, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940365, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 751302, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 106 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 924716, + "best_constant_accuracy_ppm": 751302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 182942, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 946832, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881153, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 751302, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 738281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 515316, + "best_constant_accuracy_ppm": 762369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 402, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24088, + "final_window_accuracy_ppm": 765625, + "final_window_balanced_accuracy_ppm": 498716, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702430, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 762369, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 733723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809333, + "best_constant_accuracy_ppm": 762369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 409, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -28646, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 909149, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 587529, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 762369, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949811, + "best_constant_accuracy_ppm": 762369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 185547, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 933901, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947459, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 762369, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 84 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 919941, + "best_constant_accuracy_ppm": 762369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 167318, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 933901, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879738, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 762369, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 719401, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507173, + "best_constant_accuracy_ppm": 746744, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 431, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27343, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 510857, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714274, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 746744, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 725260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799902, + "best_constant_accuracy_ppm": 746744, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 422, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 906182, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 575176, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 746744, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947243, + "best_constant_accuracy_ppm": 746744, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 198568, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 951156, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943098, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 746744, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 83 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 919748, + "best_constant_accuracy_ppm": 746744, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 180339, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 951156, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876106, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 746744, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 721354, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496230, + "best_constant_accuracy_ppm": 753906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 428, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -32552, + "final_window_accuracy_ppm": 730468, + "final_window_balanced_accuracy_ppm": 490508, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709146, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 725911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797728, + "best_constant_accuracy_ppm": 753906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 421, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 918581, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 552101, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941079, + "best_constant_accuracy_ppm": 753906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 188151, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 938783, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939387, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 94 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 912924, + "best_constant_accuracy_ppm": 753906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 171224, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 938783, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880025, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 761718, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507290, + "best_constant_accuracy_ppm": 792317, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 366, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 785156, + "final_window_balanced_accuracy_ppm": 487059, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 745191, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 792317, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 737630, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815923, + "best_constant_accuracy_ppm": 792317, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 403, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -54687, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 964285, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 562836, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 792317, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946983, + "best_constant_accuracy_ppm": 792317, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 152995, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 976190, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935199, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 792317, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 85 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 904923, + "best_constant_accuracy_ppm": 792317, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 132162, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 976190, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865871, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 792317, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 712890, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495095, + "best_constant_accuracy_ppm": 742187, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 441, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 695312, + "final_window_balanced_accuracy_ppm": 494099, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696597, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 742187, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 736979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804678, + "best_constant_accuracy_ppm": 742187, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 404, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 906965, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 598591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 742187, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947222, + "best_constant_accuracy_ppm": 742187, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 206380, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944803, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952796, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 742187, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 917583, + "best_constant_accuracy_ppm": 742187, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 186849, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944803, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876708, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 742187, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 725911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499591, + "best_constant_accuracy_ppm": 753255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 421, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 757812, + "final_window_balanced_accuracy_ppm": 499955, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 714568, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 753255, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 736979, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810329, + "best_constant_accuracy_ppm": 753255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 404, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16276, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 944767, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 553338, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 753255, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952075, + "best_constant_accuracy_ppm": 753255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 197265, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964868, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934825, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 753255, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 126 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 923097, + "best_constant_accuracy_ppm": 753255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 180338, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964868, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876823, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 753255, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 722005, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504226, + "best_constant_accuracy_ppm": 749348, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 427, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27343, + "final_window_accuracy_ppm": 675781, + "final_window_balanced_accuracy_ppm": 473962, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 727170, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 749348, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813689, + "best_constant_accuracy_ppm": 749348, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14322, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 926574, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 559846, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 749348, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959215, + "best_constant_accuracy_ppm": 749348, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203777, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 945391, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951163, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 749348, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 93 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 932358, + "best_constant_accuracy_ppm": 749348, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 185547, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 945391, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888132, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 749348, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 745442, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502854, + "best_constant_accuracy_ppm": 772135, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 391, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -26693, + "final_window_accuracy_ppm": 734375, + "final_window_balanced_accuracy_ppm": 510416, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 746294, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 772135, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 742187, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 822982, + "best_constant_accuracy_ppm": 772135, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 396, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29948, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 960937, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 571137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 772135, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 960840, + "best_constant_accuracy_ppm": 772135, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 182943, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 979166, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 772135, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 119 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 922011, + "best_constant_accuracy_ppm": 772135, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 163411, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 979166, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 772135, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 718098, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504751, + "best_constant_accuracy_ppm": 751953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 433, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33855, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 489966, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696896, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 751953, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811091, + "best_constant_accuracy_ppm": 751953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 412, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20183, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 916440, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 582325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 751953, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954381, + "best_constant_accuracy_ppm": 751953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 195312, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 942346, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 751953, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 928649, + "best_constant_accuracy_ppm": 751953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 175130, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 942346, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875539, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 751953, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 709635, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493972, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 446, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -30599, + "final_window_accuracy_ppm": 738281, + "final_window_balanced_accuracy_ppm": 491892, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698437, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800685, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 875942, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 564975, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941406, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 203125, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905354, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933588, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 86 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 909506, + "best_constant_accuracy_ppm": 740234, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 183594, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905354, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861507, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 733723, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505140, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 409, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24089, + "final_window_accuracy_ppm": 773437, + "final_window_balanced_accuracy_ppm": 505021, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 710561, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 757812, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 738281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809943, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 402, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -19531, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 897321, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 584422, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 757812, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951695, + "best_constant_accuracy_ppm": 757812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 195313, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 926589, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948728, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 757812, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 81 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 918315, + "best_constant_accuracy_ppm": 757812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 173828, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 926589, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871457, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 757812, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 714843, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500743, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 438, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -25391, + "final_window_accuracy_ppm": 765625, + "final_window_balanced_accuracy_ppm": 496700, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 672807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735026, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806379, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 407, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -5208, + "final_window_accuracy_ppm": 878906, + "final_window_balanced_accuracy_ppm": 888790, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 588672, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954576, + "best_constant_accuracy_ppm": 740234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 214193, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 930662, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948906, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 62 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 927556, + "best_constant_accuracy_ppm": 740234, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 194661, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 930662, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874294, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 740234, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 710937, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491881, + "best_constant_accuracy_ppm": 744140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 444, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 498748, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680435, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 744140, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 736328, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806138, + "best_constant_accuracy_ppm": 744140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 405, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7812, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 950719, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 581123, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 744140, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946120, + "best_constant_accuracy_ppm": 744140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 200521, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969336, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929449, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 744140, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 76 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 914233, + "best_constant_accuracy_ppm": 744140, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 181641, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 969336, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861302, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 744140, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 705078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501067, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 453, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27994, + "final_window_accuracy_ppm": 703125, + "final_window_balanced_accuracy_ppm": 501811, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 681776, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 733072, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 744791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815075, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 392, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 11719, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 912137, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 594893, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 733072, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958059, + "best_constant_accuracy_ppm": 733072, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 221355, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 939311, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952517, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 733072, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 935101, + "best_constant_accuracy_ppm": 733072, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 202474, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 939311, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878358, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 733072, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 722656, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495312, + "best_constant_accuracy_ppm": 753906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 426, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 734375, + "final_window_balanced_accuracy_ppm": 505208, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709561, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 740885, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818351, + "best_constant_accuracy_ppm": 753906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 398, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13021, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 932291, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 579406, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 959974, + "best_constant_accuracy_ppm": 753906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 200521, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 966145, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949131, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 83 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 929201, + "best_constant_accuracy_ppm": 753906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 180989, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 966145, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875517, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 753906, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 730468, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495322, + "best_constant_accuracy_ppm": 758463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 414, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 722656, + "final_window_balanced_accuracy_ppm": 476804, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 728376, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 758463, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 744791, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814307, + "best_constant_accuracy_ppm": 758463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 392, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -13672, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 932324, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 591214, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 758463, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950359, + "best_constant_accuracy_ppm": 758463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 192708, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 960674, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948672, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 758463, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 108 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 918992, + "best_constant_accuracy_ppm": 758463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 175781, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 960674, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890906, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 758463, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 735677, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500483, + "best_constant_accuracy_ppm": 760416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 406, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24739, + "final_window_accuracy_ppm": 679687, + "final_window_balanced_accuracy_ppm": 477052, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 741597, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 760416, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 741536, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813299, + "best_constant_accuracy_ppm": 760416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 397, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -18880, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 905494, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 570013, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 760416, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952854, + "best_constant_accuracy_ppm": 760416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 193360, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935386, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945813, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 760416, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 136 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 923112, + "best_constant_accuracy_ppm": 760416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 176432, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 935386, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889584, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 760416, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 713541, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498812, + "best_constant_accuracy_ppm": 745442, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 440, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31901, + "final_window_accuracy_ppm": 750000, + "final_window_balanced_accuracy_ppm": 475657, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 708600, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 745442, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 728515, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803588, + "best_constant_accuracy_ppm": 745442, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 417, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 909564, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 574807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 745442, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947256, + "best_constant_accuracy_ppm": 745442, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 197266, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 926637, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938443, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 745442, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 116 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 910951, + "best_constant_accuracy_ppm": 745442, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 175781, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 926637, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869665, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 745442, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 716145, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497009, + "best_constant_accuracy_ppm": 747395, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 436, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 718750, + "final_window_balanced_accuracy_ppm": 485201, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 709813, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 747395, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 733072, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806072, + "best_constant_accuracy_ppm": 747395, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 410, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 921682, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 565026, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 747395, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949800, + "best_constant_accuracy_ppm": 747395, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 200521, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 944878, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951878, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 747395, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 97 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 917947, + "best_constant_accuracy_ppm": 747395, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 179688, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 944878, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878141, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 747395, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 747395, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507754, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 388, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 734375, + "final_window_balanced_accuracy_ppm": 491156, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 748826, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 770833, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731119, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802633, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 413, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 913775, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 580372, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 770833, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944525, + "best_constant_accuracy_ppm": 770833, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 179036, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949489, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954449, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 770833, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 133 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 909474, + "best_constant_accuracy_ppm": 770833, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 158854, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949489, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886377, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 770833, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 725260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511410, + "best_constant_accuracy_ppm": 746093, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 422, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20833, + "final_window_accuracy_ppm": 726562, + "final_window_balanced_accuracy_ppm": 494791, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693163, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 746093, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 725911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791790, + "best_constant_accuracy_ppm": 746093, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 421, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -20182, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 890625, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 579009, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 746093, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938823, + "best_constant_accuracy_ppm": 746093, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 199219, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 924479, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944970, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 746093, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 911383, + "best_constant_accuracy_ppm": 746093, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 180990, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 924479, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 873423, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 746093, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 729166, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487325, + "best_constant_accuracy_ppm": 768229, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 416, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39063, + "final_window_accuracy_ppm": 746093, + "final_window_balanced_accuracy_ppm": 479556, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 713933, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 768229, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 730468, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805941, + "best_constant_accuracy_ppm": 768229, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 414, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37761, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 953611, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 558722, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 768229, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944077, + "best_constant_accuracy_ppm": 768229, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 174479, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 961037, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935839, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 768229, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 81 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 919062, + "best_constant_accuracy_ppm": 768229, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 160156, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 961037, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882457, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 768229, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 718750, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504955, + "best_constant_accuracy_ppm": 748697, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 432, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29947, + "final_window_accuracy_ppm": 746093, + "final_window_balanced_accuracy_ppm": 498677, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698735, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 748697, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731119, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804944, + "best_constant_accuracy_ppm": 748697, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 413, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -17578, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 918407, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 576179, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 748697, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948857, + "best_constant_accuracy_ppm": 748697, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 197917, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946045, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943087, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 748697, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 78 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 921184, + "best_constant_accuracy_ppm": 748697, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 178386, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 946045, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867569, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 748697, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 731770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501632, + "best_constant_accuracy_ppm": 764322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 412, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -32552, + "final_window_accuracy_ppm": 753906, + "final_window_balanced_accuracy_ppm": 485461, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 692599, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 764322, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 740234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814782, + "best_constant_accuracy_ppm": 764322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 399, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -24088, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 934146, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 601477, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 764322, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948939, + "best_constant_accuracy_ppm": 764322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 180990, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 965853, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939984, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 764322, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 89 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1" + ], + "balanced_accuracy_ppm": 923433, + "best_constant_accuracy_ppm": 764322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 119, + "scaffold_candidate_count": 105, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 165365, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 965853, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:1e16c78aa8c8acf644e5f604243feb889a524bda9966a6b6aaa02e9702041bb1", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 764322, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 499348, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 488801, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 769, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 493465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 497795, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803212, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285808, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 930564, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 668068, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942629, + "best_constant_accuracy_ppm": 513671, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429037, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 931284, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927171, + "best_constant_accuracy_ppm": 513671, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413412, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 953465, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 867109, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 513671, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 514322, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 516200, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 746, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 7161, + "final_window_accuracy_ppm": 535156, + "final_window_balanced_accuracy_ppm": 536534, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507644, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 492838, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799292, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294271, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925097, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 689971, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 492838, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947245, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 440104, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949290, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946893, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 492838, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 70 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 928788, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949290, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878881, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 492838, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 492838, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 488136, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 779, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503543, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 492606, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 807291, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809396, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 296, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 300130, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929129, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696442, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948677, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945258, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951402, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 931236, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945258, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878264, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 521484, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 504518, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 735, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3255, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 504981, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 532413, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 524739, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 811197, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817580, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 286458, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941163, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 691820, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 524739, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947853, + "best_constant_accuracy_ppm": 524739, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956201, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936977, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 524739, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 75 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 934179, + "best_constant_accuracy_ppm": 524739, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 409505, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 956201, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884251, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 524739, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 478515, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 478215, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 801, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23438, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 468458, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 474048, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 801432, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801991, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 305, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 299479, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 895114, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 693148, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943366, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 441406, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937099, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932143, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 926438, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937099, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 861879, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 527994, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 527935, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 725, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 26692, + "final_window_accuracy_ppm": 542968, + "final_window_balanced_accuracy_ppm": 543980, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 527959, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 798828, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799221, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 309, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905309, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680286, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947922, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446614, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925801, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946933, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 929659, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925801, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878089, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 508463, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498077, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 755, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 511718, + "final_window_balanced_accuracy_ppm": 490273, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513017, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 483723, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803680, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292317, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 928064, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703470, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 483723, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945672, + "best_constant_accuracy_ppm": 516276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429687, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944457, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936565, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 483723, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 926999, + "best_constant_accuracy_ppm": 516276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 411458, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 944457, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 865927, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 483723, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 502604, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493045, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -8463, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 503906, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511812, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800030, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 292318, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937500, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700804, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950496, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 439453, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964843, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940806, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 68 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 932520, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 421875, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964843, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879405, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 502604, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502234, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 764, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9765, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 502259, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505164, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 512369, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 802083, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805862, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 304, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 289714, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945648, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 698753, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 512369, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944998, + "best_constant_accuracy_ppm": 512369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432292, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964732, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946068, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 512369, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927425, + "best_constant_accuracy_ppm": 512369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414714, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 964732, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875280, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 512369, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 473307, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 473295, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 809, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 507812, + "final_window_balanced_accuracy_ppm": 510996, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 464884, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 500651, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 804036, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804224, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 301, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 896260, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 704770, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 500651, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944016, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945502, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938289, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 500651, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 53 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927084, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 945502, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869731, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 500651, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 488281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 487229, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 786, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -14323, + "final_window_accuracy_ppm": 460937, + "final_window_balanced_accuracy_ppm": 459016, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508625, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 497395, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 805989, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805237, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 298, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 303385, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921335, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706106, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 497395, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948562, + "best_constant_accuracy_ppm": 502604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937728, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952017, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 497395, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 931614, + "best_constant_accuracy_ppm": 502604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 429036, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937728, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887807, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 497395, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 501302, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496385, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 766, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9765, + "final_window_accuracy_ppm": 472656, + "final_window_balanced_accuracy_ppm": 487459, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507513, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 802734, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799767, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 303, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 291667, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925801, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 694484, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 941578, + "best_constant_accuracy_ppm": 511067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 430339, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936995, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939167, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 926090, + "best_constant_accuracy_ppm": 511067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414714, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 936995, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872767, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 488932, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 507812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502018, + "best_constant_accuracy_ppm": 523437, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -15625, + "final_window_accuracy_ppm": 523437, + "final_window_balanced_accuracy_ppm": 486735, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 523506, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 476562, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796590, + "best_constant_accuracy_ppm": 523437, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 279948, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 931650, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 687478, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 476562, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947546, + "best_constant_accuracy_ppm": 523437, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423828, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952836, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942538, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 476562, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 60 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927544, + "best_constant_accuracy_ppm": 523437, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 404297, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952836, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 869851, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 476562, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 488932, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 482210, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 785, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -21484, + "final_window_accuracy_ppm": 468750, + "final_window_balanced_accuracy_ppm": 477450, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505738, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 797526, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 794683, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 311, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 287110, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921568, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702194, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 940295, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 429688, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 943627, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935032, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 63 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 923971, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 413412, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 943627, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 871915, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 498046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496516, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 457031, + "final_window_balanced_accuracy_ppm": 455437, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505456, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 808593, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810624, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 294, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 301432, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 895134, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697591, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951831, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925209, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952448, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 934296, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 427083, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 925209, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881709, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 466796, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 465888, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 819, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -36459, + "final_window_accuracy_ppm": 472656, + "final_window_balanced_accuracy_ppm": 475217, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 459223, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 496744, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804393, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302083, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 906487, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 699903, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 496744, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945284, + "best_constant_accuracy_ppm": 503255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442057, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937495, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945071, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 496744, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 41 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 926365, + "best_constant_accuracy_ppm": 503255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937495, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 863345, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 496744, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 514322, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493923, + "best_constant_accuracy_ppm": 523437, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 746, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9115, + "final_window_accuracy_ppm": 484375, + "final_window_balanced_accuracy_ppm": 491452, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513285, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 523437, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 800130, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807183, + "best_constant_accuracy_ppm": 523437, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 307, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 276693, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 913674, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 672322, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 523437, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947108, + "best_constant_accuracy_ppm": 523437, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 423177, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941452, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938332, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 523437, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 930521, + "best_constant_accuracy_ppm": 523437, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 406901, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 941452, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872527, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 523437, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 535156, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505761, + "best_constant_accuracy_ppm": 537109, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 714, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -1953, + "final_window_accuracy_ppm": 593750, + "final_window_balanced_accuracy_ppm": 524774, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518634, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 462890, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 820963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809817, + "best_constant_accuracy_ppm": 537109, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 275, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 283854, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 904404, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 721129, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 462890, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956793, + "best_constant_accuracy_ppm": 537109, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 419922, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 941441, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949431, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 462890, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [ + 58 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 940109, + "best_constant_accuracy_ppm": 537109, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 90, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 404297, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 941441, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889084, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 462890, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 497395, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498846, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 772, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 527343, + "final_window_balanced_accuracy_ppm": 532957, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 472308, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 505208, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804937, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 933898, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 675057, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 505208, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949911, + "best_constant_accuracy_ppm": 505208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 444661, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962675, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 929204, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 505208, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 50 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 931639, + "best_constant_accuracy_ppm": 505208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 962675, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 857488, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 505208, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 498046, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497807, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 771, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3907, + "final_window_accuracy_ppm": 570312, + "final_window_balanced_accuracy_ppm": 570877, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 488603, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 811197, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811754, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 290, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309244, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 902041, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 711192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 956380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956371, + "best_constant_accuracy_ppm": 501953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 454427, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942691, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958893, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 938851, + "best_constant_accuracy_ppm": 501953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 436849, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942691, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 890175, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 501953, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 500000, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498664, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 768, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -4557, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 499388, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 518464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 495442, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 817057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815813, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 281, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 312500, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933650, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 716872, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 495442, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950504, + "best_constant_accuracy_ppm": 504557, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445963, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948802, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946980, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 495442, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 932812, + "best_constant_accuracy_ppm": 504557, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 948802, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879536, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 495442, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 493489, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494004, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 778, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -7813, + "final_window_accuracy_ppm": 476562, + "final_window_balanced_accuracy_ppm": 518408, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 515888, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810923, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309244, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 932963, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 697075, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952481, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451171, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961331, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945410, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 64 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 934912, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 961331, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877259, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 507812, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507816, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 756, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3906, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 488438, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 522060, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488281, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 817708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814218, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305990, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 907572, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 706617, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488281, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 958333, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958218, + "best_constant_accuracy_ppm": 511718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 64, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 446615, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952654, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952670, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488281, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [ + 61 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 942432, + "best_constant_accuracy_ppm": 511718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 88, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 430990, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952654, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 892920, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 488281, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 528645, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503398, + "best_constant_accuracy_ppm": 532552, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 724, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3907, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 496642, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 535336, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 532552, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 818359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 826482, + "best_constant_accuracy_ppm": 532552, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 279, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 285807, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 929791, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 696305, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 532552, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 957031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956677, + "best_constant_accuracy_ppm": 532552, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 66, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 424479, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949022, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945312, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 532552, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 66 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 938796, + "best_constant_accuracy_ppm": 532552, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 406250, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949022, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877993, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 532552, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 483072, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 477583, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 794, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27344, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 492745, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 477907, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 805338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802580, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 299, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 294922, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 905111, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 702329, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943537, + "best_constant_accuracy_ppm": 510416, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 432943, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942301, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937290, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 925409, + "best_constant_accuracy_ppm": 510416, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 414714, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942301, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 864907, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 489583, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 472656, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 472519, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 810, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -27995, + "final_window_accuracy_ppm": 441406, + "final_window_balanced_accuracy_ppm": 440242, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 499949, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 499348, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 798177, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797979, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 310, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921808, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703963, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 499348, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944003, + "best_constant_accuracy_ppm": 500651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 443359, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937556, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947457, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 499348, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 56 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 925758, + "best_constant_accuracy_ppm": 500651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 937556, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877018, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 499348, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 500651, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500240, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 767, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -6510, + "final_window_accuracy_ppm": 449218, + "final_window_balanced_accuracy_ppm": 442683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510089, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 809895, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811964, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 292, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 302734, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 931000, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 683248, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953170, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 445964, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949657, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947816, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 55 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 935673, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 428385, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 949657, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878036, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 516276, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497093, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 743, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -9114, + "final_window_accuracy_ppm": 546875, + "final_window_balanced_accuracy_ppm": 500462, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516326, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 474609, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 803385, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795783, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 302, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 277995, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 909157, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 701827, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 474609, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945989, + "best_constant_accuracy_ppm": 525390, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 420573, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946518, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 474609, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 54 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 928862, + "best_constant_accuracy_ppm": 525390, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 402995, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952636, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 875438, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 474609, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 484375, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 484944, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 792, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -16927, + "final_window_accuracy_ppm": 515625, + "final_window_balanced_accuracy_ppm": 515506, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 473918, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 799479, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799847, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 308, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 298177, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 918253, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 680889, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944003, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 86, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952868, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936562, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 927735, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 426432, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952868, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 870121, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 501302, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 514973, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512242, + "best_constant_accuracy_ppm": 517578, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 745, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -2605, + "final_window_accuracy_ppm": 464843, + "final_window_balanced_accuracy_ppm": 461355, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 524297, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 482421, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 815104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809879, + "best_constant_accuracy_ppm": 517578, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 284, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 297526, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 921733, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 703440, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 482421, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 956380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956303, + "best_constant_accuracy_ppm": 517578, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 67, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 438802, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933638, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 954654, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 482421, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [ + 51 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 939754, + "best_constant_accuracy_ppm": 517578, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 92, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 422526, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933638, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 891395, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 482421, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 505859, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505813, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 759, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 4557, + "final_window_accuracy_ppm": 488281, + "final_window_balanced_accuracy_ppm": 489539, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 516946, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 810546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810173, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 291, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 309244, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 947026, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 700351, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953124, + "best_constant_accuracy_ppm": 501302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 451823, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 973146, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948766, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 59 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 934851, + "best_constant_accuracy_ppm": 501302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 433593, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 973146, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 878438, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 498697, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 503906, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507348, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 762, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -3255, + "final_window_accuracy_ppm": 503906, + "final_window_balanced_accuracy_ppm": 502103, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510737, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 813151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 815154, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 287, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 305990, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 900952, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 731287, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949943, + "best_constant_accuracy_ppm": 507161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 442708, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942910, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949403, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 46 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "balanced_accuracy_ppm": 932426, + "best_constant_accuracy_ppm": 507161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 425130, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 942910, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 879219, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 507161, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 856770, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496316, + "best_constant_accuracy_ppm": 899739, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 220, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42969, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 523317, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 858325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 100260, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 914713, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 785277, + "best_constant_accuracy_ppm": 899739, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 131, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 14974, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 916174, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 891607, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 100260, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950861, + "best_constant_accuracy_ppm": 899739, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 80, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 48177, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 987603, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939205, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 100260, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 299 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 869330, + "best_constant_accuracy_ppm": 899739, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 31250, + "final_window_accuracy_ppm": 976562, + "final_window_balanced_accuracy_ppm": 987603, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 901142, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 100260, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 847656, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503037, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 234, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39062, + "final_window_accuracy_ppm": 816406, + "final_window_balanced_accuracy_ppm": 522814, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 833098, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 912109, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 787520, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 135, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 25391, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 943867, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 876220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942692, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 60547, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 970183, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941382, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 158 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 865106, + "best_constant_accuracy_ppm": 886718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 42969, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 970183, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889216, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 822265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507918, + "best_constant_accuracy_ppm": 852213, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 273, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29948, + "final_window_accuracy_ppm": 843750, + "final_window_balanced_accuracy_ppm": 524757, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 819258, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 147786, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 918619, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 833909, + "best_constant_accuracy_ppm": 852213, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 125, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 66406, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 967614, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 881683, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 147786, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952852, + "best_constant_accuracy_ppm": 852213, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 101563, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 967614, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947400, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 147786, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 893381, + "best_constant_accuracy_ppm": 852213, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 83984, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 967614, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 892846, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 147786, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 833333, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491026, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 256, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -50130, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 518684, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 832817, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 906250, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 803876, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 144, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 22787, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 949718, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 880744, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949127, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 56641, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 966960, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942047, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 194 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 870546, + "best_constant_accuracy_ppm": 883463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 37760, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 966960, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895469, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 850260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508939, + "best_constant_accuracy_ppm": 889322, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 230, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39062, + "final_window_accuracy_ppm": 847656, + "final_window_balanced_accuracy_ppm": 552359, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 856919, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 110677, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 914062, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797174, + "best_constant_accuracy_ppm": 889322, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 132, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 24740, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 919026, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 894610, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 110677, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947174, + "best_constant_accuracy_ppm": 889322, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 57943, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 969026, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 946220, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 110677, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 300 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 876220, + "best_constant_accuracy_ppm": 889322, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 41667, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 969026, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 907927, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 110677, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 865234, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500821, + "best_constant_accuracy_ppm": 900390, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 207, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35156, + "final_window_accuracy_ppm": 867187, + "final_window_balanced_accuracy_ppm": 494949, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 871711, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 99609, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919270, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 772063, + "best_constant_accuracy_ppm": 900390, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 124, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 18880, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 904040, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 903098, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 99609, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948534, + "best_constant_accuracy_ppm": 900390, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 54037, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 949494, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952728, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 99609, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 937500, + "arena_version": "v0.3", + "authorization_events": [ + 325 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 863566, + "best_constant_accuracy_ppm": 900390, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 96, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 37110, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 949494, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 911280, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 99609, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 852864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499481, + "best_constant_accuracy_ppm": 891276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 226, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -38412, + "final_window_accuracy_ppm": 828125, + "final_window_balanced_accuracy_ppm": 479638, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 866606, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 108723, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 916666, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 792894, + "best_constant_accuracy_ppm": 891276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 128, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 25390, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 951066, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 898275, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 108723, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939601, + "best_constant_accuracy_ppm": 891276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 57291, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 951066, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943829, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 108723, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 283 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 864751, + "best_constant_accuracy_ppm": 891276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 41015, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 951066, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 907541, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 108723, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 849609, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500466, + "best_constant_accuracy_ppm": 882812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 231, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 843750, + "final_window_balanced_accuracy_ppm": 490809, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 847568, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 117187, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 920572, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 800835, + "best_constant_accuracy_ppm": 882812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 122, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 37760, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 939085, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 895305, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 117187, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 955729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950835, + "best_constant_accuracy_ppm": 882812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 68, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 72917, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 956326, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955910, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 117187, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 939453, + "arena_version": "v0.3", + "authorization_events": [ + 189 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 883800, + "best_constant_accuracy_ppm": 882812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 93, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 56641, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 956326, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 907524, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 117187, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 850911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509180, + "best_constant_accuracy_ppm": 880208, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 229, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 800781, + "final_window_balanced_accuracy_ppm": 507676, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 882729, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 119791, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802659, + "best_constant_accuracy_ppm": 880208, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 121, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 41015, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 912438, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 914613, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 119791, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938528, + "best_constant_accuracy_ppm": 880208, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 73568, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 936248, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 959781, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 119791, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [ + 316 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 876028, + "best_constant_accuracy_ppm": 880208, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 94, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 58594, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 936248, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 924631, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 119791, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 835937, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 510480, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 252, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33203, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 537620, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 822915, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 914713, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811475, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 131, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 45573, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 937620, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 888924, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953266, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 82682, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 970954, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 955155, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 167 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 885728, + "best_constant_accuracy_ppm": 869140, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 64453, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 970954, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 900280, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 839192, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499975, + "best_constant_accuracy_ppm": 880859, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 247, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -41667, + "final_window_accuracy_ppm": 828125, + "final_window_balanced_accuracy_ppm": 486607, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 844960, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 119140, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 908203, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 789592, + "best_constant_accuracy_ppm": 880859, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 141, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 27344, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 908482, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 882701, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 119140, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 923472, + "best_constant_accuracy_ppm": 880859, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 59245, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 924107, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943314, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 119140, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 225 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 857529, + "best_constant_accuracy_ppm": 880859, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 42969, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 924107, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 898325, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 119140, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 796223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 490480, + "best_constant_accuracy_ppm": 839843, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 313, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -43620, + "final_window_accuracy_ppm": 800781, + "final_window_balanced_accuracy_ppm": 506352, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 794099, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 160156, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 901692, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 818103, + "best_constant_accuracy_ppm": 839843, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 151, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 920986, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 866634, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 160156, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 938802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 933957, + "best_constant_accuracy_ppm": 839843, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 94, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 98959, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 933181, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933466, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 160156, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [ + 267 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 880724, + "best_constant_accuracy_ppm": 839843, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 121, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 81380, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 933181, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 881482, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 160156, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 832682, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496369, + "best_constant_accuracy_ppm": 873697, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 257, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -41015, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 498448, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 845623, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 126302, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 912109, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810802, + "best_constant_accuracy_ppm": 873697, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 135, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 38412, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 884162, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 895031, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 126302, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947400, + "best_constant_accuracy_ppm": 873697, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 72917, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 955591, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 939968, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 126302, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 326 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 882967, + "best_constant_accuracy_ppm": 873697, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 56641, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 955591, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 904302, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 126302, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 827473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489514, + "best_constant_accuracy_ppm": 878255, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 265, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -50782, + "final_window_accuracy_ppm": 792968, + "final_window_balanced_accuracy_ppm": 491831, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831117, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 121744, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 900390, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 788980, + "best_constant_accuracy_ppm": 878255, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 153, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 22135, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 882075, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 875346, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 121744, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 933365, + "best_constant_accuracy_ppm": 878255, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 99, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 57291, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 943051, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935894, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 121744, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919921, + "arena_version": "v0.3", + "authorization_events": [ + 168 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 869194, + "best_constant_accuracy_ppm": 878255, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 123, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 41666, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 943051, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 892088, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 121744, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 833984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500673, + "best_constant_accuracy_ppm": 869791, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 255, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35807, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 533480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 836765, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 130208, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910807, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 795673, + "best_constant_accuracy_ppm": 869791, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 137, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 41016, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 886292, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 130208, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943173, + "best_constant_accuracy_ppm": 869791, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 79427, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952897, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 130208, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 231 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 869176, + "best_constant_accuracy_ppm": 869791, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 57943, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 933480, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 900411, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 130208, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 830729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508279, + "best_constant_accuracy_ppm": 860026, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 260, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -29297, + "final_window_accuracy_ppm": 820312, + "final_window_balanced_accuracy_ppm": 506481, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831481, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 921223, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 831534, + "best_constant_accuracy_ppm": 860026, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 121, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 61197, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 981481, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 897242, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952465, + "best_constant_accuracy_ppm": 860026, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 95052, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 981481, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 158 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 895137, + "best_constant_accuracy_ppm": 860026, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 76822, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 981481, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 904389, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 841796, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 497441, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 243, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31250, + "final_window_accuracy_ppm": 820312, + "final_window_balanced_accuracy_ppm": 462555, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 855364, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 919921, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805133, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 123, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 46875, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 928072, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 910437, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943595, + "best_constant_accuracy_ppm": 873046, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 82032, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 945313, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 963513, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 251 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 871800, + "best_constant_accuracy_ppm": 873046, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 63802, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 945313, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 924232, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 126953, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 839192, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 489493, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 247, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -44271, + "final_window_accuracy_ppm": 804687, + "final_window_balanced_accuracy_ppm": 510013, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831875, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910156, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793962, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 138, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 26693, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 902870, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 870621, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 945312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944800, + "best_constant_accuracy_ppm": 883463, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 84, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 926679, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 930403, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 927734, + "arena_version": "v0.3", + "authorization_events": [ + 223 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 869381, + "best_constant_accuracy_ppm": 883463, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 111, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 44271, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 926679, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886819, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 116536, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 824218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 492811, + "best_constant_accuracy_ppm": 860026, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 270, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35808, + "final_window_accuracy_ppm": 781250, + "final_window_balanced_accuracy_ppm": 478468, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 833156, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 914062, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813741, + "best_constant_accuracy_ppm": 860026, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 132, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 54036, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 925277, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 881544, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 952473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950951, + "best_constant_accuracy_ppm": 860026, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 73, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 92447, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 967830, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941330, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 225 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 887403, + "best_constant_accuracy_ppm": 860026, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 73567, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 967830, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 896169, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 139973, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 850260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500380, + "best_constant_accuracy_ppm": 884114, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 230, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33854, + "final_window_accuracy_ppm": 820312, + "final_window_balanced_accuracy_ppm": 513143, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 872031, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 115885, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 917317, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 789706, + "best_constant_accuracy_ppm": 884114, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 127, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 33203, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 905034, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 908590, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 115885, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947009, + "best_constant_accuracy_ppm": 884114, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 69662, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 932061, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 958052, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 115885, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 257 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 873975, + "best_constant_accuracy_ppm": 884114, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 52734, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 932061, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 920394, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 115885, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 845703, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 505663, + "best_constant_accuracy_ppm": 882161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 237, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -36458, + "final_window_accuracy_ppm": 855468, + "final_window_balanced_accuracy_ppm": 513421, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 861746, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 117838, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 916666, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806768, + "best_constant_accuracy_ppm": 882161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 128, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 34505, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 946754, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 904444, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 117838, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953177, + "best_constant_accuracy_ppm": 882161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 69010, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 963421, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952610, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 117838, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 319 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 866803, + "best_constant_accuracy_ppm": 882161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 47526, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 963421, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 907327, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 117838, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 854166, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 491302, + "best_constant_accuracy_ppm": 893880, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 224, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 835937, + "final_window_balanced_accuracy_ppm": 489462, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 871075, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 106119, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 917968, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791915, + "best_constant_accuracy_ppm": 893880, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 126, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 24088, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 892687, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 908522, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 106119, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948357, + "best_constant_accuracy_ppm": 893880, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 57291, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 957203, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 953585, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 106119, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 364 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 861739, + "best_constant_accuracy_ppm": 893880, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 37760, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 957203, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 912126, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 106119, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 863281, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514354, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 210, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -23437, + "final_window_accuracy_ppm": 855468, + "final_window_balanced_accuracy_ppm": 530603, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 866501, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810331, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 107, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 43620, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 912956, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 910936, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 961588, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948262, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 59, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 74870, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 971780, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 956732, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 944010, + "arena_version": "v0.3", + "authorization_events": [ + 234 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 873183, + "best_constant_accuracy_ppm": 886718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 86, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 57292, + "final_window_accuracy_ppm": 972656, + "final_window_balanced_accuracy_ppm": 971780, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 913444, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 113281, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 828125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 502384, + "best_constant_accuracy_ppm": 867187, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 264, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39062, + "final_window_accuracy_ppm": 828125, + "final_window_balanced_accuracy_ppm": 514838, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 824394, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 132812, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 913411, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 821387, + "best_constant_accuracy_ppm": 867187, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 133, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 46224, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 956014, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 874051, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 132812, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948838, + "best_constant_accuracy_ppm": 867187, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 80078, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 970720, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934510, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 132812, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 894541, + "best_constant_accuracy_ppm": 867187, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 65104, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 970720, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888366, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 132812, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 817708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496109, + "best_constant_accuracy_ppm": 861979, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 280, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -44271, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 482039, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 791076, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 138020, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 903645, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805449, + "best_constant_accuracy_ppm": 861979, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 148, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 41666, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 877873, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 862162, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 138020, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 940104, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937524, + "best_constant_accuracy_ppm": 861979, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 92, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 898706, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938506, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 138020, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 107 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 875448, + "best_constant_accuracy_ppm": 861979, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 59896, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 898706, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 874544, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 138020, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 826822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 486220, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 266, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42318, + "final_window_accuracy_ppm": 769531, + "final_window_balanced_accuracy_ppm": 473627, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 820142, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 911458, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809603, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 136, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 42318, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 916809, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 877163, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 946419, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 928173, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945670, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 929687, + "arena_version": "v0.3", + "authorization_events": [ + 153 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 879255, + "best_constant_accuracy_ppm": 869140, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 108, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 60547, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 928173, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888318, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 130859, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 835286, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 493190, + "best_constant_accuracy_ppm": 874348, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 253, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39062, + "final_window_accuracy_ppm": 863281, + "final_window_balanced_accuracy_ppm": 517846, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 839138, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 125651, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 916015, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814433, + "best_constant_accuracy_ppm": 874348, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 129, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 41667, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 934513, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 887717, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 125651, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 956920, + "best_constant_accuracy_ppm": 874348, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 77474, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 967846, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941619, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 125651, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 259 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 894744, + "best_constant_accuracy_ppm": 874348, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 967846, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 901899, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 125651, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 830729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500497, + "best_constant_accuracy_ppm": 871093, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 260, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -40364, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 509141, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 822504, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 128906, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 911458, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813629, + "best_constant_accuracy_ppm": 871093, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 136, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 40365, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 891494, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 879674, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 128906, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952517, + "best_constant_accuracy_ppm": 871093, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 76172, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 965023, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 943328, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 128906, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 165 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 881810, + "best_constant_accuracy_ppm": 871093, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 57943, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 965023, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889853, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 128906, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 827473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507396, + "best_constant_accuracy_ppm": 870442, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 265, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42969, + "final_window_accuracy_ppm": 835937, + "final_window_balanced_accuracy_ppm": 532589, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 841464, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 129557, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 909505, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 823979, + "best_constant_accuracy_ppm": 870442, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 139, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 39063, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 939996, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 892766, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 129557, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 941406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947094, + "best_constant_accuracy_ppm": 870442, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 90, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 70964, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 958515, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941137, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 129557, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 272 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 886793, + "best_constant_accuracy_ppm": 870442, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 55339, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 958515, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 905238, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 129557, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 821614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 499568, + "best_constant_accuracy_ppm": 858723, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 274, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37109, + "final_window_accuracy_ppm": 828125, + "final_window_balanced_accuracy_ppm": 507966, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 819649, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 141276, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 908854, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806398, + "best_constant_accuracy_ppm": 858723, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 140, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 50131, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 915861, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 875684, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 141276, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 933126, + "best_constant_accuracy_ppm": 858723, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 85938, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 915861, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 938140, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 141276, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 225 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 872082, + "best_constant_accuracy_ppm": 858723, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 67058, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 915861, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887249, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 141276, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 837239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500527, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -38412, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 493303, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 849541, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 124348, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 910156, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793720, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 138, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 34505, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 899553, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 895189, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 124348, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 932464, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 69010, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 946428, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 951386, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 124348, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 205 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 861412, + "best_constant_accuracy_ppm": 875651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 50781, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 946428, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 906061, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 124348, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 822916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514313, + "best_constant_accuracy_ppm": 856770, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 272, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33854, + "final_window_accuracy_ppm": 789062, + "final_window_balanced_accuracy_ppm": 497929, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 849900, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 143229, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 912760, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 827949, + "best_constant_accuracy_ppm": 856770, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 134, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 55990, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 878363, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 896781, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 143229, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 942708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 932494, + "best_constant_accuracy_ppm": 856770, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 88, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 85938, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 889233, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940105, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 143229, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 928385, + "arena_version": "v0.3", + "authorization_events": [ + 309 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "balanced_accuracy_ppm": 882494, + "best_constant_accuracy_ppm": 856770, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 110, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 71615, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 889233, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 908884, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 143229, + "task": "AND-1-2-4" + }, + { + "accuracy_ppm": 821614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503640, + "best_constant_accuracy_ppm": 858072, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 274, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -36458, + "final_window_accuracy_ppm": 769531, + "final_window_balanced_accuracy_ppm": 491422, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 817019, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 858072, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 702473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805574, + "best_constant_accuracy_ppm": 858072, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 457, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -155599, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 944444, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512205, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 858072, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 948973, + "best_constant_accuracy_ppm": 858072, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 90495, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 971014, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936414, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 858072, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 930338, + "arena_version": "v0.3", + "authorization_events": [ + 195 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 894324, + "best_constant_accuracy_ppm": 858072, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 107, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 72266, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 971014, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885484, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6000, + "target_prevalence_ppm": 858072, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 830078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500035, + "best_constant_accuracy_ppm": 878906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 261, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -48828, + "final_window_accuracy_ppm": 828125, + "final_window_balanced_accuracy_ppm": 466960, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 840932, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 686848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805626, + "best_constant_accuracy_ppm": 878906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 481, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -192058, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 891006, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 491615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950812, + "best_constant_accuracy_ppm": 878906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 63151, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 915235, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942576, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 260 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 893715, + "best_constant_accuracy_ppm": 878906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 44271, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 915235, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 895520, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6001, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 841145, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509150, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 244, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35808, + "final_window_accuracy_ppm": 832031, + "final_window_balanced_accuracy_ppm": 495706, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 834484, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 692708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 790680, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 472, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -184245, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 959090, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 493234, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 936560, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 71614, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 981818, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940163, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 193 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 889731, + "best_constant_accuracy_ppm": 876953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 57291, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 981818, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 892495, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6002, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 831380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 495393, + "best_constant_accuracy_ppm": 874348, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 259, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42968, + "final_window_accuracy_ppm": 824218, + "final_window_balanced_accuracy_ppm": 512127, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 833186, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 874348, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 702473, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805456, + "best_constant_accuracy_ppm": 874348, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 457, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -171875, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 914997, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 487722, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 874348, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 943952, + "best_constant_accuracy_ppm": 874348, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 70313, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 940698, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 925914, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 874348, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 925781, + "arena_version": "v0.3", + "authorization_events": [ + 256 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 879914, + "best_constant_accuracy_ppm": 874348, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 114, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 51433, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 940698, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 880066, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6003, + "target_prevalence_ppm": 874348, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 842447, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512166, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 242, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -34506, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 536725, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 812337, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 703776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 799265, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 455, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -173177, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 875810, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519088, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938834, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 71614, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 920058, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934713, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 153 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 881423, + "best_constant_accuracy_ppm": 876953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 54687, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 920058, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883064, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6004, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 826171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500033, + "best_constant_accuracy_ppm": 871093, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 267, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -44922, + "final_window_accuracy_ppm": 820312, + "final_window_balanced_accuracy_ppm": 483761, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 810370, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 871093, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 691406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 801353, + "best_constant_accuracy_ppm": 871093, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 474, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -179687, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 906916, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 501828, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 871093, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 945225, + "best_constant_accuracy_ppm": 871093, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 70964, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938306, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 934048, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 871093, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 162 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 885276, + "best_constant_accuracy_ppm": 871093, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 52735, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 938306, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 877858, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6005, + "target_prevalence_ppm": 871093, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 820312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512785, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 276, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -44922, + "final_window_accuracy_ppm": 816406, + "final_window_balanced_accuracy_ppm": 462389, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 798223, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 691406, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793121, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 474, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -173828, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 923598, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 535507, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 934957, + "best_constant_accuracy_ppm": 865234, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 97, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 71614, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 945722, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936053, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 921875, + "arena_version": "v0.3", + "authorization_events": [ + 115 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 893675, + "best_constant_accuracy_ppm": 865234, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 120, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 56641, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 945722, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884330, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6006, + "target_prevalence_ppm": 865234, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 837890, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503760, + "best_constant_accuracy_ppm": 873697, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 249, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35807, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 512043, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 814191, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 873697, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 698567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805448, + "best_constant_accuracy_ppm": 873697, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 463, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -175130, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 897629, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508451, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 873697, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 951822, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950381, + "best_constant_accuracy_ppm": 873697, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 74, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 78125, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 921134, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941653, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 873697, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 213 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 894767, + "best_constant_accuracy_ppm": 873697, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 921134, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888305, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6007, + "target_prevalence_ppm": 873697, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 839843, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503645, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 246, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -46875, + "final_window_accuracy_ppm": 851562, + "final_window_balanced_accuracy_ppm": 513392, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 826978, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 689453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 804837, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 477, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -197265, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 924107, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 504097, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 947275, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 55339, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 950892, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940356, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 185 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 876474, + "best_constant_accuracy_ppm": 886718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 36459, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 950892, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886310, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6008, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 842447, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 515785, + "best_constant_accuracy_ppm": 882161, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 242, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 511861, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 882161, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 692708, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 813862, + "best_constant_accuracy_ppm": 882161, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 472, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -189453, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 912900, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511697, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 882161, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 947265, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 958143, + "best_constant_accuracy_ppm": 882161, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 81, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 65104, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 951861, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940315, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 882161, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 926432, + "arena_version": "v0.3", + "authorization_events": [ + 232 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 881712, + "best_constant_accuracy_ppm": 882161, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 113, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 44271, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 951861, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888837, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6009, + "target_prevalence_ppm": 882161, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 833984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 500715, + "best_constant_accuracy_ppm": 876302, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 255, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -42318, + "final_window_accuracy_ppm": 804687, + "final_window_balanced_accuracy_ppm": 492780, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 819006, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 876302, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 687500, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 787791, + "best_constant_accuracy_ppm": 876302, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 480, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -188802, + "final_window_accuracy_ppm": 914062, + "final_window_balanced_accuracy_ppm": 938540, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 484831, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 876302, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 933037, + "best_constant_accuracy_ppm": 876302, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 65755, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 952239, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 937905, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 876302, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 923177, + "arena_version": "v0.3", + "authorization_events": [ + 165 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 868021, + "best_constant_accuracy_ppm": 876302, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 118, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 46875, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 952239, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 882659, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6010, + "target_prevalence_ppm": 876302, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 848307, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501090, + "best_constant_accuracy_ppm": 895833, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 233, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -47526, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 476595, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 844577, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 895833, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 695312, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 791279, + "best_constant_accuracy_ppm": 895833, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 468, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -200521, + "final_window_accuracy_ppm": 925781, + "final_window_balanced_accuracy_ppm": 937892, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508349, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 895833, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 938151, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 926816, + "best_constant_accuracy_ppm": 895833, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 95, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 42318, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952785, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 932805, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 895833, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 922526, + "arena_version": "v0.3", + "authorization_events": [ + 218 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 865625, + "best_constant_accuracy_ppm": 895833, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 119, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 26693, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 952785, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888785, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6011, + "target_prevalence_ppm": 895833, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 852864, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 516369, + "best_constant_accuracy_ppm": 884765, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 226, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -31901, + "final_window_accuracy_ppm": 832031, + "final_window_balanced_accuracy_ppm": 504636, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 848087, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 884765, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 703776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810484, + "best_constant_accuracy_ppm": 884765, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 455, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -180989, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 924483, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 522863, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 884765, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 955078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 952500, + "best_constant_accuracy_ppm": 884765, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 69, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 70313, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 960519, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 957486, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 884765, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 936848, + "arena_version": "v0.3", + "authorization_events": [ + 202 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 885689, + "best_constant_accuracy_ppm": 884765, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 97, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 52083, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 960519, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 903714, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6012, + "target_prevalence_ppm": 884765, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 841796, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512113, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 243, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33855, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 502683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 817624, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 701171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797922, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 459, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -174480, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 903203, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 496089, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 949218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 939558, + "best_constant_accuracy_ppm": 875651, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 78, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 73567, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 922683, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 936072, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 259 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 877862, + "best_constant_accuracy_ppm": 875651, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 55989, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 922683, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887987, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6013, + "target_prevalence_ppm": 875651, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 843098, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512078, + "best_constant_accuracy_ppm": 878906, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 241, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35808, + "final_window_accuracy_ppm": 812500, + "final_window_balanced_accuracy_ppm": 494634, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 835127, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 692057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 797000, + "best_constant_accuracy_ppm": 878906, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 473, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -186849, + "final_window_accuracy_ppm": 886718, + "final_window_balanced_accuracy_ppm": 910342, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 486670, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 948567, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 942926, + "best_constant_accuracy_ppm": 878906, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 79, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 69661, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 937491, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945593, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 930989, + "arena_version": "v0.3", + "authorization_events": [ + 182 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 881935, + "best_constant_accuracy_ppm": 878906, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 106, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 52083, + "final_window_accuracy_ppm": 933593, + "final_window_balanced_accuracy_ppm": 937491, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 893828, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6014, + "target_prevalence_ppm": 878906, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 842447, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 514300, + "best_constant_accuracy_ppm": 877604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 242, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35157, + "final_window_accuracy_ppm": 867187, + "final_window_balanced_accuracy_ppm": 548967, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 821526, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 701171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 806860, + "best_constant_accuracy_ppm": 877604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 459, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -176433, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 939085, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 510991, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949294, + "best_constant_accuracy_ppm": 877604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 73567, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965633, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941722, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 932291, + "arena_version": "v0.3", + "authorization_events": [ + 198 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 888187, + "best_constant_accuracy_ppm": 877604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 104, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 54687, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 965633, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 883775, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6015, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 855468, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 509931, + "best_constant_accuracy_ppm": 900390, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 222, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -44922, + "final_window_accuracy_ppm": 867187, + "final_window_balanced_accuracy_ppm": 474358, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 830462, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 900390, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 694010, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812640, + "best_constant_accuracy_ppm": 900390, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 470, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -206380, + "final_window_accuracy_ppm": 898437, + "final_window_balanced_accuracy_ppm": 882672, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 500446, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 900390, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 944661, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951830, + "best_constant_accuracy_ppm": 900390, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 85, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 44271, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 906176, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942999, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 900390, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 163 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 871230, + "best_constant_accuracy_ppm": 900390, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 24740, + "final_window_accuracy_ppm": 941406, + "final_window_balanced_accuracy_ppm": 906176, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884982, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6016, + "target_prevalence_ppm": 900390, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 830729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 510831, + "best_constant_accuracy_ppm": 864583, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 260, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33854, + "final_window_accuracy_ppm": 816406, + "final_window_balanced_accuracy_ppm": 520089, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 817396, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 864583, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 705078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 807141, + "best_constant_accuracy_ppm": 864583, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 453, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -159505, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 899553, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511995, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 864583, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 950520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949084, + "best_constant_accuracy_ppm": 864583, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 76, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 85937, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 926339, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 941190, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 864583, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 186 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 898748, + "best_constant_accuracy_ppm": 864583, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 69010, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 926339, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885517, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6017, + "target_prevalence_ppm": 864583, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 850260, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507181, + "best_constant_accuracy_ppm": 886067, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 230, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35807, + "final_window_accuracy_ppm": 867187, + "final_window_balanced_accuracy_ppm": 495987, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 832938, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 886067, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 705729, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 814027, + "best_constant_accuracy_ppm": 886067, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 452, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -180338, + "final_window_accuracy_ppm": 902343, + "final_window_balanced_accuracy_ppm": 926758, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 505150, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 886067, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953997, + "best_constant_accuracy_ppm": 886067, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 67709, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 952509, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 940097, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 886067, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 207 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 891426, + "best_constant_accuracy_ppm": 886067, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 49479, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 952509, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888709, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6018, + "target_prevalence_ppm": 886067, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 824869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496822, + "best_constant_accuracy_ppm": 860677, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 269, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35808, + "final_window_accuracy_ppm": 816406, + "final_window_balanced_accuracy_ppm": 475000, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 806126, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 860677, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 696614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 796336, + "best_constant_accuracy_ppm": 860677, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 466, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -164063, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 896969, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 860677, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944218, + "best_constant_accuracy_ppm": 860677, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 90494, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 933333, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948565, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 860677, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 931640, + "arena_version": "v0.3", + "authorization_events": [ + 163 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 885874, + "best_constant_accuracy_ppm": 860677, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 105, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 70963, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 933333, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888049, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6019, + "target_prevalence_ppm": 860677, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 842447, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 503638, + "best_constant_accuracy_ppm": 882812, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 242, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -40365, + "final_window_accuracy_ppm": 867187, + "final_window_balanced_accuracy_ppm": 482608, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 811784, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 882812, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 699869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 798696, + "best_constant_accuracy_ppm": 882812, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 461, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -182943, + "final_window_accuracy_ppm": 917968, + "final_window_balanced_accuracy_ppm": 920233, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 521151, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 882812, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 945963, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 938077, + "best_constant_accuracy_ppm": 882812, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 83, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 63151, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 944146, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 933753, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 882812, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 927083, + "arena_version": "v0.3", + "authorization_events": [ + 124 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 871976, + "best_constant_accuracy_ppm": 882812, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 112, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 44271, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 944146, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 872090, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6020, + "target_prevalence_ppm": 882812, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 836588, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 510140, + "best_constant_accuracy_ppm": 871744, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 251, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -35156, + "final_window_accuracy_ppm": 855468, + "final_window_balanced_accuracy_ppm": 514480, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 811048, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 704427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 810988, + "best_constant_accuracy_ppm": 871744, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 454, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -167317, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 941648, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 512778, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 954378, + "best_constant_accuracy_ppm": 871744, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 82683, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 966092, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948879, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 936197, + "arena_version": "v0.3", + "authorization_events": [ + 192 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 904959, + "best_constant_accuracy_ppm": 871744, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 98, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 64453, + "final_window_accuracy_ppm": 964843, + "final_window_balanced_accuracy_ppm": 966092, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 884868, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6021, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 832031, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 496703, + "best_constant_accuracy_ppm": 871744, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 258, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39713, + "final_window_accuracy_ppm": 824218, + "final_window_balanced_accuracy_ppm": 477375, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 824268, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 703776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 823602, + "best_constant_accuracy_ppm": 871744, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 455, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -167968, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 926890, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 517745, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 954427, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 967366, + "best_constant_accuracy_ppm": 871744, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 70, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 82683, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 963089, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 949704, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 190 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 903839, + "best_constant_accuracy_ppm": 871744, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 62500, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 963089, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 888628, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6022, + "target_prevalence_ppm": 871744, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 860677, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 508302, + "best_constant_accuracy_ppm": 894531, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 214, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33854, + "final_window_accuracy_ppm": 871093, + "final_window_balanced_accuracy_ppm": 501839, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 849892, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 894531, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 706380, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 805932, + "best_constant_accuracy_ppm": 894531, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 451, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -188151, + "final_window_accuracy_ppm": 921875, + "final_window_balanced_accuracy_ppm": 956521, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 520798, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 894531, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 944214, + "best_constant_accuracy_ppm": 894531, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 59245, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 982608, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947823, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 894531, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 935546, + "arena_version": "v0.3", + "authorization_events": [ + 255 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 874130, + "best_constant_accuracy_ppm": 894531, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 99, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 41015, + "final_window_accuracy_ppm": 968750, + "final_window_balanced_accuracy_ppm": 982608, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 897368, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6023, + "target_prevalence_ppm": 894531, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 835286, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 501654, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 253, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -33854, + "final_window_accuracy_ppm": 839843, + "final_window_balanced_accuracy_ppm": 491684, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 833398, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 708984, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 809340, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 447, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -160156, + "final_window_accuracy_ppm": 894531, + "final_window_balanced_accuracy_ppm": 926092, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 519884, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 953776, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 950164, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 71, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 84636, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 959426, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 947833, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 934895, + "arena_version": "v0.3", + "authorization_events": [ + 276 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 890703, + "best_constant_accuracy_ppm": 869140, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 100, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 65755, + "final_window_accuracy_ppm": 953125, + "final_window_balanced_accuracy_ppm": 959426, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 901797, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6024, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 838541, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 518940, + "best_constant_accuracy_ppm": 877604, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 248, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39063, + "final_window_accuracy_ppm": 859375, + "final_window_balanced_accuracy_ppm": 468085, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 827560, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 689453, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 793318, + "best_constant_accuracy_ppm": 877604, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 477, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -188151, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 927253, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508228, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 942057, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 937235, + "best_constant_accuracy_ppm": 877604, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 89, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 64453, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 944275, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 935887, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 923828, + "arena_version": "v0.3", + "authorization_events": [ + 226 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 876499, + "best_constant_accuracy_ppm": 877604, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 117, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 46224, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 944275, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 885079, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6025, + "target_prevalence_ppm": 877604, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 830078, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 507110, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 261, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39062, + "final_window_accuracy_ppm": 828125, + "final_window_balanced_accuracy_ppm": 486607, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 814324, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 699218, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 812175, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 462, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -169922, + "final_window_accuracy_ppm": 910156, + "final_window_balanced_accuracy_ppm": 948660, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 498142, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 951171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 957118, + "best_constant_accuracy_ppm": 869140, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 75, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 82031, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 970982, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 948406, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 933593, + "arena_version": "v0.3", + "authorization_events": [ + 232 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 908971, + "best_constant_accuracy_ppm": 869140, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 102, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 64453, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 970982, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 893554, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6026, + "target_prevalence_ppm": 869140, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 850911, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 498385, + "best_constant_accuracy_ppm": 891276, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 229, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -40365, + "final_window_accuracy_ppm": 851562, + "final_window_balanced_accuracy_ppm": 511209, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 848760, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 891276, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 697916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 817388, + "best_constant_accuracy_ppm": 891276, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 464, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -193360, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 946902, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 513570, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 891276, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 953125, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 960559, + "best_constant_accuracy_ppm": 891276, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 72, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 61849, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 977876, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 952475, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 891276, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 934244, + "arena_version": "v0.3", + "authorization_events": [ + 252 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 889505, + "best_constant_accuracy_ppm": 891276, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 101, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 42968, + "final_window_accuracy_ppm": 960937, + "final_window_balanced_accuracy_ppm": 977876, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 900963, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6027, + "target_prevalence_ppm": 891276, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 837239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 506923, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 875000, + "final_window_balanced_accuracy_ppm": 501436, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 803028, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 688802, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 783904, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 478, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -188151, + "final_window_accuracy_ppm": 906250, + "final_window_balanced_accuracy_ppm": 910919, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 511144, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 929042, + "best_constant_accuracy_ppm": 876953, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 66406, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 938936, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 942700, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 925130, + "arena_version": "v0.3", + "authorization_events": [ + 87 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 873162, + "best_constant_accuracy_ppm": 876953, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 115, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 48177, + "final_window_accuracy_ppm": 957031, + "final_window_balanced_accuracy_ppm": 938936, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 876961, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6028, + "target_prevalence_ppm": 876953, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 849609, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 511526, + "best_constant_accuracy_ppm": 887369, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 231, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -37760, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 473029, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 831136, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 887369, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 700520, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 811067, + "best_constant_accuracy_ppm": 887369, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 460, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -186849, + "final_window_accuracy_ppm": 929687, + "final_window_balanced_accuracy_ppm": 962655, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 507021, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 887369, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 949869, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 951566, + "best_constant_accuracy_ppm": 887369, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 77, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 62500, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 973029, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944353, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 887369, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 932942, + "arena_version": "v0.3", + "authorization_events": [ + 123 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 891562, + "best_constant_accuracy_ppm": 887369, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 103, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 45573, + "final_window_accuracy_ppm": 949218, + "final_window_balanced_accuracy_ppm": 973029, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 889391, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6029, + "target_prevalence_ppm": 887369, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 822916, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 512842, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 272, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -39714, + "final_window_accuracy_ppm": 867187, + "final_window_balanced_accuracy_ppm": 515804, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 806114, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 693359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 802340, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 471, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -169271, + "final_window_accuracy_ppm": 890625, + "final_window_balanced_accuracy_ppm": 902298, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 508192, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 946614, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 949133, + "best_constant_accuracy_ppm": 862630, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 82, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 83984, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 932470, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 944793, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 929036, + "arena_version": "v0.3", + "authorization_events": [ + 181 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 903082, + "best_constant_accuracy_ppm": 862630, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 109, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 66406, + "final_window_accuracy_ppm": 945312, + "final_window_balanced_accuracy_ppm": 932470, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 887520, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6030, + "target_prevalence_ppm": 862630, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 837239, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 494657, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "REACTIVE", + "cumulative_mistakes": 250, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -49479, + "final_window_accuracy_ppm": 878906, + "final_window_balanced_accuracy_ppm": 498030, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 816565, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 701171, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 816458, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "FIXED-H8", + "cumulative_mistakes": 459, + "exact_target_construction_active": null, + "excess_over_constant_ppm": -185547, + "final_window_accuracy_ppm": 882812, + "final_window_balanced_accuracy_ppm": 909918, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 534025, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 943359, + "arena_version": "v0.3", + "authorization_events": [], + "authorized_construction_count": 0, + "authorized_construction_ids": [], + "balanced_accuracy_ppm": 953022, + "best_constant_accuracy_ppm": 886718, + "candidate_field": null, + "condition": "ORACLE-FEATURE", + "cumulative_mistakes": 87, + "exact_target_construction_active": null, + "excess_over_constant_ppm": 56641, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939207, + "global_alpha_spending": true, + "partition_matches": [], + "predictive_partition_recovered": null, + "primary_aulc_ppm": 945615, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + }, + { + "accuracy_ppm": 924479, + "arena_version": "v0.3", + "authorization_events": [ + 149 + ], + "authorized_construction_count": 1, + "authorized_construction_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "balanced_accuracy_ppm": 884728, + "best_constant_accuracy_ppm": 886718, + "candidate_field": { + "active_construction_count": 1, + "alpha_denominator": 256, + "candidate_count": 256, + "composed_candidate_count": 32, + "epoch": 1, + "primitive_candidate_count": 120, + "scaffold_candidate_count": 104, + "threshold": 65536 + }, + "condition": "M20-CONSTRUCTION", + "cumulative_mistakes": 116, + "exact_target_construction_active": true, + "excess_over_constant_ppm": 37761, + "final_window_accuracy_ppm": 937500, + "final_window_balanced_accuracy_ppm": 939207, + "global_alpha_spending": true, + "partition_matches": [ + { + "construction_id": "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255", + "relation": "exact" + } + ], + "predictive_partition_recovered": true, + "primary_aulc_ppm": 886605, + "receipt_chain_valid": true, + "steps": 1536, + "stream_seed": 6031, + "target_prevalence_ppm": 886718, + "task": "OR-2-3-4" + } + ], + "seed_cluster_count": 32, + "status": "FROZEN_HELD_OUT_EVALUATION", + "task_count": 12 +} diff --git a/experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.sha256 b/experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.sha256 new file mode 100644 index 0000000..b30123b --- /dev/null +++ b/experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.sha256 @@ -0,0 +1 @@ +6556a2a21c3e52b6b2c9d656365651d3c66e2856963ee8cbc80e925c0a12c980 experiments/prime_m20_universal_arena/FROZEN_EVALUATION_RESULT_V0_3.json diff --git a/experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.md b/experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.md new file mode 100644 index 0000000..5f495aa --- /dev/null +++ b/experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.md @@ -0,0 +1,190 @@ +# PRIME M20 Universal Adaptive-State Arena v0.3 +## Frozen Held-Out Result + +Status: + + PRIMARY CLAIM SUPPORTED + +Frozen result commit: + + 51e5869 + +Frozen result SHA256: + + 6556a2a21c3e52b6b2c9d656365651d3c66e2856963ee8cbc80e925c0a12c980 + +Held-out seeds: + + 6000..6031 + +Seed clusters: + + 32 + +Tasks: + + 12 + +Paired task/seed worlds: + + 384 + +Total condition rows: + + 1536 + +--- + +## Primary result + +Comparison: + + M20-CONSTRUCTION + minus + FIXED-H8 + +Mean held-out AULC delta: + + +184737 ppm + +Frozen deterministic seed-cluster bootstrap: + + [+181945, +187493] ppm + +Paired held-out worlds: + + M20 better: + 384 / 384 + + ties: + 0 / 384 + + M20 worse: + 0 / 384 + +Primary claim: + + SUPPORTED + +--- + +## Final-window performance + +M20 minus FIXED-H8 final-window accuracy: + + +27160 ppm + +M20 minus FIXED-H8 final-window balanced accuracy: + + +27125 ppm + +Condition means: + + REACTIVE + AULC 631148 + + FIXED-H8 + AULC 699044 + + ORACLE-FEATURE + AULC 943999 + + M20-CONSTRUCTION + AULC 883781 + +M20 and ORACLE-FEATURE had the same aggregate final-window accuracy: + + 948414 ppm + +and the same aggregate final-window balanced accuracy: + + 948443 ppm + +M20 minus ORACLE AULC: + + -60218 ppm + +Interpretation: + + The remaining oracle gap is primarily online representation-discovery and + authorization latency rather than final predictive performance on this + arena. + +--- + +## Representation recovery + +Exact-expression recovery: + + 320 / 384 + +Predictive-partition recovery: + + 384 / 384 + +Exact relation worlds: + + 288 + +Complement-equivalent relation worlds: + + 64 + +CURRENT worlds: + + 32 + +Unnecessary CURRENT constructions: + + 0 / 32 + +The exact-expression deficit is explained by the preregistered binary +predictive-quotient rule: exact complements induce the same two-cell predictive +partition. + +--- + +## Integrity + +Receipt chains: + + PASS + +Complete unique task/seed/condition row set: + + PASS + +v0.3 global-alpha flags: + + PASS + +Global sequential verifier budget: + + alpha_run <= 1/64 + +All preregistered claim gates: + + PASS + +--- + +## Claim boundary + +This result supports the following controlled claim: + + Frozen PRIME M20 v0.3 learns more efficiently than the frozen raw H8 + representation on the held-out Universal Adaptive-State Arena while + recovering the required predictive representation class under a globally + alpha-spent verifier. + +This does not establish: + + AGI; + universal representation learning; + arbitrary-POMDP superiority; + superiority over learned recurrent memory; + language understanding; + general real-world intelligence. + +The next required tests are transfer, continual construction reuse, proposal +search efficiency, and a learned recurrent-memory comparison. diff --git a/experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.sha256 b/experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.sha256 new file mode 100644 index 0000000..234c4b6 --- /dev/null +++ b/experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.sha256 @@ -0,0 +1 @@ +cbe59c2cfa42bc1f48c84aae76ef3928f8a80a0409a8c0914f3ef1b6ccebc908 experiments/prime_m20_universal_arena/HELD_OUT_RESULT_V0_3.md diff --git a/experiments/prime_m20_universal_arena/PROTOCOL_V0_2.md b/experiments/prime_m20_universal_arena/PROTOCOL_V0_2.md new file mode 100644 index 0000000..21b4ffa --- /dev/null +++ b/experiments/prime_m20_universal_arena/PROTOCOL_V0_2.md @@ -0,0 +1,49 @@ +# PRIME M20 Universal Arena v0.2 + +Status: + + DEVELOPMENT PROTOCOL + +Held-out seeds remain: + + 6000..6031 + +They have not been run. + +v0.2 corrects three v0.1 development issues: + +1. condition-independent exploration schedule; +2. predictive-partition recovery in addition to syntactic recovery; +3. imbalance diagnostics. + +Architecture and task families are otherwise unchanged. + +Primary future held-out comparison remains: + + M20-CONSTRUCTION + versus + FIXED-H8 + +AULC remains the online-learning-efficiency metric. + +Additional reporting: + + exact-expression recovery; + predictive-partition recovery; + balanced accuracy; + target prevalence; + best constant accuracy; + excess accuracy over best constant; + oracle gap. + +Predictive partition equivalence for binary features includes exact complement: + + q(h) = f(h) + +or + + q(h) = 1 - f(h) + +because either induces the same two-cell partition of history space. + +This equivalence rule is frozen before v0.2 development results. diff --git a/experiments/prime_m20_universal_arena/PROTOCOL_V0_2.sha256 b/experiments/prime_m20_universal_arena/PROTOCOL_V0_2.sha256 new file mode 100644 index 0000000..60063cd --- /dev/null +++ b/experiments/prime_m20_universal_arena/PROTOCOL_V0_2.sha256 @@ -0,0 +1 @@ +6d3a2116c29c6b3f39e786e41a15772ae510b7de984b4988cd6454e167629115 experiments/prime_m20_universal_arena/PROTOCOL_V0_2.md diff --git a/experiments/prime_m20_universal_arena/PROTOCOL_V0_3.md b/experiments/prime_m20_universal_arena/PROTOCOL_V0_3.md new file mode 100644 index 0000000..1c3c62c --- /dev/null +++ b/experiments/prime_m20_universal_arena/PROTOCOL_V0_3.md @@ -0,0 +1,102 @@ +# PRIME M20 Universal Adaptive-State Arena v0.3 + +Status: + + DEVELOPMENT PROTOCOL + FROZEN BEFORE v0.3 DEVELOPMENT RESULTS + +v0.3 supersedes the unexecuted v0.2 held-out evaluation. + +No v0.2 or v0.3 held-out seed had been executed when this protocol was frozen. + +Development seeds: + + 600..607 inclusive + +Held-out seeds: + + 6000..6031 inclusive + +Task families: + + CURRENT + LAG-1 + LAG-4 + LAG-7 + XOR-1-4 + XOR-2-7 + EQ-1-4 + AND-1-4 + OR-2-7 + XOR-1-2-3 + AND-1-2-4 + OR-2-3-4 + +Conditions: + + REACTIVE + FIXED-H8 + ORACLE-FEATURE + M20-CONSTRUCTION + +Scored steps: + + 1536 per world + +Final window: + + 256 + +Candidate field: + + max lag = 8 + max simultaneous candidates = 256 + non-authoritative higher-order scaffolds enabled + +Matched exploration: + + all conditions on a task/seed world use the same + condition-independent action-randomness schedule. + +Predictive quotient: + + exact binary complements count as the same predictive partition. + +Global adaptive evidence budget: + + alpha_run <= 1/64 + +For zero-indexed adaptive representation epoch e: + + alpha_e = + 1 / (64 * 2^(e + 1)) + +For N_e candidate streams: + + T_e = + 64 * N_e * 2^(e + 1) + +Evidence condition: + + 3^W >= T_e * 2^(W + L) + +plus the existing structural-complexity gate. + +This replaces the v0.2 adaptive per-epoch reuse of the 1/64 budget. + +Primary DEVELOPMENT diagnostics: + + AULC ppm + final-window accuracy + balanced accuracy + predictive-partition recovery + exact-expression recovery + authorization latency + receipt integrity + paired M20 - FIXED-H8 differences + paired M20 - ORACLE differences + +No inferential scientific claim may be made from development seeds. + +A separate v0.3 held-out analysis plan must be frozen after development and +before seed 6000 is executed. diff --git a/experiments/prime_m20_universal_arena/PROTOCOL_V0_3.sha256 b/experiments/prime_m20_universal_arena/PROTOCOL_V0_3.sha256 new file mode 100644 index 0000000..bd0fc85 --- /dev/null +++ b/experiments/prime_m20_universal_arena/PROTOCOL_V0_3.sha256 @@ -0,0 +1 @@ +d435014ff43c528741cd410d9f03ee0dd0f697d12c519396fd9a35623cfa2586 experiments/prime_m20_universal_arena/PROTOCOL_V0_3.md diff --git a/experiments/prime_m20_universal_arena/V0_1_DIAGNOSIS.md b/experiments/prime_m20_universal_arena/V0_1_DIAGNOSIS.md new file mode 100644 index 0000000..d042f21 --- /dev/null +++ b/experiments/prime_m20_universal_arena/V0_1_DIAGNOSIS.md @@ -0,0 +1,79 @@ +# PRIME M20 Universal Arena v0.1 +## Development Diagnosis + +Held-out seeds 6000..6031 were not run. + +Development result: + + M20-CONSTRUCTION AULC: + 887347 + + FIXED-H8 AULC: + 704211 + + ORACLE-FEATURE AULC: + 945416 + + REACTIVE AULC: + 632637 + +Receipt integrity: + + PASS + +Reported syntactic target recovery: + + 80 / 96 + +Two development issues were identified before any held-out execution. + +## 1. Representation-equivalence metric + +XOR(a,b) and EQ(a,b) are binary complements: + + EQ(a,b) = 1 - XOR(a,b) + +They induce the same binary partition of histories. + +A downstream tabular policy can therefore use either representation with no +loss of predictive sufficiency by reversing the output mapping. + +The v0.1 exact-expression metric counts this as failure even when the recovered +representation contains the same predictive information. + +Arena v0.2 must therefore retain exact-expression recovery but additionally +report predictive-partition recovery. + +This is a diagnostic correction, not a claim that arbitrary different +expressions are equivalent. + +## 2. Condition-specific exploration randomness + +v0.1 derives learner exploration randomness partly from the condition name. + +Thus REACTIVE, FIXED-H8, ORACLE-FEATURE and M20-CONSTRUCTION do not receive +identical exploration schedules. + +Arena v0.2 will use one condition-independent exploration schedule for every +task/seed pair. + +## 3. Class imbalance + +AND / OR families have unequal target prevalence. + +Raw accuracy and AULC remain useful for paired comparisons, but v0.2 must also +report: + + target prevalence; + best-constant accuracy; + excess accuracy over constant; + balanced accuracy. + +## Status + +Arena v0.1 is retained as development evidence. + +It is superseded for future held-out evaluation by a separately frozen Arena +v0.2 protocol. + +No held-out result exists for Arena v0.1. diff --git a/experiments/prime_m20_universal_arena/__init__.py b/experiments/prime_m20_universal_arena/__init__.py new file mode 100644 index 0000000..e7ea041 --- /dev/null +++ b/experiments/prime_m20_universal_arena/__init__.py @@ -0,0 +1 @@ +"""PRIME M20 Universal Adaptive-State Arena.""" diff --git a/experiments/prime_m20_universal_arena/run_development.py b/experiments/prime_m20_universal_arena/run_development.py new file mode 100644 index 0000000..266cb77 --- /dev/null +++ b/experiments/prime_m20_universal_arena/run_development.py @@ -0,0 +1,300 @@ +"""Development-only sweep for PRIME M20 Universal Arena.""" + +import json + +from .runner import ( + CONDITIONS, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, + run_world, +) +from .tasks import ( + TASKS, +) + + +def mean_floor( + values, +): + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def main(): + if DEVELOPMENT_SEEDS != tuple( + range( + 600, + 608, + ) + ): + raise RuntimeError( + "development seeds changed" + ) + + if EVALUATION_SEEDS != tuple( + range( + 6000, + 6032, + ) + ): + raise RuntimeError( + "evaluation seeds changed" + ) + + rows = [] + + for task in TASKS: + for seed in DEVELOPMENT_SEEDS: + for condition in CONDITIONS: + rows.append( + run_world( + task=task, + stream_seed=seed, + condition=condition, + ).payload + ) + + summaries = {} + + for condition in CONDITIONS: + subset = [ + row + for row in rows + if row[ + "condition" + ] == condition + ] + + summaries[ + condition + ] = { + "world_count": ( + len(subset) + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row in subset + ] + ) + ), + } + + by_task = [] + + for task in TASKS: + for condition in CONDITIONS: + subset = [ + row + for row in rows + if ( + row["task"] + == task.name + and row[ + "condition" + ] + == condition + ) + ] + + m20_rows = [ + row + for row in subset + if condition + == "M20-CONSTRUCTION" + ] + + auth_events = [ + event + for row in m20_rows + for event in row[ + "authorization_events" + ] + ] + + by_task.append( + { + "task": ( + task.name + ), + "condition": ( + condition + ), + "world_count": ( + len(subset) + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row + in subset + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row + in subset + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row + in subset + ] + ) + ), + "exact_target_recovery": ( + sum( + row[ + "exact_target_construction_active" + ] + is True + for row + in m20_rows + ) + if m20_rows + else None + ), + "mean_first_authorization_event": ( + mean_floor( + [ + row[ + "authorization_events" + ][0] + for row + in m20_rows + if row[ + "authorization_events" + ] + ] + ) + if m20_rows + else None + ), + "all_receipts_valid": ( + all( + row[ + "receipt_chain_valid" + ] + for row + in m20_rows + ) + if m20_rows + else None + ), + } + ) + + m20_rows = [ + row + for row in rows + if row[ + "condition" + ] == "M20-CONSTRUCTION" + ] + + report = { + "benchmark": ( + "prime-m20-universal-adaptive-state-arena" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "development_seeds": list( + DEVELOPMENT_SEEDS + ), + "evaluation_seeds_run": ( + False + ), + "task_count": ( + len(TASKS) + ), + "condition_count": ( + len(CONDITIONS) + ), + "row_count": ( + len(rows) + ), + "condition_summaries": ( + summaries + ), + "m20_exact_target_recovery": ( + sum( + row[ + "exact_target_construction_active" + ] + is True + for row + in m20_rows + ) + ), + "m20_world_count": ( + len(m20_rows) + ), + "m20_receipts_all_valid": ( + all( + row[ + "receipt_chain_valid" + ] + for row + in m20_rows + ) + ), + "by_task": ( + by_task + ), + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m20_universal_arena/run_development_v0_2.py b/experiments/prime_m20_universal_arena/run_development_v0_2.py new file mode 100644 index 0000000..034538c --- /dev/null +++ b/experiments/prime_m20_universal_arena/run_development_v0_2.py @@ -0,0 +1,570 @@ +"""Development-only analysis for PRIME M20 Universal Arena v0.2.""" + +from __future__ import annotations + +import json + +from .runner_v0_2 import ( + CONDITIONS, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, + run_world, +) +from .tasks import ( + TASKS, +) + + +def mean_floor(values): + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def main() -> None: + if DEVELOPMENT_SEEDS != tuple( + range(600, 608) + ): + raise RuntimeError( + "development seeds changed" + ) + + if EVALUATION_SEEDS != tuple( + range(6000, 6032) + ): + raise RuntimeError( + "evaluation seeds changed" + ) + + rows = [] + + for task in TASKS: + for seed in DEVELOPMENT_SEEDS: + for condition in CONDITIONS: + result = run_world( + task=task, + stream_seed=seed, + condition=condition, + ).payload + + rows.append( + result + ) + + expected_rows = ( + len(TASKS) + * len(DEVELOPMENT_SEEDS) + * len(CONDITIONS) + ) + + if len(rows) != expected_rows: + raise RuntimeError( + "unexpected development row count" + ) + + summaries = {} + + for condition in CONDITIONS: + subset = [ + row + for row in rows + if ( + row["condition"] + == condition + ) + ] + + summaries[ + condition + ] = { + "world_count": len( + subset + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_accuracy_ppm": ( + mean_floor( + [ + row[ + "accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "balanced_accuracy_ppm" + ] + for row in subset + if row[ + "balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_final_window_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_balanced_accuracy_ppm" + ] + for row in subset + if row[ + "final_window_balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_best_constant_accuracy_ppm": ( + mean_floor( + [ + row[ + "best_constant_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_excess_over_constant_ppm": ( + mean_floor( + [ + row[ + "excess_over_constant_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row in subset + ] + ) + ), + } + + by_task = [] + + for task in TASKS: + for condition in CONDITIONS: + subset = [ + row + for row in rows + if ( + row["task"] + == task.name + and row["condition"] + == condition + ) + ] + + exact = None + quotient = None + receipt_integrity = None + auth_events = [] + relation_counts = {} + + if condition == "M20-CONSTRUCTION": + exact = sum( + row[ + "exact_target_construction_active" + ] + is True + for row in subset + ) + + quotient = sum( + row[ + "predictive_partition_recovered" + ] + is True + for row in subset + ) + + receipt_integrity = all( + row[ + "receipt_chain_valid" + ] + for row in subset + ) + + auth_events = [ + row[ + "authorization_events" + ][0] + for row in subset + if row[ + "authorization_events" + ] + ] + + for row in subset: + for match in row[ + "partition_matches" + ]: + relation = match[ + "relation" + ] + + relation_counts[ + relation + ] = ( + relation_counts.get( + relation, + 0, + ) + + 1 + ) + + by_task.append( + { + "task": ( + task.name + ), + "condition": ( + condition + ), + "world_count": ( + len(subset) + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_accuracy_ppm": ( + mean_floor( + [ + row[ + "accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "balanced_accuracy_ppm" + ] + for row in subset + if row[ + "balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_final_window_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_balanced_accuracy_ppm" + ] + for row in subset + if row[ + "final_window_balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_target_prevalence_ppm": ( + mean_floor( + [ + row[ + "target_prevalence_ppm" + ] + for row in subset + ] + ) + ), + "mean_best_constant_accuracy_ppm": ( + mean_floor( + [ + row[ + "best_constant_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_excess_over_constant_ppm": ( + mean_floor( + [ + row[ + "excess_over_constant_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row in subset + ] + ) + ), + "exact_expression_recovery": ( + exact + ), + "predictive_partition_recovery": ( + quotient + ), + "mean_first_authorization_event": ( + mean_floor( + auth_events + ) + ), + "partition_relation_counts": ( + relation_counts + ), + "all_receipts_valid": ( + receipt_integrity + ), + } + ) + + lookup = { + ( + row["task"], + row["stream_seed"], + row["condition"], + ): row + for row in rows + } + + def paired_delta( + left, + right, + metric, + ): + values = [] + + for task in TASKS: + for seed in DEVELOPMENT_SEEDS: + values.append( + lookup[ + ( + task.name, + seed, + left, + ) + ][metric] + - + lookup[ + ( + task.name, + seed, + right, + ) + ][metric] + ) + + return { + "world_count": ( + len(values) + ), + "mean_delta": ( + mean_floor( + values + ) + ), + "positive_worlds": sum( + value > 0 + for value in values + ), + "ties": sum( + value == 0 + for value in values + ), + "negative_worlds": sum( + value < 0 + for value in values + ), + } + + m20_rows = [ + row + for row in rows + if ( + row["condition"] + == "M20-CONSTRUCTION" + ) + ] + + exact_total = sum( + row[ + "exact_target_construction_active" + ] + is True + for row in m20_rows + ) + + quotient_total = sum( + row[ + "predictive_partition_recovered" + ] + is True + for row in m20_rows + ) + + complement_worlds = sum( + any( + match["relation"] + == "complement" + for match in row[ + "partition_matches" + ] + ) + for row in m20_rows + ) + + exact_relation_worlds = sum( + any( + match["relation"] + == "exact" + for match in row[ + "partition_matches" + ] + ) + for row in m20_rows + ) + + report = { + "benchmark": ( + "prime-m20-universal-arena-v0.2" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "development_seeds": list( + DEVELOPMENT_SEEDS + ), + "evaluation_seeds_run": ( + False + ), + "task_count": len( + TASKS + ), + "condition_count": len( + CONDITIONS + ), + "row_count": len( + rows + ), + "condition_summaries": ( + summaries + ), + "m20_exact_expression_recovery": ( + exact_total + ), + "m20_predictive_partition_recovery": ( + quotient_total + ), + "m20_world_count": len( + m20_rows + ), + "m20_exact_relation_worlds": ( + exact_relation_worlds + ), + "m20_complement_relation_worlds": ( + complement_worlds + ), + "m20_receipts_all_valid": all( + row[ + "receipt_chain_valid" + ] + for row in m20_rows + ), + "paired_development": { + "m20_minus_h8_aulc_ppm": ( + paired_delta( + "M20-CONSTRUCTION", + "FIXED-H8", + "primary_aulc_ppm", + ) + ), + "m20_minus_h8_balanced_accuracy_ppm": ( + paired_delta( + "M20-CONSTRUCTION", + "FIXED-H8", + "balanced_accuracy_ppm", + ) + ), + "m20_minus_oracle_aulc_ppm": ( + paired_delta( + "M20-CONSTRUCTION", + "ORACLE-FEATURE", + "primary_aulc_ppm", + ) + ), + }, + "by_task": ( + by_task + ), + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m20_universal_arena/run_development_v0_3.py b/experiments/prime_m20_universal_arena/run_development_v0_3.py new file mode 100644 index 0000000..0b1a8d1 --- /dev/null +++ b/experiments/prime_m20_universal_arena/run_development_v0_3.py @@ -0,0 +1,570 @@ +"""Development-only analysis for PRIME M20 Universal Arena v0.3.""" + +from __future__ import annotations + +import json + +from .runner_v0_3 import ( + CONDITIONS, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, + run_world, +) +from .tasks import ( + TASKS, +) + + +def mean_floor(values): + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def main() -> None: + if DEVELOPMENT_SEEDS != tuple( + range(600, 608) + ): + raise RuntimeError( + "development seeds changed" + ) + + if EVALUATION_SEEDS != tuple( + range(6000, 6032) + ): + raise RuntimeError( + "evaluation seeds changed" + ) + + rows = [] + + for task in TASKS: + for seed in DEVELOPMENT_SEEDS: + for condition in CONDITIONS: + result = run_world( + task=task, + stream_seed=seed, + condition=condition, + ).payload + + rows.append( + result + ) + + expected_rows = ( + len(TASKS) + * len(DEVELOPMENT_SEEDS) + * len(CONDITIONS) + ) + + if len(rows) != expected_rows: + raise RuntimeError( + "unexpected development row count" + ) + + summaries = {} + + for condition in CONDITIONS: + subset = [ + row + for row in rows + if ( + row["condition"] + == condition + ) + ] + + summaries[ + condition + ] = { + "world_count": len( + subset + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_accuracy_ppm": ( + mean_floor( + [ + row[ + "accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "balanced_accuracy_ppm" + ] + for row in subset + if row[ + "balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_final_window_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_balanced_accuracy_ppm" + ] + for row in subset + if row[ + "final_window_balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_best_constant_accuracy_ppm": ( + mean_floor( + [ + row[ + "best_constant_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_excess_over_constant_ppm": ( + mean_floor( + [ + row[ + "excess_over_constant_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row in subset + ] + ) + ), + } + + by_task = [] + + for task in TASKS: + for condition in CONDITIONS: + subset = [ + row + for row in rows + if ( + row["task"] + == task.name + and row["condition"] + == condition + ) + ] + + exact = None + quotient = None + receipt_integrity = None + auth_events = [] + relation_counts = {} + + if condition == "M20-CONSTRUCTION": + exact = sum( + row[ + "exact_target_construction_active" + ] + is True + for row in subset + ) + + quotient = sum( + row[ + "predictive_partition_recovered" + ] + is True + for row in subset + ) + + receipt_integrity = all( + row[ + "receipt_chain_valid" + ] + for row in subset + ) + + auth_events = [ + row[ + "authorization_events" + ][0] + for row in subset + if row[ + "authorization_events" + ] + ] + + for row in subset: + for match in row[ + "partition_matches" + ]: + relation = match[ + "relation" + ] + + relation_counts[ + relation + ] = ( + relation_counts.get( + relation, + 0, + ) + + 1 + ) + + by_task.append( + { + "task": ( + task.name + ), + "condition": ( + condition + ), + "world_count": ( + len(subset) + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_accuracy_ppm": ( + mean_floor( + [ + row[ + "accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "balanced_accuracy_ppm" + ] + for row in subset + if row[ + "balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_final_window_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_balanced_accuracy_ppm" + ] + for row in subset + if row[ + "final_window_balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_target_prevalence_ppm": ( + mean_floor( + [ + row[ + "target_prevalence_ppm" + ] + for row in subset + ] + ) + ), + "mean_best_constant_accuracy_ppm": ( + mean_floor( + [ + row[ + "best_constant_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_excess_over_constant_ppm": ( + mean_floor( + [ + row[ + "excess_over_constant_ppm" + ] + for row in subset + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row in subset + ] + ) + ), + "exact_expression_recovery": ( + exact + ), + "predictive_partition_recovery": ( + quotient + ), + "mean_first_authorization_event": ( + mean_floor( + auth_events + ) + ), + "partition_relation_counts": ( + relation_counts + ), + "all_receipts_valid": ( + receipt_integrity + ), + } + ) + + lookup = { + ( + row["task"], + row["stream_seed"], + row["condition"], + ): row + for row in rows + } + + def paired_delta( + left, + right, + metric, + ): + values = [] + + for task in TASKS: + for seed in DEVELOPMENT_SEEDS: + values.append( + lookup[ + ( + task.name, + seed, + left, + ) + ][metric] + - + lookup[ + ( + task.name, + seed, + right, + ) + ][metric] + ) + + return { + "world_count": ( + len(values) + ), + "mean_delta": ( + mean_floor( + values + ) + ), + "positive_worlds": sum( + value > 0 + for value in values + ), + "ties": sum( + value == 0 + for value in values + ), + "negative_worlds": sum( + value < 0 + for value in values + ), + } + + m20_rows = [ + row + for row in rows + if ( + row["condition"] + == "M20-CONSTRUCTION" + ) + ] + + exact_total = sum( + row[ + "exact_target_construction_active" + ] + is True + for row in m20_rows + ) + + quotient_total = sum( + row[ + "predictive_partition_recovered" + ] + is True + for row in m20_rows + ) + + complement_worlds = sum( + any( + match["relation"] + == "complement" + for match in row[ + "partition_matches" + ] + ) + for row in m20_rows + ) + + exact_relation_worlds = sum( + any( + match["relation"] + == "exact" + for match in row[ + "partition_matches" + ] + ) + for row in m20_rows + ) + + report = { + "benchmark": ( + "prime-m20-universal-arena-v0.3" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "development_seeds": list( + DEVELOPMENT_SEEDS + ), + "evaluation_seeds_run": ( + False + ), + "task_count": len( + TASKS + ), + "condition_count": len( + CONDITIONS + ), + "row_count": len( + rows + ), + "condition_summaries": ( + summaries + ), + "m20_exact_expression_recovery": ( + exact_total + ), + "m20_predictive_partition_recovery": ( + quotient_total + ), + "m20_world_count": len( + m20_rows + ), + "m20_exact_relation_worlds": ( + exact_relation_worlds + ), + "m20_complement_relation_worlds": ( + complement_worlds + ), + "m20_receipts_all_valid": all( + row[ + "receipt_chain_valid" + ] + for row in m20_rows + ), + "paired_development": { + "m20_minus_h8_aulc_ppm": ( + paired_delta( + "M20-CONSTRUCTION", + "FIXED-H8", + "primary_aulc_ppm", + ) + ), + "m20_minus_h8_balanced_accuracy_ppm": ( + paired_delta( + "M20-CONSTRUCTION", + "FIXED-H8", + "balanced_accuracy_ppm", + ) + ), + "m20_minus_oracle_aulc_ppm": ( + paired_delta( + "M20-CONSTRUCTION", + "ORACLE-FEATURE", + "primary_aulc_ppm", + ) + ), + }, + "by_task": ( + by_task + ), + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m20_universal_arena/run_evaluation_v0_3.py b/experiments/prime_m20_universal_arena/run_evaluation_v0_3.py new file mode 100644 index 0000000..0b67b1c --- /dev/null +++ b/experiments/prime_m20_universal_arena/run_evaluation_v0_3.py @@ -0,0 +1,803 @@ +"""Frozen held-out evaluator for PRIME M20 Universal Arena v0.3.""" + +from __future__ import annotations + +import json + +from .runner_v0_3 import ( + CONDITIONS, + DEVELOPMENT_SEEDS, + EVALUATION_SEEDS, + splitmix64, + run_world, +) +from .tasks import ( + TASKS, +) + + +BOOTSTRAP_REPLICATES = 16384 +BOOTSTRAP_SEED = ( + 0x4D3230563033434C +) + +LOWER_INDEX = 409 +UPPER_INDEX = 15974 + + +def mean_floor(values): + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def paired_delta_rows( + lookup, + left, + right, + metric, +): + values = [] + + for seed in EVALUATION_SEEDS: + for task in TASKS: + values.append( + { + "seed": seed, + "task": task.name, + "delta": ( + lookup[ + ( + task.name, + seed, + left, + ) + ][metric] + - + lookup[ + ( + task.name, + seed, + right, + ) + ][metric] + ), + } + ) + + return values + + +def cluster_bootstrap( + paired_rows, +): + by_seed = { + seed: [] + for seed + in EVALUATION_SEEDS + } + + for row in paired_rows: + by_seed[ + row["seed"] + ].append( + row["delta"] + ) + + task_count = len( + TASKS + ) + + for seed, values in ( + by_seed.items() + ): + if ( + len(values) + != task_count + ): + raise RuntimeError( + "cluster task count mismatch" + ) + + cluster_sums = [ + sum( + by_seed[seed] + ) + for seed + in EVALUATION_SEEDS + ] + + cluster_count = len( + cluster_sums + ) + + denominator = ( + cluster_count + * task_count + ) + + bootstrap_means = [] + + for replicate in range( + BOOTSTRAP_REPLICATES + ): + total = 0 + + for draw in range( + cluster_count + ): + index = ( + splitmix64( + BOOTSTRAP_SEED + ^ splitmix64( + replicate + ) + ^ splitmix64( + draw + ) + ) + % cluster_count + ) + + total += ( + cluster_sums[ + index + ] + ) + + bootstrap_means.append( + total + // denominator + ) + + bootstrap_means.sort() + + return { + "method": ( + "deterministic-seed-cluster-bootstrap" + ), + "replicates": ( + BOOTSTRAP_REPLICATES + ), + "cluster_count": ( + cluster_count + ), + "tasks_per_cluster": ( + task_count + ), + "bootstrap_seed": ( + BOOTSTRAP_SEED + ), + "lower_index": ( + LOWER_INDEX + ), + "upper_index": ( + UPPER_INDEX + ), + "lower_ppm": ( + bootstrap_means[ + LOWER_INDEX + ] + ), + "upper_ppm": ( + bootstrap_means[ + UPPER_INDEX + ] + ), + } + + +def summarize_condition( + rows, + condition, +): + subset = [ + row + for row in rows + if ( + row["condition"] + == condition + ) + ] + + return { + "world_count": len( + subset + ), + "mean_primary_aulc_ppm": ( + mean_floor( + [ + row[ + "primary_aulc_ppm" + ] + for row in subset + ] + ) + ), + "mean_accuracy_ppm": ( + mean_floor( + [ + row[ + "accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "balanced_accuracy_ppm" + ] + for row in subset + if row[ + "balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_final_window_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_accuracy_ppm" + ] + for row in subset + ] + ) + ), + "mean_final_window_balanced_accuracy_ppm": ( + mean_floor( + [ + row[ + "final_window_balanced_accuracy_ppm" + ] + for row in subset + if row[ + "final_window_balanced_accuracy_ppm" + ] + is not None + ] + ) + ), + "mean_cumulative_mistakes": ( + mean_floor( + [ + row[ + "cumulative_mistakes" + ] + for row in subset + ] + ) + ), + } + + +def main(): + if DEVELOPMENT_SEEDS != tuple( + range( + 600, + 608, + ) + ): + raise RuntimeError( + "development seed contract changed" + ) + + if EVALUATION_SEEDS != tuple( + range( + 6000, + 6032, + ) + ): + raise RuntimeError( + "evaluation seed contract changed" + ) + + if len(TASKS) != 12: + raise RuntimeError( + "task contract changed" + ) + + if len(CONDITIONS) != 4: + raise RuntimeError( + "condition contract changed" + ) + + rows = [] + + for task in TASKS: + for seed in EVALUATION_SEEDS: + for condition in CONDITIONS: + result = run_world( + task=task, + stream_seed=seed, + condition=condition, + permit_evaluation=True, + ).payload + + rows.append( + result + ) + + expected_rows = ( + len(TASKS) + * len(EVALUATION_SEEDS) + * len(CONDITIONS) + ) + + if ( + len(rows) + != expected_rows + or expected_rows + != 1536 + ): + raise RuntimeError( + "held-out row count mismatch" + ) + + expected_keys = { + ( + task.name, + seed, + condition, + ) + for task in TASKS + for seed in EVALUATION_SEEDS + for condition in CONDITIONS + } + + observed_keys = { + ( + row["task"], + row["stream_seed"], + row["condition"], + ) + for row in rows + } + + integrity_unique = ( + observed_keys + == expected_keys + and len(observed_keys) + == expected_rows + ) + + integrity_version = all( + row[ + "arena_version" + ] == "v0.3" + and row[ + "global_alpha_spending" + ] is True + for row in rows + ) + + lookup = { + ( + row["task"], + row["stream_seed"], + row["condition"], + ): row + for row in rows + } + + condition_summaries = { + condition: ( + summarize_condition( + rows, + condition, + ) + ) + for condition in CONDITIONS + } + + aulc_rows = ( + paired_delta_rows( + lookup, + "M20-CONSTRUCTION", + "FIXED-H8", + "primary_aulc_ppm", + ) + ) + + final_rows = ( + paired_delta_rows( + lookup, + "M20-CONSTRUCTION", + "FIXED-H8", + "final_window_accuracy_ppm", + ) + ) + + final_balanced_rows = ( + paired_delta_rows( + lookup, + "M20-CONSTRUCTION", + "FIXED-H8", + "final_window_balanced_accuracy_ppm", + ) + ) + + oracle_rows = ( + paired_delta_rows( + lookup, + "M20-CONSTRUCTION", + "ORACLE-FEATURE", + "primary_aulc_ppm", + ) + ) + + observed_aulc_delta = ( + mean_floor( + [ + row["delta"] + for row + in aulc_rows + ] + ) + ) + + observed_final_delta = ( + mean_floor( + [ + row["delta"] + for row + in final_rows + ] + ) + ) + + observed_final_balanced_delta = ( + mean_floor( + [ + row["delta"] + for row + in final_balanced_rows + ] + ) + ) + + observed_oracle_delta = ( + mean_floor( + [ + row["delta"] + for row + in oracle_rows + ] + ) + ) + + bootstrap = ( + cluster_bootstrap( + aulc_rows + ) + ) + + m20_rows = [ + row + for row in rows + if ( + row["condition"] + == "M20-CONSTRUCTION" + ) + ] + + quotient_recovery = sum( + row[ + "predictive_partition_recovered" + ] + is True + for row in m20_rows + ) + + exact_recovery = sum( + row[ + "exact_target_construction_active" + ] + is True + for row in m20_rows + ) + + exact_relations = sum( + any( + match["relation"] + == "exact" + for match in row[ + "partition_matches" + ] + ) + for row in m20_rows + ) + + complement_relations = sum( + any( + match["relation"] + == "complement" + for match in row[ + "partition_matches" + ] + ) + for row in m20_rows + ) + + current_rows = [ + row + for row in m20_rows + if row[ + "task" + ] == "CURRENT" + ] + + current_unnecessary = sum( + row[ + "authorized_construction_count" + ] != 0 + for row in current_rows + ) + + receipts_valid = all( + row[ + "receipt_chain_valid" + ] + for row in m20_rows + ) + + positive_worlds = sum( + row["delta"] > 0 + for row in aulc_rows + ) + + tied_worlds = sum( + row["delta"] == 0 + for row in aulc_rows + ) + + negative_worlds = sum( + row["delta"] < 0 + for row in aulc_rows + ) + + gates = { + "observed_mean_positive": ( + observed_aulc_delta + is not None + and observed_aulc_delta + > 0 + ), + "cluster_bootstrap_lower_positive": ( + bootstrap[ + "lower_ppm" + ] + > 0 + ), + "final_accuracy_noninferior": ( + observed_final_delta + is not None + and observed_final_delta + >= 0 + ), + "final_balanced_accuracy_noninferior": ( + observed_final_balanced_delta + is not None + and observed_final_balanced_delta + >= 0 + ), + "predictive_partition_recovery_complete": ( + quotient_recovery + == 384 + ), + "current_no_unnecessary_construction": ( + len(current_rows) + == 32 + and current_unnecessary + == 0 + ), + "receipt_integrity": ( + receipts_valid + ), + "row_integrity": ( + integrity_unique + and integrity_version + ), + } + + supported = all( + gates.values() + ) + + by_task = [] + + for task in TASKS: + task_aulc = [ + row["delta"] + for row in aulc_rows + if row[ + "task" + ] == task.name + ] + + task_m20 = [ + row + for row in m20_rows + if row[ + "task" + ] == task.name + ] + + auth_events = [ + row[ + "authorization_events" + ][0] + for row in task_m20 + if row[ + "authorization_events" + ] + ] + + by_task.append( + { + "task": task.name, + "world_count": len( + task_aulc + ), + "mean_m20_minus_h8_aulc_ppm": ( + mean_floor( + task_aulc + ) + ), + "positive_worlds": sum( + x > 0 + for x in task_aulc + ), + "ties": sum( + x == 0 + for x in task_aulc + ), + "negative_worlds": sum( + x < 0 + for x in task_aulc + ), + "predictive_recovery": sum( + row[ + "predictive_partition_recovered" + ] + is True + for row in task_m20 + ), + "exact_recovery": sum( + row[ + "exact_target_construction_active" + ] + is True + for row in task_m20 + ), + "mean_first_authorization_event": ( + mean_floor( + auth_events + ) + ), + } + ) + + report = { + "benchmark": ( + "prime-m20-universal-arena-v0.3" + ), + "status": ( + "FROZEN_HELD_OUT_EVALUATION" + ), + "development_seeds_run": ( + False + ), + "evaluation_seeds": list( + EVALUATION_SEEDS + ), + "task_count": len( + TASKS + ), + "seed_cluster_count": len( + EVALUATION_SEEDS + ), + "paired_world_count": ( + 384 + ), + "row_count": ( + len(rows) + ), + "condition_summaries": ( + condition_summaries + ), + "primary": { + "comparison": ( + "M20-CONSTRUCTION minus FIXED-H8" + ), + "observed_mean_aulc_delta_ppm": ( + observed_aulc_delta + ), + "positive_worlds": ( + positive_worlds + ), + "ties": ( + tied_worlds + ), + "negative_worlds": ( + negative_worlds + ), + "cluster_bootstrap": ( + bootstrap + ), + "mean_final_window_accuracy_delta_ppm": ( + observed_final_delta + ), + "mean_final_window_balanced_accuracy_delta_ppm": ( + observed_final_balanced_delta + ), + }, + "oracle_diagnostic": { + "mean_m20_minus_oracle_aulc_ppm": ( + observed_oracle_delta + ), + }, + "representation": { + "exact_recovery": ( + exact_recovery + ), + "predictive_partition_recovery": ( + quotient_recovery + ), + "exact_relation_worlds": ( + exact_relations + ), + "complement_relation_worlds": ( + complement_relations + ), + "current_world_count": ( + len(current_rows) + ), + "current_unnecessary_construction_count": ( + current_unnecessary + ), + }, + "integrity": { + "receipt_chains_valid": ( + receipts_valid + ), + "unique_complete_row_set": ( + integrity_unique + ), + "v03_global_alpha_flags_valid": ( + integrity_version + ), + }, + "claim_gates": ( + gates + ), + "claim_supported": ( + supported + ), + "by_task": ( + by_task + ), + "rows": ( + rows + ), + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m20_universal_arena/runner.py b/experiments/prime_m20_universal_arena/runner.py new file mode 100644 index 0000000..4df8ea6 --- /dev/null +++ b/experiments/prime_m20_universal_arena/runner.py @@ -0,0 +1,534 @@ +"""Dependency-free arena runner for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.grammar import ( + evaluate, + history_value, +) +from core.construction.receipts import ( + verify_receipt_chain, +) + +from .tasks import ( + ArenaTask, + TASKS, +) + + +PPM = 1_000_000 + +STEPS = 1536 +FINAL_WINDOW = 256 + +DEVELOPMENT_SEEDS = tuple( + range( + 600, + 608, + ) +) + +EVALUATION_SEEDS = tuple( + range( + 6000, + 6032, + ) +) + +CONDITIONS = ( + "REACTIVE", + "FIXED-H8", + "ORACLE-FEATURE", + "M20-CONSTRUCTION", +) + + +MASK64 = ( + (1 << 64) + - 1 +) + + +def splitmix64( + value: int, +) -> int: + z = ( + value + + 0x9E3779B97F4A7C15 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 30) + ) + * 0xBF58476D1CE4E5B9 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 27) + ) + * 0x94D049BB133111EB + ) & MASK64 + + return ( + z + ^ (z >> 31) + ) & MASK64 + + +class TargetTableLearner: + def __init__( + self, + seed: int, + ) -> None: + self.seed = seed + + self.counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + def choose( + self, + state: tuple[int, ...], + event_index: int, + ) -> int: + exploration = ( + splitmix64( + self.seed + ^ splitmix64( + event_index + ) + ) + % 10 + == 0 + ) + + if exploration: + return ( + splitmix64( + self.seed + ^ 0xA11CE + ^ splitmix64( + event_index + ) + ) + & 1 + ) + + counts = self.counts.get( + state, + [0, 0], + ) + + return int( + counts[1] + > counts[0] + ) + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + counts = self.counts.setdefault( + state, + [0, 0], + ) + + counts[ + target + ] += 1 + + +@dataclass(frozen=True) +class ArenaResult: + payload: dict + + +def observation_stream( + seed: int, +): + state = splitmix64( + seed + ^ 0x5052494D453230 + ) + + while True: + state = splitmix64( + state + ) + + yield ( + state >> 63 + ) & 1 + + +def fixed_h8_state( + observation: int, + history: tuple[int, ...], +) -> tuple[int, ...]: + return ( + observation, + *( + history_value( + history, + lag_index, + ) + for lag_index + in range( + 1, + 9, + ) + ), + ) + + +def oracle_state( + observation: int, + task: ArenaTask, + history: tuple[int, ...], +) -> tuple[int, ...]: + return ( + observation, + task.target( + history + ), + ) + + +def target_construction_active( + engine: ( + CompositionalAdaptiveConstructionEngine + ), + task: ArenaTask, +) -> bool: + if task.expression is None: + return ( + len( + engine.active_construction_ids + ) + == 0 + ) + + target_hash = ( + task.expression.expression_hash + ) + + return any( + record.spec.expression.expression_hash + == target_hash + for record + in engine.registry.active_records() + ) + + +def run_world( + *, + task: ArenaTask, + stream_seed: int, + condition: str, + permit_evaluation: bool = False, +) -> ArenaResult: + if condition not in CONDITIONS: + raise ValueError( + "unknown arena condition" + ) + + if permit_evaluation: + if ( + stream_seed + not in EVALUATION_SEEDS + ): + raise RuntimeError( + "evaluation mode accepts only frozen evaluation seeds" + ) + else: + if ( + stream_seed + not in DEVELOPMENT_SEEDS + ): + raise RuntimeError( + "development mode accepts only frozen development seeds" + ) + + learner_seed = ( + splitmix64( + stream_seed + ^ sum( + ord(ch) + for ch in condition + ) + ) + ) + + learner = ( + TargetTableLearner( + learner_seed + ) + ) + + engine = None + + if ( + condition + == "M20-CONSTRUCTION" + ): + engine = ( + CompositionalAdaptiveConstructionEngine( + max_lag=8, + max_candidates=256, + enable_scaffolds=True, + ) + ) + + engine.begin_episode() + + stream = ( + observation_stream( + stream_seed + ) + ) + + history: list[ + int + ] = [] + + outcomes: list[ + int + ] = [] + + authorization_events: list[ + int + ] = [] + + authorized_ids: list[ + str + ] = [] + + cumulative = 0 + curve_sum = 0 + + for event_index in range( + STEPS + ): + observation = next( + stream + ) + + history.append( + observation + ) + + if len(history) > 9: + del history[:-9] + + history_tuple = tuple( + history + ) + + target = task.target( + history_tuple + ) + + if condition == "REACTIVE": + state = ( + observation, + ) + + elif condition == "FIXED-H8": + state = fixed_h8_state( + observation, + history_tuple, + ) + + elif condition == "ORACLE-FEATURE": + state = oracle_state( + observation, + task, + history_tuple, + ) + + elif ( + condition + == "M20-CONSTRUCTION" + ): + assert ( + engine is not None + ) + + state = engine.observe( + observation + ) + + else: + raise RuntimeError( + "unreachable condition" + ) + + action = learner.choose( + state, + event_index, + ) + + correct = int( + action + == target + ) + + learner.update( + state, + target, + ) + + if engine is not None: + decision = ( + engine.finalize( + target + ) + ) + + if decision.authorized: + authorization_events.append( + event_index + ) + + assert ( + decision.construction_id + is not None + ) + + authorized_ids.append( + decision.construction_id + ) + + outcomes.append( + correct + ) + + cumulative += correct + + curve_sum += ( + PPM + * cumulative + ) // ( + event_index + 1 + ) + + final_window = ( + outcomes[ + -FINAL_WINDOW: + ] + ) + + receipt_valid = True + active_count = 0 + exact_target = None + field = None + + if engine is not None: + receipt_valid = ( + verify_receipt_chain( + engine.receipt_chain, + expected_count=len( + engine.receipt_chain + ), + ) + ) + + active_count = len( + engine.active_construction_ids + ) + + exact_target = ( + target_construction_active( + engine, + task, + ) + ) + + snapshot = ( + engine.candidate_field_snapshot() + ) + + field = { + "epoch": ( + snapshot.epoch + ), + "candidate_count": ( + snapshot.candidate_count + ), + "primitive_candidate_count": ( + snapshot.primitive_candidate_count + ), + "scaffold_candidate_count": ( + snapshot.scaffold_candidate_count + ), + "composed_candidate_count": ( + snapshot.composed_candidate_count + ), + "active_construction_count": ( + snapshot.active_construction_count + ), + "threshold": ( + snapshot.threshold + ), + } + + payload = { + "task": task.name, + "stream_seed": ( + stream_seed + ), + "condition": condition, + "steps": STEPS, + "primary_aulc_ppm": ( + curve_sum + // STEPS + ), + "final_window_accuracy_ppm": ( + PPM + * sum( + final_window + ) + // len( + final_window + ) + ), + "cumulative_mistakes": ( + STEPS + - sum( + outcomes + ) + ), + "authorized_construction_count": ( + active_count + ), + "authorization_events": ( + authorization_events + ), + "authorized_construction_ids": ( + authorized_ids + ), + "exact_target_construction_active": ( + exact_target + ), + "receipt_chain_valid": ( + receipt_valid + ), + "candidate_field": ( + field + ), + } + + return ArenaResult( + payload=payload + ) diff --git a/experiments/prime_m20_universal_arena/runner_v0_2.py b/experiments/prime_m20_universal_arena/runner_v0_2.py new file mode 100644 index 0000000..5682fc2 --- /dev/null +++ b/experiments/prime_m20_universal_arena/runner_v0_2.py @@ -0,0 +1,702 @@ +"""Corrected v0.2 arena runner for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.grammar import ( + evaluate, + history_value, +) +from core.construction.receipts import ( + verify_receipt_chain, +) +from core.construction.quotient import ( + RELATION_COMPLEMENT, + RELATION_EXACT, + active_partition_matches, +) + +from .tasks import ( + ArenaTask, + TASKS, +) + + +PPM = 1_000_000 + +STEPS = 1536 +FINAL_WINDOW = 256 + +DEVELOPMENT_SEEDS = tuple( + range( + 600, + 608, + ) +) + +EVALUATION_SEEDS = tuple( + range( + 6000, + 6032, + ) +) + +CONDITIONS = ( + "REACTIVE", + "FIXED-H8", + "ORACLE-FEATURE", + "M20-CONSTRUCTION", +) + + +MASK64 = ( + (1 << 64) + - 1 +) + + +def splitmix64( + value: int, +) -> int: + z = ( + value + + 0x9E3779B97F4A7C15 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 30) + ) + * 0xBF58476D1CE4E5B9 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 27) + ) + * 0x94D049BB133111EB + ) & MASK64 + + return ( + z + ^ (z >> 31) + ) & MASK64 + + +class TargetTableLearner: + def __init__( + self, + seed: int, + ) -> None: + self.seed = seed + + self.counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + def choose( + self, + state: tuple[int, ...], + event_index: int, + ) -> int: + exploration = ( + splitmix64( + self.seed + ^ splitmix64( + event_index + ) + ) + % 10 + == 0 + ) + + if exploration: + return ( + splitmix64( + self.seed + ^ 0xA11CE + ^ splitmix64( + event_index + ) + ) + & 1 + ) + + counts = self.counts.get( + state, + [0, 0], + ) + + return int( + counts[1] + > counts[0] + ) + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + counts = self.counts.setdefault( + state, + [0, 0], + ) + + counts[ + target + ] += 1 + + +@dataclass(frozen=True) +class ArenaResult: + payload: dict + + +def observation_stream( + seed: int, +): + state = splitmix64( + seed + ^ 0x5052494D453230 + ) + + while True: + state = splitmix64( + state + ) + + yield ( + state >> 63 + ) & 1 + + +def fixed_h8_state( + observation: int, + history: tuple[int, ...], +) -> tuple[int, ...]: + return ( + observation, + *( + history_value( + history, + lag_index, + ) + for lag_index + in range( + 1, + 9, + ) + ), + ) + + +def oracle_state( + observation: int, + task: ArenaTask, + history: tuple[int, ...], +) -> tuple[int, ...]: + return ( + observation, + task.target( + history + ), + ) + + +def target_construction_active( + engine: ( + CompositionalAdaptiveConstructionEngine + ), + task: ArenaTask, +) -> bool: + if task.expression is None: + return ( + len( + engine.active_construction_ids + ) + == 0 + ) + + target_hash = ( + task.expression.expression_hash + ) + + return any( + record.spec.expression.expression_hash + == target_hash + for record + in engine.registry.active_records() + ) + + +def run_world( + *, + task: ArenaTask, + stream_seed: int, + condition: str, + permit_evaluation: bool = False, +) -> ArenaResult: + if condition not in CONDITIONS: + raise ValueError( + "unknown arena condition" + ) + + if permit_evaluation: + if ( + stream_seed + not in EVALUATION_SEEDS + ): + raise RuntimeError( + "evaluation mode accepts only frozen evaluation seeds" + ) + else: + if ( + stream_seed + not in DEVELOPMENT_SEEDS + ): + raise RuntimeError( + "development mode accepts only frozen development seeds" + ) + + # v0.2 paired-control fix: + # identical exploration randomness for every + # condition on the same task/stream world. + learner_seed = ( + splitmix64( + stream_seed + ^ 0x4D3230563032 + ) + ) + + learner = ( + TargetTableLearner( + learner_seed + ) + ) + + engine = None + + if ( + condition + == "M20-CONSTRUCTION" + ): + engine = ( + CompositionalAdaptiveConstructionEngine( + max_lag=8, + max_candidates=256, + enable_scaffolds=True, + ) + ) + + engine.begin_episode() + + stream = ( + observation_stream( + stream_seed + ) + ) + + history: list[ + int + ] = [] + + outcomes: list[ + int + ] = [] + + targets: list[ + int + ] = [] + + authorization_events: list[ + int + ] = [] + + authorized_ids: list[ + str + ] = [] + + cumulative = 0 + curve_sum = 0 + + for event_index in range( + STEPS + ): + observation = next( + stream + ) + + history.append( + observation + ) + + if len(history) > 9: + del history[:-9] + + history_tuple = tuple( + history + ) + + target = task.target( + history_tuple + ) + + if condition == "REACTIVE": + state = ( + observation, + ) + + elif condition == "FIXED-H8": + state = fixed_h8_state( + observation, + history_tuple, + ) + + elif condition == "ORACLE-FEATURE": + state = oracle_state( + observation, + task, + history_tuple, + ) + + elif ( + condition + == "M20-CONSTRUCTION" + ): + assert ( + engine is not None + ) + + state = engine.observe( + observation + ) + + else: + raise RuntimeError( + "unreachable condition" + ) + + action = learner.choose( + state, + event_index, + ) + + correct = int( + action + == target + ) + + learner.update( + state, + target, + ) + + if engine is not None: + decision = ( + engine.finalize( + target + ) + ) + + if decision.authorized: + authorization_events.append( + event_index + ) + + assert ( + decision.construction_id + is not None + ) + + authorized_ids.append( + decision.construction_id + ) + + outcomes.append( + correct + ) + + targets.append( + target + ) + + cumulative += correct + + curve_sum += ( + PPM + * cumulative + ) // ( + event_index + 1 + ) + + final_window = ( + outcomes[ + -FINAL_WINDOW: + ] + ) + + receipt_valid = True + active_count = 0 + exact_target = None + partition_target = None + partition_relations = [] + field = None + + if engine is not None: + receipt_valid = ( + verify_receipt_chain( + engine.receipt_chain, + expected_count=len( + engine.receipt_chain + ), + ) + ) + + active_count = len( + engine.active_construction_ids + ) + + exact_target = ( + target_construction_active( + engine, + task, + ) + ) + + if task.expression is None: + partition_target = ( + active_count == 0 + ) + else: + matches = ( + active_partition_matches( + engine.registry, + task.expression, + max_lag=8, + ) + ) + + partition_target = bool( + matches + ) + + partition_relations = [ + { + "construction_id": ( + match.construction_id + ), + "relation": ( + match.relation + ), + } + for match in matches + ] + + snapshot = ( + engine.candidate_field_snapshot() + ) + + field = { + "epoch": ( + snapshot.epoch + ), + "candidate_count": ( + snapshot.candidate_count + ), + "primitive_candidate_count": ( + snapshot.primitive_candidate_count + ), + "scaffold_candidate_count": ( + snapshot.scaffold_candidate_count + ), + "composed_candidate_count": ( + snapshot.composed_candidate_count + ), + "active_construction_count": ( + snapshot.active_construction_count + ), + "threshold": ( + snapshot.threshold + ), + } + + total_target_ones = sum( + targets + ) + + total_target_zeroes = ( + len(targets) + - total_target_ones + ) + + total_correct = sum( + outcomes + ) + + accuracy_ppm = ( + PPM + * total_correct + // len(outcomes) + ) + + best_constant_accuracy_ppm = ( + PPM + * max( + total_target_ones, + total_target_zeroes, + ) + // len(targets) + ) + + def balanced_accuracy( + correct_values, + target_values, + ): + zero_count = sum( + target == 0 + for target in target_values + ) + + one_count = ( + len(target_values) + - zero_count + ) + + if ( + zero_count == 0 + or one_count == 0 + ): + return None + + correct_zero = sum( + correct + for correct, target + in zip( + correct_values, + target_values, + ) + if target == 0 + ) + + correct_one = sum( + correct + for correct, target + in zip( + correct_values, + target_values, + ) + if target == 1 + ) + + zero_ppm = ( + PPM + * correct_zero + // zero_count + ) + + one_ppm = ( + PPM + * correct_one + // one_count + ) + + return ( + zero_ppm + + one_ppm + ) // 2 + + final_targets = targets[ + -FINAL_WINDOW: + ] + + final_outcomes = outcomes[ + -FINAL_WINDOW: + ] + + payload = { + "task": task.name, + "stream_seed": ( + stream_seed + ), + "condition": condition, + "steps": STEPS, + "primary_aulc_ppm": ( + curve_sum + // STEPS + ), + "final_window_accuracy_ppm": ( + PPM + * sum( + final_window + ) + // len( + final_window + ) + ), + "cumulative_mistakes": ( + STEPS + - total_correct + ), + "accuracy_ppm": ( + accuracy_ppm + ), + "balanced_accuracy_ppm": ( + balanced_accuracy( + outcomes, + targets, + ) + ), + "final_window_balanced_accuracy_ppm": ( + balanced_accuracy( + final_outcomes, + final_targets, + ) + ), + "target_prevalence_ppm": ( + PPM + * total_target_ones + // len(targets) + ), + "best_constant_accuracy_ppm": ( + best_constant_accuracy_ppm + ), + "excess_over_constant_ppm": ( + accuracy_ppm + - best_constant_accuracy_ppm + ), + "authorized_construction_count": ( + active_count + ), + "authorization_events": ( + authorization_events + ), + "authorized_construction_ids": ( + authorized_ids + ), + "exact_target_construction_active": ( + exact_target + ), + "predictive_partition_recovered": ( + partition_target + ), + "partition_matches": ( + partition_relations + ), + "receipt_chain_valid": ( + receipt_valid + ), + "candidate_field": ( + field + ), + } + + return ArenaResult( + payload=payload + ) diff --git a/experiments/prime_m20_universal_arena/runner_v0_3.py b/experiments/prime_m20_universal_arena/runner_v0_3.py new file mode 100644 index 0000000..fed4099 --- /dev/null +++ b/experiments/prime_m20_universal_arena/runner_v0_3.py @@ -0,0 +1,730 @@ +"""Globally alpha-spent v0.3 arena runner for PRIME M20.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.grammar import ( + evaluate, + history_value, +) +from core.construction.receipts import ( + verify_receipt_chain, +) +from core.construction.quotient import ( + RELATION_COMPLEMENT, + RELATION_EXACT, + active_partition_matches, +) + +from .tasks import ( + ArenaTask, + TASKS, +) + + +ARENA_VERSION = "v0.3" +GLOBAL_ALPHA_SPENDING = True + +PPM = 1_000_000 + +STEPS = 1536 +FINAL_WINDOW = 256 + +DEVELOPMENT_SEEDS = tuple( + range( + 600, + 608, + ) +) + +EVALUATION_SEEDS = tuple( + range( + 6000, + 6032, + ) +) + +CONDITIONS = ( + "REACTIVE", + "FIXED-H8", + "ORACLE-FEATURE", + "M20-CONSTRUCTION", +) + + +MASK64 = ( + (1 << 64) + - 1 +) + + +def splitmix64( + value: int, +) -> int: + z = ( + value + + 0x9E3779B97F4A7C15 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 30) + ) + * 0xBF58476D1CE4E5B9 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 27) + ) + * 0x94D049BB133111EB + ) & MASK64 + + return ( + z + ^ (z >> 31) + ) & MASK64 + + +class TargetTableLearner: + def __init__( + self, + seed: int, + ) -> None: + self.seed = seed + + self.counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + def choose( + self, + state: tuple[int, ...], + event_index: int, + ) -> int: + exploration = ( + splitmix64( + self.seed + ^ splitmix64( + event_index + ) + ) + % 10 + == 0 + ) + + if exploration: + return ( + splitmix64( + self.seed + ^ 0xA11CE + ^ splitmix64( + event_index + ) + ) + & 1 + ) + + counts = self.counts.get( + state, + [0, 0], + ) + + return int( + counts[1] + > counts[0] + ) + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + counts = self.counts.setdefault( + state, + [0, 0], + ) + + counts[ + target + ] += 1 + + +@dataclass(frozen=True) +class ArenaResult: + payload: dict + + +def observation_stream( + seed: int, +): + state = splitmix64( + seed + ^ 0x5052494D453230 + ) + + while True: + state = splitmix64( + state + ) + + yield ( + state >> 63 + ) & 1 + + +def fixed_h8_state( + observation: int, + history: tuple[int, ...], +) -> tuple[int, ...]: + return ( + observation, + *( + history_value( + history, + lag_index, + ) + for lag_index + in range( + 1, + 9, + ) + ), + ) + + +def oracle_state( + observation: int, + task: ArenaTask, + history: tuple[int, ...], +) -> tuple[int, ...]: + return ( + observation, + task.target( + history + ), + ) + + +def target_construction_active( + engine: ( + CompositionalAdaptiveConstructionEngine + ), + task: ArenaTask, +) -> bool: + if task.expression is None: + return ( + len( + engine.active_construction_ids + ) + == 0 + ) + + target_hash = ( + task.expression.expression_hash + ) + + return any( + record.spec.expression.expression_hash + == target_hash + for record + in engine.registry.active_records() + ) + + +def run_world( + *, + task: ArenaTask, + stream_seed: int, + condition: str, + permit_evaluation: bool = False, +) -> ArenaResult: + if condition not in CONDITIONS: + raise ValueError( + "unknown arena condition" + ) + + if permit_evaluation: + if ( + stream_seed + not in EVALUATION_SEEDS + ): + raise RuntimeError( + "evaluation mode accepts only frozen evaluation seeds" + ) + else: + if ( + stream_seed + not in DEVELOPMENT_SEEDS + ): + raise RuntimeError( + "development mode accepts only frozen development seeds" + ) + + # v0.2 paired-control fix: + # identical exploration randomness for every + # condition on the same task/stream world. + learner_seed = ( + splitmix64( + stream_seed + ^ 0x4D3230563032 + ) + ) + + learner = ( + TargetTableLearner( + learner_seed + ) + ) + + engine = None + + if ( + condition + == "M20-CONSTRUCTION" + ): + engine = ( + CompositionalAdaptiveConstructionEngine( + max_lag=8, + max_candidates=256, + enable_scaffolds=True, + ) + ) + + initial_field = ( + engine.candidate_field_snapshot() + ) + + if ( + initial_field.epoch != 0 + or initial_field.alpha_denominator + != 128 + or initial_field.threshold + != ( + 128 + * initial_field.candidate_count + ) + ): + raise RuntimeError( + "v0.3 global alpha schedule invariant failed" + ) + + engine.begin_episode() + + stream = ( + observation_stream( + stream_seed + ) + ) + + history: list[ + int + ] = [] + + outcomes: list[ + int + ] = [] + + targets: list[ + int + ] = [] + + authorization_events: list[ + int + ] = [] + + authorized_ids: list[ + str + ] = [] + + cumulative = 0 + curve_sum = 0 + + for event_index in range( + STEPS + ): + observation = next( + stream + ) + + history.append( + observation + ) + + if len(history) > 9: + del history[:-9] + + history_tuple = tuple( + history + ) + + target = task.target( + history_tuple + ) + + if condition == "REACTIVE": + state = ( + observation, + ) + + elif condition == "FIXED-H8": + state = fixed_h8_state( + observation, + history_tuple, + ) + + elif condition == "ORACLE-FEATURE": + state = oracle_state( + observation, + task, + history_tuple, + ) + + elif ( + condition + == "M20-CONSTRUCTION" + ): + assert ( + engine is not None + ) + + state = engine.observe( + observation + ) + + else: + raise RuntimeError( + "unreachable condition" + ) + + action = learner.choose( + state, + event_index, + ) + + correct = int( + action + == target + ) + + learner.update( + state, + target, + ) + + if engine is not None: + decision = ( + engine.finalize( + target + ) + ) + + if decision.authorized: + authorization_events.append( + event_index + ) + + assert ( + decision.construction_id + is not None + ) + + authorized_ids.append( + decision.construction_id + ) + + outcomes.append( + correct + ) + + targets.append( + target + ) + + cumulative += correct + + curve_sum += ( + PPM + * cumulative + ) // ( + event_index + 1 + ) + + final_window = ( + outcomes[ + -FINAL_WINDOW: + ] + ) + + receipt_valid = True + active_count = 0 + exact_target = None + partition_target = None + partition_relations = [] + field = None + + if engine is not None: + receipt_valid = ( + verify_receipt_chain( + engine.receipt_chain, + expected_count=len( + engine.receipt_chain + ), + ) + ) + + active_count = len( + engine.active_construction_ids + ) + + exact_target = ( + target_construction_active( + engine, + task, + ) + ) + + if task.expression is None: + partition_target = ( + active_count == 0 + ) + else: + matches = ( + active_partition_matches( + engine.registry, + task.expression, + max_lag=8, + ) + ) + + partition_target = bool( + matches + ) + + partition_relations = [ + { + "construction_id": ( + match.construction_id + ), + "relation": ( + match.relation + ), + } + for match in matches + ] + + snapshot = ( + engine.candidate_field_snapshot() + ) + + field = { + "epoch": ( + snapshot.epoch + ), + "candidate_count": ( + snapshot.candidate_count + ), + "primitive_candidate_count": ( + snapshot.primitive_candidate_count + ), + "scaffold_candidate_count": ( + snapshot.scaffold_candidate_count + ), + "composed_candidate_count": ( + snapshot.composed_candidate_count + ), + "active_construction_count": ( + snapshot.active_construction_count + ), + "alpha_denominator": ( + snapshot.alpha_denominator + ), + "threshold": ( + snapshot.threshold + ), + } + + total_target_ones = sum( + targets + ) + + total_target_zeroes = ( + len(targets) + - total_target_ones + ) + + total_correct = sum( + outcomes + ) + + accuracy_ppm = ( + PPM + * total_correct + // len(outcomes) + ) + + best_constant_accuracy_ppm = ( + PPM + * max( + total_target_ones, + total_target_zeroes, + ) + // len(targets) + ) + + def balanced_accuracy( + correct_values, + target_values, + ): + zero_count = sum( + target == 0 + for target in target_values + ) + + one_count = ( + len(target_values) + - zero_count + ) + + if ( + zero_count == 0 + or one_count == 0 + ): + return None + + correct_zero = sum( + correct + for correct, target + in zip( + correct_values, + target_values, + ) + if target == 0 + ) + + correct_one = sum( + correct + for correct, target + in zip( + correct_values, + target_values, + ) + if target == 1 + ) + + zero_ppm = ( + PPM + * correct_zero + // zero_count + ) + + one_ppm = ( + PPM + * correct_one + // one_count + ) + + return ( + zero_ppm + + one_ppm + ) // 2 + + final_targets = targets[ + -FINAL_WINDOW: + ] + + final_outcomes = outcomes[ + -FINAL_WINDOW: + ] + + payload = { + "arena_version": ARENA_VERSION, + "global_alpha_spending": ( + GLOBAL_ALPHA_SPENDING + ), + "task": task.name, + "stream_seed": ( + stream_seed + ), + "condition": condition, + "steps": STEPS, + "primary_aulc_ppm": ( + curve_sum + // STEPS + ), + "final_window_accuracy_ppm": ( + PPM + * sum( + final_window + ) + // len( + final_window + ) + ), + "cumulative_mistakes": ( + STEPS + - total_correct + ), + "accuracy_ppm": ( + accuracy_ppm + ), + "balanced_accuracy_ppm": ( + balanced_accuracy( + outcomes, + targets, + ) + ), + "final_window_balanced_accuracy_ppm": ( + balanced_accuracy( + final_outcomes, + final_targets, + ) + ), + "target_prevalence_ppm": ( + PPM + * total_target_ones + // len(targets) + ), + "best_constant_accuracy_ppm": ( + best_constant_accuracy_ppm + ), + "excess_over_constant_ppm": ( + accuracy_ppm + - best_constant_accuracy_ppm + ), + "authorized_construction_count": ( + active_count + ), + "authorization_events": ( + authorization_events + ), + "authorized_construction_ids": ( + authorized_ids + ), + "exact_target_construction_active": ( + exact_target + ), + "predictive_partition_recovered": ( + partition_target + ), + "partition_matches": ( + partition_relations + ), + "receipt_chain_valid": ( + receipt_valid + ), + "candidate_field": ( + field + ), + } + + return ArenaResult( + payload=payload + ) diff --git a/experiments/prime_m20_universal_arena/tasks.py b/experiments/prime_m20_universal_arena/tasks.py new file mode 100644 index 0000000..a10baa7 --- /dev/null +++ b/experiments/prime_m20_universal_arena/tasks.py @@ -0,0 +1,177 @@ +"""Task definitions for PRIME M20 Universal Adaptive-State Arena.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.grammar import ( + binary, + evaluate, + lag, +) +from core.construction.scaffold import ( + fold_commutative, +) +from core.construction.types import ( + FeatureExpr, + FeatureOp, +) + + +@dataclass(frozen=True) +class ArenaTask: + name: str + expression: ( + FeatureExpr + | None + ) + + def target( + self, + history: tuple[ + int, + ..., + ], + ) -> int: + if self.expression is None: + if not history: + return 0 + + return history[-1] + + return evaluate( + self.expression, + history, + ) + + +def xor( + a: int, + b: int, +) -> FeatureExpr: + return binary( + FeatureOp.XOR, + lag(a), + lag(b), + ) + + +def eq( + a: int, + b: int, +) -> FeatureExpr: + return binary( + FeatureOp.EQ, + lag(a), + lag(b), + ) + + +def and2( + a: int, + b: int, +) -> FeatureExpr: + return binary( + FeatureOp.AND, + lag(a), + lag(b), + ) + + +def or2( + a: int, + b: int, +) -> FeatureExpr: + return binary( + FeatureOp.OR, + lag(a), + lag(b), + ) + + +def triple( + op: FeatureOp, + a: int, + b: int, + c: int, +) -> FeatureExpr: + return fold_commutative( + op, + ( + lag(a), + lag(b), + lag(c), + ), + ) + + +TASKS = ( + ArenaTask( + "CURRENT", + None, + ), + ArenaTask( + "LAG-1", + lag(1), + ), + ArenaTask( + "LAG-4", + lag(4), + ), + ArenaTask( + "LAG-7", + lag(7), + ), + ArenaTask( + "XOR-1-4", + xor(1, 4), + ), + ArenaTask( + "XOR-2-7", + xor(2, 7), + ), + ArenaTask( + "EQ-1-4", + eq(1, 4), + ), + ArenaTask( + "AND-1-4", + and2(1, 4), + ), + ArenaTask( + "OR-2-7", + or2(2, 7), + ), + ArenaTask( + "XOR-1-2-3", + triple( + FeatureOp.XOR, + 1, + 2, + 3, + ), + ), + ArenaTask( + "AND-1-2-4", + triple( + FeatureOp.AND, + 1, + 2, + 4, + ), + ), + ArenaTask( + "OR-2-3-4", + triple( + FeatureOp.OR, + 2, + 3, + 4, + ), + ), +) + +TASK_BY_NAME = { + task.name: task + for task in TASKS +} diff --git a/experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.json b/experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.json new file mode 100644 index 0000000..db5b29a --- /dev/null +++ b/experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.json @@ -0,0 +1,1939 @@ +{ + "by_role": { + "family-learning": { + "chapter_count": 4, + "mean_aulc_gain_ppm": -3978, + "mean_transfer_gain_events": -5, + "negative_transfer": 4, + "positive_transfer": 0, + "ties": 0 + }, + "long-range-recall": { + "chapter_count": 2, + "mean_aulc_gain_ppm": 7070, + "mean_transfer_gain_events": 6, + "negative_transfer": 0, + "positive_transfer": 2, + "ties": 0 + }, + "negative-transfer": { + "chapter_count": 1, + "mean_aulc_gain_ppm": 0, + "mean_transfer_gain_events": null, + "negative_transfer": 0, + "positive_transfer": 0, + "ties": 0 + }, + "novel": { + "chapter_count": 8, + "mean_aulc_gain_ppm": -551, + "mean_transfer_gain_events": -8, + "negative_transfer": 6, + "positive_transfer": 0, + "ties": 1 + }, + "quotient-transfer": { + "chapter_count": 1, + "mean_aulc_gain_ppm": 19984, + "mean_transfer_gain_events": 8, + "negative_transfer": 0, + "positive_transfer": 1, + "ties": 0 + }, + "repeat": { + "chapter_count": 3, + "mean_aulc_gain_ppm": 16097, + "mean_transfer_gain_events": 15, + "negative_transfer": 0, + "positive_transfer": 3, + "ties": 0 + }, + "schema-transfer": { + "chapter_count": 6, + "mean_aulc_gain_ppm": 6096, + "mean_transfer_gain_events": 14, + "negative_transfer": 1, + "positive_transfer": 5, + "ties": 0 + } + }, + "chapter_count": 25, + "cold_recovery_count": 25, + "cold_rows": [ + { + "accepted_priority_count": 0, + "accuracy_ppm": 946289, + "active_construction_count": 0, + "aulc_ppm": 942241, + "authorized_ids": [], + "chapter_id": "C00-current", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 937500, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22000, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 836586, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C01-lag1", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 949218, + "first_authorization_event": 60, + "first_recovery_event": 60, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22001, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 908203, + "active_construction_count": 1, + "aulc_ppm": 828988, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C02-xor1-4", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 925781, + "first_authorization_event": 51, + "first_recovery_event": 51, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22002, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 869900, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C03-and1-4", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 179, + "first_recovery_event": 179, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22003, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 927734, + "active_construction_count": 1, + "aulc_ppm": 852150, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C04-lag1-repeat", + "developmental_role": "repeat", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 972656, + "first_authorization_event": 48, + "first_recovery_event": 48, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22004, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 915039, + "active_construction_count": 1, + "aulc_ppm": 847802, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C05-xor1-4-repeat", + "developmental_role": "repeat", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 933593, + "first_authorization_event": 63, + "first_recovery_event": 63, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22005, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 880975, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C06-and1-4-repeat", + "developmental_role": "repeat", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 933593, + "first_authorization_event": 136, + "first_recovery_event": 136, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22006, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 853327, + "authorized_ids": [ + "cx:69bd2ef3e74f9643af24859bea628bfd2c4e00a5a10c598922442a8ef785885c" + ], + "chapter_id": "C07-xor2-5", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 960937, + "first_authorization_event": 59, + "first_recovery_event": 59, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22007, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 931640, + "active_construction_count": 1, + "aulc_ppm": 879675, + "authorized_ids": [ + "cx:9641b24fbdee515b24a003a7dc9b9be0b87f0292d44101b88987f7b96297e9ef" + ], + "chapter_id": "C08-xor3-6", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 941406, + "first_authorization_event": 77, + "first_recovery_event": 77, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22008, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 921875, + "active_construction_count": 1, + "aulc_ppm": 855591, + "authorized_ids": [ + "cx:026cf589a29f8fa72a1f5ce6b57c7d72cb17ac6f2a3b35d9a813f84e7c82aba7" + ], + "chapter_id": "C09-xor4-7", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 55, + "first_recovery_event": 55, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22009, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 880763, + "authorized_ids": [ + "cx:a6118412a2161cb245196a224ca639f05a7e97d7f7697304ef3cc1c039de4bd0" + ], + "chapter_id": "C10-and2-5", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 941406, + "first_authorization_event": 131, + "first_recovery_event": 131, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22010, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 876916, + "authorized_ids": [ + "cx:99808bb3af376ae1e4e3944d16b64ec286efd32146edfce97ddd60fb0978c7d3" + ], + "chapter_id": "C11-and3-6", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 953125, + "first_authorization_event": 185, + "first_recovery_event": 185, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22011, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 875022, + "authorized_ids": [ + "cx:56f9e955c4ff07d6812692e0563ec9b9b9ac6e64bc246819e44098318944789d" + ], + "chapter_id": "C12-and4-7", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 964843, + "first_authorization_event": 130, + "first_recovery_event": 130, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22012, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 904296, + "active_construction_count": 1, + "aulc_ppm": 832848, + "authorized_ids": [ + "cx:3c381ca4b7647494bd90e31fa8ca4301d8188691e9b1a82b0bf3fe292256bdbd" + ], + "chapter_id": "C13-or1-4", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 132, + "first_recovery_event": 132, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22013, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 924804, + "active_construction_count": 1, + "aulc_ppm": 854357, + "authorized_ids": [ + "cx:2a6df23137dd1f89a7a145497796aa0023f55106867871974c990f54454e8f10" + ], + "chapter_id": "C14-or2-5", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 96, + "first_recovery_event": 96, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22014, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 922851, + "active_construction_count": 1, + "aulc_ppm": 843339, + "authorized_ids": [ + "cx:869ff5f4e15edfa7d543e017916c7df91e793dec5b3cc0e39905f70cde6c2c12" + ], + "chapter_id": "C15-or3-6", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 960937, + "first_authorization_event": 80, + "first_recovery_event": 80, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22015, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 916992, + "active_construction_count": 1, + "aulc_ppm": 837896, + "authorized_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "chapter_id": "C16-xor123", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 949218, + "first_authorization_event": 61, + "first_recovery_event": 61, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22016, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 931640, + "active_construction_count": 1, + "aulc_ppm": 849242, + "authorized_ids": [ + "cx:2fb2b079d27f35d42956ef15a8ef417d32879747cd01b2bf2d6e0efa5f944ebd" + ], + "chapter_id": "C17-xor234", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 964843, + "first_authorization_event": 60, + "first_recovery_event": 60, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22017, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 908203, + "active_construction_count": 1, + "aulc_ppm": 851831, + "authorized_ids": [ + "cx:285cab98bfb692df8ab1bbf04a69aa81eacff3c9309b635d184b27fd68728ad2" + ], + "chapter_id": "C18-xor345", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 58, + "first_recovery_event": 58, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22018, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 922851, + "active_construction_count": 1, + "aulc_ppm": 840325, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C19-eq1-4", + "developmental_role": "quotient-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 960937, + "first_authorization_event": 49, + "first_recovery_event": 49, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22019, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 952148, + "active_construction_count": 0, + "aulc_ppm": 934241, + "authorized_ids": [], + "chapter_id": "C20-current", + "developmental_role": "negative-transfer", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 992187, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22020, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 902343, + "active_construction_count": 1, + "aulc_ppm": 831310, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C21-xor1-4-long-return", + "developmental_role": "long-range-recall", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 914062, + "first_authorization_event": 53, + "first_recovery_event": 53, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22021, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 927734, + "active_construction_count": 1, + "aulc_ppm": 851462, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C22-lag1-long-return", + "developmental_role": "long-range-recall", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 933593, + "first_authorization_event": 50, + "first_recovery_event": 50, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22022, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 917968, + "active_construction_count": 1, + "aulc_ppm": 881333, + "authorized_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "chapter_id": "C23-and124", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 949218, + "first_authorization_event": 284, + "first_recovery_event": 284, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22023, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 921875, + "active_construction_count": 1, + "aulc_ppm": 875124, + "authorized_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "chapter_id": "C24-or234", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 957031, + "first_authorization_event": 195, + "first_recovery_event": 195, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22024, + "steps": 1024 + } + ], + "comparable_recovery_count": 23, + "comparisons": [ + { + "aulc_gain_ppm": 0, + "chapter_id": "C00-current", + "cold_aulc_ppm": 942241, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": null, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 942241, + "persistent_candidates": 256, + "persistent_primed": false, + "persistent_priority_candidates": 0, + "persistent_recovered": true, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": 0, + "chapter_id": "C01-lag1", + "cold_aulc_ppm": 836586, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 60, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 836586, + "persistent_candidates": 256, + "persistent_primed": false, + "persistent_priority_candidates": 0, + "persistent_recovered": true, + "persistent_recovery_event": 60, + "transfer_gain_events": 0 + }, + { + "aulc_gain_ppm": 6003, + "chapter_id": "C02-xor1-4", + "cold_aulc_ppm": 828988, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 51, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 834991, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 1, + "persistent_recovered": true, + "persistent_recovery_event": 59, + "transfer_gain_events": -8 + }, + { + "aulc_gain_ppm": -3167, + "chapter_id": "C03-and1-4", + "cold_aulc_ppm": 869900, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 179, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 866733, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 2, + "persistent_recovered": true, + "persistent_recovery_event": 190, + "transfer_gain_events": -11 + }, + { + "aulc_gain_ppm": 20927, + "chapter_id": "C04-lag1-repeat", + "cold_aulc_ppm": 852150, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 48, + "developmental_role": "repeat", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 873077, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 36, + "transfer_gain_events": 12 + }, + { + "aulc_gain_ppm": 7735, + "chapter_id": "C05-xor1-4-repeat", + "cold_aulc_ppm": 847802, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 63, + "developmental_role": "repeat", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 855537, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 47, + "transfer_gain_events": 16 + }, + { + "aulc_gain_ppm": 19630, + "chapter_id": "C06-and1-4-repeat", + "cold_aulc_ppm": 880975, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 136, + "developmental_role": "repeat", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 900605, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 118, + "transfer_gain_events": 18 + }, + { + "aulc_gain_ppm": 432, + "chapter_id": "C07-xor2-5", + "cold_aulc_ppm": 853327, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 59, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 853759, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 66, + "transfer_gain_events": -7 + }, + { + "aulc_gain_ppm": -4727, + "chapter_id": "C08-xor3-6", + "cold_aulc_ppm": 879675, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 77, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 874948, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 4, + "persistent_recovered": true, + "persistent_recovery_event": 86, + "transfer_gain_events": -9 + }, + { + "aulc_gain_ppm": 11685, + "chapter_id": "C09-xor4-7", + "cold_aulc_ppm": 855591, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 55, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 867276, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 8, + "persistent_recovered": true, + "persistent_recovery_event": 45, + "transfer_gain_events": 10 + }, + { + "aulc_gain_ppm": 1976, + "chapter_id": "C10-and2-5", + "cold_aulc_ppm": 880763, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 131, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 882739, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 8, + "persistent_recovered": true, + "persistent_recovery_event": 134, + "transfer_gain_events": -3 + }, + { + "aulc_gain_ppm": 13407, + "chapter_id": "C11-and3-6", + "cold_aulc_ppm": 876916, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 185, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 890323, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 12, + "persistent_recovered": true, + "persistent_recovery_event": 143, + "transfer_gain_events": 42 + }, + { + "aulc_gain_ppm": 5640, + "chapter_id": "C12-and4-7", + "cold_aulc_ppm": 875022, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 130, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 880662, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 12, + "persistent_recovered": true, + "persistent_recovery_event": 107, + "transfer_gain_events": 23 + }, + { + "aulc_gain_ppm": 306, + "chapter_id": "C13-or1-4", + "cold_aulc_ppm": 832848, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 132, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 833154, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 12, + "persistent_recovered": true, + "persistent_recovery_event": 143, + "transfer_gain_events": -11 + }, + { + "aulc_gain_ppm": -10419, + "chapter_id": "C14-or2-5", + "cold_aulc_ppm": 854357, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 96, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 843938, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 13, + "persistent_recovered": true, + "persistent_recovery_event": 103, + "transfer_gain_events": -7 + }, + { + "aulc_gain_ppm": 13404, + "chapter_id": "C15-or3-6", + "cold_aulc_ppm": 843339, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 80, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 856743, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": 61, + "transfer_gain_events": 19 + }, + { + "aulc_gain_ppm": -10640, + "chapter_id": "C16-xor123", + "cold_aulc_ppm": 837896, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 61, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 827256, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": 64, + "transfer_gain_events": -3 + }, + { + "aulc_gain_ppm": -7899, + "chapter_id": "C17-xor234", + "cold_aulc_ppm": 849242, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 60, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 841343, + "persistent_candidates": 256, + "persistent_primed": true, + "persistent_priority_candidates": 18, + "persistent_recovered": true, + "persistent_recovery_event": 62, + "transfer_gain_events": -2 + }, + { + "aulc_gain_ppm": -2829, + "chapter_id": "C18-xor345", + "cold_aulc_ppm": 851831, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 58, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 849002, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 23, + "persistent_recovered": true, + "persistent_recovery_event": 54, + "transfer_gain_events": 4 + }, + { + "aulc_gain_ppm": 19984, + "chapter_id": "C19-eq1-4", + "cold_aulc_ppm": 840325, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 49, + "developmental_role": "quotient-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 860309, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 23, + "persistent_recovered": true, + "persistent_recovery_event": 41, + "transfer_gain_events": 8 + }, + { + "aulc_gain_ppm": 0, + "chapter_id": "C20-current", + "cold_aulc_ppm": 934241, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": null, + "developmental_role": "negative-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 934241, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 23, + "persistent_recovered": true, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": 11239, + "chapter_id": "C21-xor1-4-long-return", + "cold_aulc_ppm": 831310, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 53, + "developmental_role": "long-range-recall", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 842549, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 23, + "persistent_recovered": true, + "persistent_recovery_event": 45, + "transfer_gain_events": 8 + }, + { + "aulc_gain_ppm": 2901, + "chapter_id": "C22-lag1-long-return", + "cold_aulc_ppm": 851462, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 50, + "developmental_role": "long-range-recall", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 854363, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 23, + "persistent_recovered": true, + "persistent_recovery_event": 46, + "transfer_gain_events": 4 + }, + { + "aulc_gain_ppm": 1238, + "chapter_id": "C23-and124", + "cold_aulc_ppm": 881333, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 284, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 882571, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 23, + "persistent_recovered": true, + "persistent_recovery_event": 286, + "transfer_gain_events": -2 + }, + { + "aulc_gain_ppm": 1854, + "chapter_id": "C24-or234", + "cold_aulc_ppm": 875124, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 195, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 876978, + "persistent_candidates": 257, + "persistent_primed": true, + "persistent_priority_candidates": 24, + "persistent_recovered": true, + "persistent_recovery_event": 215, + "transfer_gain_events": -20 + } + ], + "episode_chain_valid": true, + "episodic_memory_count": 25, + "experiment": "prime-m22-cognitive-search-ecology", + "mean_aulc_gain_ppm": 3947, + "mean_transfer_gain_events": 3, + "meta_sources": {}, + "negative_transfer_chapters": 11, + "persistent_recovery_count": 25, + "persistent_rows": [ + { + "accepted_priority_count": 0, + "accuracy_ppm": 946289, + "active_construction_count": 0, + "aulc_ppm": 942241, + "authorized_ids": [], + "chapter_id": "C00-current", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 937500, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": true, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22000, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 836586, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C01-lag1", + "developmental_role": "novel", + "ecology_maximum_threshold": 32768, + "ecology_minimum_threshold": 32768, + "ecology_priority_count": 0, + "ecology_priority_mass_ppm": 0, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 949218, + "first_authorization_event": 60, + "first_recovery_event": 60, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": true, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22001, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 910156, + "active_construction_count": 1, + "aulc_ppm": 834991, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C02-xor1-4", + "developmental_role": "novel", + "ecology_maximum_threshold": 65536, + "ecology_minimum_threshold": 256, + "ecology_priority_count": 1, + "ecology_priority_mass_ppm": 501953, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 925781, + "first_authorization_event": 59, + "first_recovery_event": 59, + "initial_candidate_count": 256, + "initial_threshold": 65536, + "persistent": true, + "primed": true, + "priority_candidate_count": 1, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22002, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 921875, + "active_construction_count": 1, + "aulc_ppm": 866733, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C03-and1-4", + "developmental_role": "novel", + "ecology_maximum_threshold": 65528, + "ecology_minimum_threshold": 382, + "ecology_priority_count": 2, + "ecology_priority_mass_ppm": 503845, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 190, + "first_recovery_event": 190, + "initial_candidate_count": 256, + "initial_threshold": 65528, + "persistent": true, + "primed": true, + "priority_candidate_count": 2, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22003, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 934570, + "active_construction_count": 1, + "aulc_ppm": 873077, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C04-lag1-repeat", + "developmental_role": "repeat", + "ecology_maximum_threshold": 65528, + "ecology_minimum_threshold": 508, + "ecology_priority_count": 3, + "ecology_priority_mass_ppm": 505799, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 972656, + "first_authorization_event": 36, + "first_recovery_event": 36, + "initial_candidate_count": 256, + "initial_threshold": 65528, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22004, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 917968, + "active_construction_count": 1, + "aulc_ppm": 855537, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C05-xor1-4-repeat", + "developmental_role": "repeat", + "ecology_maximum_threshold": 65528, + "ecology_minimum_threshold": 508, + "ecology_priority_count": 3, + "ecology_priority_mass_ppm": 505799, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 933593, + "first_authorization_event": 47, + "first_recovery_event": 47, + "initial_candidate_count": 256, + "initial_threshold": 65528, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22005, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 938476, + "active_construction_count": 1, + "aulc_ppm": 900605, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C06-and1-4-repeat", + "developmental_role": "repeat", + "ecology_maximum_threshold": 65528, + "ecology_minimum_threshold": 508, + "ecology_priority_count": 3, + "ecology_priority_mass_ppm": 505799, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 933593, + "first_authorization_event": 118, + "first_recovery_event": 118, + "initial_candidate_count": 256, + "initial_threshold": 65528, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22006, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 853759, + "authorized_ids": [ + "cx:69bd2ef3e74f9643af24859bea628bfd2c4e00a5a10c598922442a8ef785885c" + ], + "chapter_id": "C07-xor2-5", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 65528, + "ecology_minimum_threshold": 508, + "ecology_priority_count": 3, + "ecology_priority_mass_ppm": 505799, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 960937, + "first_authorization_event": 66, + "first_recovery_event": 66, + "initial_candidate_count": 256, + "initial_threshold": 65528, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22007, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 929687, + "active_construction_count": 1, + "aulc_ppm": 874948, + "authorized_ids": [ + "cx:9641b24fbdee515b24a003a7dc9b9be0b87f0292d44101b88987f7b96297e9ef" + ], + "chapter_id": "C08-xor3-6", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 65520, + "ecology_minimum_threshold": 634, + "ecology_priority_count": 4, + "ecology_priority_mass_ppm": 507692, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 941406, + "first_authorization_event": 86, + "first_recovery_event": 86, + "initial_candidate_count": 256, + "initial_threshold": 65520, + "persistent": true, + "primed": true, + "priority_candidate_count": 4, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22008, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 925781, + "active_construction_count": 1, + "aulc_ppm": 867276, + "authorized_ids": [ + "cx:026cf589a29f8fa72a1f5ce6b57c7d72cb17ac6f2a3b35d9a813f84e7c82aba7" + ], + "chapter_id": "C09-xor4-7", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 65504, + "ecology_minimum_threshold": 1132, + "ecology_priority_count": 8, + "ecology_priority_mass_ppm": 515388, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 45, + "first_recovery_event": 45, + "initial_candidate_count": 256, + "initial_threshold": 65504, + "persistent": true, + "primed": true, + "priority_candidate_count": 8, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22009, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 924804, + "active_construction_count": 1, + "aulc_ppm": 882739, + "authorized_ids": [ + "cx:a6118412a2161cb245196a224ca639f05a7e97d7f7697304ef3cc1c039de4bd0" + ], + "chapter_id": "C10-and2-5", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 65504, + "ecology_minimum_threshold": 1132, + "ecology_priority_count": 8, + "ecology_priority_mass_ppm": 515388, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 941406, + "first_authorization_event": 134, + "first_recovery_event": 134, + "initial_candidate_count": 256, + "initial_threshold": 65504, + "persistent": true, + "primed": true, + "priority_candidate_count": 8, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22010, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 890323, + "authorized_ids": [ + "cx:99808bb3af376ae1e4e3944d16b64ec286efd32146edfce97ddd60fb0978c7d3" + ], + "chapter_id": "C11-and3-6", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 65504, + "ecology_minimum_threshold": 1623, + "ecology_priority_count": 12, + "ecology_priority_mass_ppm": 523204, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 953125, + "first_authorization_event": 143, + "first_recovery_event": 143, + "initial_candidate_count": 256, + "initial_threshold": 65504, + "persistent": true, + "primed": true, + "priority_candidate_count": 12, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22011, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 880662, + "authorized_ids": [ + "cx:56f9e955c4ff07d6812692e0563ec9b9b9ac6e64bc246819e44098318944789d" + ], + "chapter_id": "C12-and4-7", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 65504, + "ecology_minimum_threshold": 1623, + "ecology_priority_count": 12, + "ecology_priority_mass_ppm": 523204, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 964843, + "first_authorization_event": 107, + "first_recovery_event": 107, + "initial_candidate_count": 256, + "initial_threshold": 65504, + "persistent": true, + "primed": true, + "priority_candidate_count": 12, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22012, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 904296, + "active_construction_count": 1, + "aulc_ppm": 833154, + "authorized_ids": [ + "cx:3c381ca4b7647494bd90e31fa8ca4301d8188691e9b1a82b0bf3fe292256bdbd" + ], + "chapter_id": "C13-or1-4", + "developmental_role": "novel", + "ecology_maximum_threshold": 65504, + "ecology_minimum_threshold": 1623, + "ecology_priority_count": 12, + "ecology_priority_mass_ppm": 523204, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 143, + "first_recovery_event": 143, + "initial_candidate_count": 256, + "initial_threshold": 65504, + "persistent": true, + "primed": true, + "priority_candidate_count": 12, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22013, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 919921, + "active_construction_count": 1, + "aulc_ppm": 843938, + "authorized_ids": [ + "cx:2a6df23137dd1f89a7a145497796aa0023f55106867871974c990f54454e8f10" + ], + "chapter_id": "C14-or2-5", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 65528, + "ecology_minimum_threshold": 1745, + "ecology_priority_count": 13, + "ecology_priority_mass_ppm": 525332, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 945312, + "first_authorization_event": 103, + "first_recovery_event": 103, + "initial_candidate_count": 256, + "initial_threshold": 65528, + "persistent": true, + "primed": true, + "priority_candidate_count": 13, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22014, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 856743, + "authorized_ids": [ + "cx:869ff5f4e15edfa7d543e017916c7df91e793dec5b3cc0e39905f70cde6c2c12" + ], + "chapter_id": "C15-or3-6", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 65472, + "ecology_minimum_threshold": 2225, + "ecology_priority_count": 17, + "ecology_priority_mass_ppm": 532746, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 960937, + "first_authorization_event": 61, + "first_recovery_event": 61, + "initial_candidate_count": 256, + "initial_threshold": 65472, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22015, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 913085, + "active_construction_count": 1, + "aulc_ppm": 827256, + "authorized_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "chapter_id": "C16-xor123", + "developmental_role": "novel", + "ecology_maximum_threshold": 65472, + "ecology_minimum_threshold": 2225, + "ecology_priority_count": 17, + "ecology_priority_mass_ppm": 532746, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 949218, + "first_authorization_event": 64, + "first_recovery_event": 64, + "initial_candidate_count": 256, + "initial_threshold": 65472, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22016, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 841343, + "authorized_ids": [ + "cx:2fb2b079d27f35d42956ef15a8ef417d32879747cd01b2bf2d6e0efa5f944ebd" + ], + "chapter_id": "C17-xor234", + "developmental_role": "family-learning", + "ecology_maximum_threshold": 65456, + "ecology_minimum_threshold": 2343, + "ecology_priority_count": 18, + "ecology_priority_mass_ppm": 534588, + "ecology_uniform_threshold": 32768, + "final_accuracy_ppm": 964843, + "first_authorization_event": 62, + "first_recovery_event": 62, + "initial_candidate_count": 256, + "initial_threshold": 65456, + "persistent": true, + "primed": true, + "priority_candidate_count": 18, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22017, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 907226, + "active_construction_count": 1, + "aulc_ppm": 849002, + "authorized_ids": [ + "cx:285cab98bfb692df8ab1bbf04a69aa81eacff3c9309b635d184b27fd68728ad2" + ], + "chapter_id": "C18-xor345", + "developmental_role": "schema-transfer", + "ecology_maximum_threshold": 65688, + "ecology_minimum_threshold": 2936, + "ecology_priority_count": 23, + "ecology_priority_mass_ppm": 544026, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 945312, + "first_authorization_event": 54, + "first_recovery_event": 54, + "initial_candidate_count": 257, + "initial_threshold": 65688, + "persistent": true, + "primed": true, + "priority_candidate_count": 23, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22018, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 929687, + "active_construction_count": 1, + "aulc_ppm": 860309, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C19-eq1-4", + "developmental_role": "quotient-transfer", + "ecology_maximum_threshold": 65688, + "ecology_minimum_threshold": 2936, + "ecology_priority_count": 23, + "ecology_priority_mass_ppm": 544026, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 960937, + "first_authorization_event": 41, + "first_recovery_event": 41, + "initial_candidate_count": 257, + "initial_threshold": 65688, + "persistent": true, + "primed": true, + "priority_candidate_count": 23, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22019, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 952148, + "active_construction_count": 0, + "aulc_ppm": 934241, + "authorized_ids": [], + "chapter_id": "C20-current", + "developmental_role": "negative-transfer", + "ecology_maximum_threshold": 65688, + "ecology_minimum_threshold": 2936, + "ecology_priority_count": 23, + "ecology_priority_mass_ppm": 544026, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 992187, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 257, + "initial_threshold": 65688, + "persistent": true, + "primed": true, + "priority_candidate_count": 23, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22020, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 906250, + "active_construction_count": 1, + "aulc_ppm": 842549, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C21-xor1-4-long-return", + "developmental_role": "long-range-recall", + "ecology_maximum_threshold": 65688, + "ecology_minimum_threshold": 2936, + "ecology_priority_count": 23, + "ecology_priority_mass_ppm": 544026, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 914062, + "first_authorization_event": 45, + "first_recovery_event": 45, + "initial_candidate_count": 257, + "initial_threshold": 65688, + "persistent": true, + "primed": true, + "priority_candidate_count": 23, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22021, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 854363, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C22-lag1-long-return", + "developmental_role": "long-range-recall", + "ecology_maximum_threshold": 65688, + "ecology_minimum_threshold": 2936, + "ecology_priority_count": 23, + "ecology_priority_mass_ppm": 544026, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 933593, + "first_authorization_event": 46, + "first_recovery_event": 46, + "initial_candidate_count": 257, + "initial_threshold": 65688, + "persistent": true, + "primed": true, + "priority_candidate_count": 23, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22022, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 918945, + "active_construction_count": 1, + "aulc_ppm": 882571, + "authorized_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "chapter_id": "C23-and124", + "developmental_role": "novel", + "ecology_maximum_threshold": 65688, + "ecology_minimum_threshold": 2936, + "ecology_priority_count": 23, + "ecology_priority_mass_ppm": 544026, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 949218, + "first_authorization_event": 286, + "first_recovery_event": 286, + "initial_candidate_count": 257, + "initial_threshold": 65688, + "persistent": true, + "primed": true, + "priority_candidate_count": 23, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22023, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 922851, + "active_construction_count": 1, + "aulc_ppm": 876978, + "authorized_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "chapter_id": "C24-or234", + "developmental_role": "novel", + "ecology_maximum_threshold": 65696, + "ecology_minimum_threshold": 3056, + "ecology_priority_count": 24, + "ecology_priority_mass_ppm": 546030, + "ecology_uniform_threshold": 32896, + "final_accuracy_ppm": 957031, + "first_authorization_event": 215, + "first_recovery_event": 215, + "initial_candidate_count": 257, + "initial_threshold": 65696, + "persistent": true, + "primed": true, + "priority_candidate_count": 24, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22024, + "steps": 1024 + } + ], + "positive_transfer_chapters": 11, + "primed_chapter_count": 23, + "schema_count": 4, + "schemas": [ + { + "normalized_offsets": [ + 0, + 3 + ], + "operator": "and", + "schema_id": "schema:42b3f2cb70d66cea2e5ce694d2f70d7f8ed37ab07a29f4d1407f119e55a96018", + "support": 4 + }, + { + "normalized_offsets": [ + 0, + 3 + ], + "operator": "xor", + "schema_id": "schema:bbc71a61a51d533de6de5bc1b84d4b883591bf078a815ccc7f1e216e0fa4ad84", + "support": 3 + }, + { + "normalized_offsets": [ + 0, + 3 + ], + "operator": "or", + "schema_id": "schema:da6ccb74c4ba308b2772f2a57bd4a5660c16bde37462280c9f5158cb302392df", + "support": 3 + }, + { + "normalized_offsets": [ + 0, + 1, + 2 + ], + "operator": "xor", + "schema_id": "schema:dde37be71ad95f74e14d8e26e357b8b99a0e9e82fa58697881da795fffe6eb26", + "support": 3 + } + ], + "semantic_memory_classes": 17, + "status": "DEVELOPMENT_ONLY", + "tied_transfer_chapters": 1 +} diff --git a/experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.sha256 b/experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.sha256 new file mode 100644 index 0000000..3461cd7 --- /dev/null +++ b/experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.sha256 @@ -0,0 +1 @@ +780ee47dae2de264037a6c289436458d08bcdbd3bc43320b748144d19d15bee5 experiments/prime_m22_developmental_world/DEVELOPMENT_ECOLOGY_V0_2_RESULT.json diff --git a/experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.json b/experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.json new file mode 100644 index 0000000..6f1592a --- /dev/null +++ b/experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.json @@ -0,0 +1,1684 @@ +{ + "by_role": { + "family-learning": { + "chapter_count": 4, + "mean_aulc_gain_ppm": -78050, + "mean_transfer_gain_events": 14, + "negative_transfer": 0, + "positive_transfer": 3, + "ties": 0 + }, + "long-range-recall": { + "chapter_count": 2, + "mean_aulc_gain_ppm": 5746, + "mean_transfer_gain_events": 5, + "negative_transfer": 0, + "positive_transfer": 2, + "ties": 0 + }, + "negative-transfer": { + "chapter_count": 1, + "mean_aulc_gain_ppm": 0, + "mean_transfer_gain_events": null, + "negative_transfer": 0, + "positive_transfer": 0, + "ties": 0 + }, + "novel": { + "chapter_count": 8, + "mean_aulc_gain_ppm": -46849, + "mean_transfer_gain_events": 12, + "negative_transfer": 0, + "positive_transfer": 3, + "ties": 1 + }, + "quotient-transfer": { + "chapter_count": 1, + "mean_aulc_gain_ppm": 7839, + "mean_transfer_gain_events": 6, + "negative_transfer": 0, + "positive_transfer": 1, + "ties": 0 + }, + "repeat": { + "chapter_count": 3, + "mean_aulc_gain_ppm": 3786, + "mean_transfer_gain_events": 6, + "negative_transfer": 0, + "positive_transfer": 3, + "ties": 0 + }, + "schema-transfer": { + "chapter_count": 6, + "mean_aulc_gain_ppm": -48271, + "mean_transfer_gain_events": 14, + "negative_transfer": 0, + "positive_transfer": 5, + "ties": 0 + } + }, + "chapter_count": 25, + "cold_recovery_count": 25, + "cold_rows": [ + { + "accepted_priority_count": 0, + "accuracy_ppm": 946289, + "active_construction_count": 0, + "aulc_ppm": 942241, + "authorized_ids": [], + "chapter_id": "C00-current", + "developmental_role": "novel", + "final_accuracy_ppm": 937500, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22000, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 836586, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C01-lag1", + "developmental_role": "novel", + "final_accuracy_ppm": 949218, + "first_authorization_event": 60, + "first_recovery_event": 60, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22001, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 908203, + "active_construction_count": 1, + "aulc_ppm": 828988, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C02-xor1-4", + "developmental_role": "novel", + "final_accuracy_ppm": 925781, + "first_authorization_event": 51, + "first_recovery_event": 51, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22002, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 869900, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C03-and1-4", + "developmental_role": "novel", + "final_accuracy_ppm": 945312, + "first_authorization_event": 179, + "first_recovery_event": 179, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22003, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 927734, + "active_construction_count": 1, + "aulc_ppm": 852150, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C04-lag1-repeat", + "developmental_role": "repeat", + "final_accuracy_ppm": 972656, + "first_authorization_event": 48, + "first_recovery_event": 48, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22004, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 915039, + "active_construction_count": 1, + "aulc_ppm": 847802, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C05-xor1-4-repeat", + "developmental_role": "repeat", + "final_accuracy_ppm": 933593, + "first_authorization_event": 63, + "first_recovery_event": 63, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22005, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 880975, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C06-and1-4-repeat", + "developmental_role": "repeat", + "final_accuracy_ppm": 933593, + "first_authorization_event": 136, + "first_recovery_event": 136, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22006, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 853327, + "authorized_ids": [ + "cx:69bd2ef3e74f9643af24859bea628bfd2c4e00a5a10c598922442a8ef785885c" + ], + "chapter_id": "C07-xor2-5", + "developmental_role": "family-learning", + "final_accuracy_ppm": 960937, + "first_authorization_event": 59, + "first_recovery_event": 59, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22007, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 931640, + "active_construction_count": 1, + "aulc_ppm": 879675, + "authorized_ids": [ + "cx:9641b24fbdee515b24a003a7dc9b9be0b87f0292d44101b88987f7b96297e9ef" + ], + "chapter_id": "C08-xor3-6", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 941406, + "first_authorization_event": 77, + "first_recovery_event": 77, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22008, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 921875, + "active_construction_count": 1, + "aulc_ppm": 855591, + "authorized_ids": [ + "cx:026cf589a29f8fa72a1f5ce6b57c7d72cb17ac6f2a3b35d9a813f84e7c82aba7" + ], + "chapter_id": "C09-xor4-7", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 945312, + "first_authorization_event": 55, + "first_recovery_event": 55, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22009, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 880763, + "authorized_ids": [ + "cx:a6118412a2161cb245196a224ca639f05a7e97d7f7697304ef3cc1c039de4bd0" + ], + "chapter_id": "C10-and2-5", + "developmental_role": "family-learning", + "final_accuracy_ppm": 941406, + "first_authorization_event": 131, + "first_recovery_event": 131, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22010, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 876916, + "authorized_ids": [ + "cx:99808bb3af376ae1e4e3944d16b64ec286efd32146edfce97ddd60fb0978c7d3" + ], + "chapter_id": "C11-and3-6", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 953125, + "first_authorization_event": 185, + "first_recovery_event": 185, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22011, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 920898, + "active_construction_count": 1, + "aulc_ppm": 875022, + "authorized_ids": [ + "cx:56f9e955c4ff07d6812692e0563ec9b9b9ac6e64bc246819e44098318944789d" + ], + "chapter_id": "C12-and4-7", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 964843, + "first_authorization_event": 130, + "first_recovery_event": 130, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22012, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 904296, + "active_construction_count": 1, + "aulc_ppm": 832848, + "authorized_ids": [ + "cx:3c381ca4b7647494bd90e31fa8ca4301d8188691e9b1a82b0bf3fe292256bdbd" + ], + "chapter_id": "C13-or1-4", + "developmental_role": "novel", + "final_accuracy_ppm": 945312, + "first_authorization_event": 132, + "first_recovery_event": 132, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22013, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 924804, + "active_construction_count": 1, + "aulc_ppm": 854357, + "authorized_ids": [ + "cx:2a6df23137dd1f89a7a145497796aa0023f55106867871974c990f54454e8f10" + ], + "chapter_id": "C14-or2-5", + "developmental_role": "family-learning", + "final_accuracy_ppm": 945312, + "first_authorization_event": 96, + "first_recovery_event": 96, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22014, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 922851, + "active_construction_count": 1, + "aulc_ppm": 843339, + "authorized_ids": [ + "cx:869ff5f4e15edfa7d543e017916c7df91e793dec5b3cc0e39905f70cde6c2c12" + ], + "chapter_id": "C15-or3-6", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 960937, + "first_authorization_event": 80, + "first_recovery_event": 80, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22015, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 916992, + "active_construction_count": 1, + "aulc_ppm": 837896, + "authorized_ids": [ + "cx:9b327d662bceb92ac239cc60594a8aeaaef9df61d3c5e8b6dbac1831083f2691" + ], + "chapter_id": "C16-xor123", + "developmental_role": "novel", + "final_accuracy_ppm": 949218, + "first_authorization_event": 61, + "first_recovery_event": 61, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22016, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 931640, + "active_construction_count": 1, + "aulc_ppm": 849242, + "authorized_ids": [ + "cx:2fb2b079d27f35d42956ef15a8ef417d32879747cd01b2bf2d6e0efa5f944ebd" + ], + "chapter_id": "C17-xor234", + "developmental_role": "family-learning", + "final_accuracy_ppm": 964843, + "first_authorization_event": 60, + "first_recovery_event": 60, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22017, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 908203, + "active_construction_count": 1, + "aulc_ppm": 851831, + "authorized_ids": [ + "cx:285cab98bfb692df8ab1bbf04a69aa81eacff3c9309b635d184b27fd68728ad2" + ], + "chapter_id": "C18-xor345", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 945312, + "first_authorization_event": 58, + "first_recovery_event": 58, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22018, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 922851, + "active_construction_count": 1, + "aulc_ppm": 840325, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C19-eq1-4", + "developmental_role": "quotient-transfer", + "final_accuracy_ppm": 960937, + "first_authorization_event": 49, + "first_recovery_event": 49, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22019, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 952148, + "active_construction_count": 0, + "aulc_ppm": 934241, + "authorized_ids": [], + "chapter_id": "C20-current", + "developmental_role": "negative-transfer", + "final_accuracy_ppm": 992187, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22020, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 902343, + "active_construction_count": 1, + "aulc_ppm": 831310, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C21-xor1-4-long-return", + "developmental_role": "long-range-recall", + "final_accuracy_ppm": 914062, + "first_authorization_event": 53, + "first_recovery_event": 53, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22021, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 927734, + "active_construction_count": 1, + "aulc_ppm": 851462, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C22-lag1-long-return", + "developmental_role": "long-range-recall", + "final_accuracy_ppm": 933593, + "first_authorization_event": 50, + "first_recovery_event": 50, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22022, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 917968, + "active_construction_count": 1, + "aulc_ppm": 881333, + "authorized_ids": [ + "cx:937df7db19180d39cec8855f20591ef7add09392c2342800baebd2a28ba69962" + ], + "chapter_id": "C23-and124", + "developmental_role": "novel", + "final_accuracy_ppm": 949218, + "first_authorization_event": 284, + "first_recovery_event": 284, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22023, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 921875, + "active_construction_count": 1, + "aulc_ppm": 875124, + "authorized_ids": [ + "cx:645d899a9c0a0294d1062c6370cfa0ef3d09519c5773378cbe0c771e987f1255" + ], + "chapter_id": "C24-or234", + "developmental_role": "novel", + "final_accuracy_ppm": 957031, + "first_authorization_event": 195, + "first_recovery_event": 195, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": false, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22024, + "steps": 1024 + } + ], + "comparable_recovery_count": 18, + "comparisons": [ + { + "aulc_gain_ppm": 0, + "chapter_id": "C00-current", + "cold_aulc_ppm": 942241, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": null, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 942241, + "persistent_candidates": 256, + "persistent_primed": false, + "persistent_priority_candidates": 0, + "persistent_recovered": true, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": 0, + "chapter_id": "C01-lag1", + "cold_aulc_ppm": 836586, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 60, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 836586, + "persistent_candidates": 256, + "persistent_primed": false, + "persistent_priority_candidates": 0, + "persistent_recovered": true, + "persistent_recovery_event": 60, + "transfer_gain_events": 0 + }, + { + "aulc_gain_ppm": 14071, + "chapter_id": "C02-xor1-4", + "cold_aulc_ppm": 828988, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 51, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 843059, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 1, + "persistent_recovered": true, + "persistent_recovery_event": 45, + "transfer_gain_events": 6 + }, + { + "aulc_gain_ppm": 3301, + "chapter_id": "C03-and1-4", + "cold_aulc_ppm": 869900, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 179, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 873201, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 2, + "persistent_recovered": true, + "persistent_recovery_event": 158, + "transfer_gain_events": 21 + }, + { + "aulc_gain_ppm": 2922, + "chapter_id": "C04-lag1-repeat", + "cold_aulc_ppm": 852150, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 48, + "developmental_role": "repeat", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 855072, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 45, + "transfer_gain_events": 3 + }, + { + "aulc_gain_ppm": 2883, + "chapter_id": "C05-xor1-4-repeat", + "cold_aulc_ppm": 847802, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 63, + "developmental_role": "repeat", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 850685, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 58, + "transfer_gain_events": 5 + }, + { + "aulc_gain_ppm": 5553, + "chapter_id": "C06-and1-4-repeat", + "cold_aulc_ppm": 880975, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 136, + "developmental_role": "repeat", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 886528, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 125, + "transfer_gain_events": 11 + }, + { + "aulc_gain_ppm": 8004, + "chapter_id": "C07-xor2-5", + "cold_aulc_ppm": 853327, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 59, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 861331, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 3, + "persistent_recovered": true, + "persistent_recovery_event": 54, + "transfer_gain_events": 5 + }, + { + "aulc_gain_ppm": 12449, + "chapter_id": "C08-xor3-6", + "cold_aulc_ppm": 879675, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 77, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 892124, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 4, + "persistent_recovered": true, + "persistent_recovery_event": 70, + "transfer_gain_events": 7 + }, + { + "aulc_gain_ppm": 5484, + "chapter_id": "C09-xor4-7", + "cold_aulc_ppm": 855591, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 55, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 861075, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 8, + "persistent_recovered": true, + "persistent_recovery_event": 49, + "transfer_gain_events": 6 + }, + { + "aulc_gain_ppm": 9767, + "chapter_id": "C10-and2-5", + "cold_aulc_ppm": 880763, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 131, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 890530, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 8, + "persistent_recovered": true, + "persistent_recovery_event": 120, + "transfer_gain_events": 11 + }, + { + "aulc_gain_ppm": 4652, + "chapter_id": "C11-and3-6", + "cold_aulc_ppm": 876916, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 185, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 881568, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 12, + "persistent_recovered": true, + "persistent_recovery_event": 164, + "transfer_gain_events": 21 + }, + { + "aulc_gain_ppm": 5750, + "chapter_id": "C12-and4-7", + "cold_aulc_ppm": 875022, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 130, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 880772, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 12, + "persistent_recovered": true, + "persistent_recovery_event": 111, + "transfer_gain_events": 19 + }, + { + "aulc_gain_ppm": 7540, + "chapter_id": "C13-or1-4", + "cold_aulc_ppm": 832848, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 132, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 840388, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 12, + "persistent_recovered": true, + "persistent_recovery_event": 109, + "transfer_gain_events": 23 + }, + { + "aulc_gain_ppm": 6062, + "chapter_id": "C14-or2-5", + "cold_aulc_ppm": 854357, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 96, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 860419, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 13, + "persistent_recovered": true, + "persistent_recovery_event": 68, + "transfer_gain_events": 28 + }, + { + "aulc_gain_ppm": 16136, + "chapter_id": "C15-or3-6", + "cold_aulc_ppm": 843339, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 80, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 859475, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": 63, + "transfer_gain_events": 17 + }, + { + "aulc_gain_ppm": -341163, + "chapter_id": "C16-xor123", + "cold_aulc_ppm": 837896, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 61, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 496733, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": false, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": -336032, + "chapter_id": "C17-xor234", + "cold_aulc_ppm": 849242, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 60, + "developmental_role": "family-learning", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 513210, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": false, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": -334095, + "chapter_id": "C18-xor345", + "cold_aulc_ppm": 851831, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 58, + "developmental_role": "schema-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 517736, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": false, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": 7839, + "chapter_id": "C19-eq1-4", + "cold_aulc_ppm": 840325, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 49, + "developmental_role": "quotient-transfer", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 848164, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": 43, + "transfer_gain_events": 6 + }, + { + "aulc_gain_ppm": 0, + "chapter_id": "C20-current", + "cold_aulc_ppm": 934241, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": null, + "developmental_role": "negative-transfer", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 934241, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": 5572, + "chapter_id": "C21-xor1-4-long-return", + "cold_aulc_ppm": 831310, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 53, + "developmental_role": "long-range-recall", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 836882, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": 49, + "transfer_gain_events": 4 + }, + { + "aulc_gain_ppm": 5921, + "chapter_id": "C22-lag1-long-return", + "cold_aulc_ppm": 851462, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 50, + "developmental_role": "long-range-recall", + "persistent_accepted_priority": 1, + "persistent_aulc_ppm": 857383, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": true, + "persistent_recovery_event": 43, + "transfer_gain_events": 7 + }, + { + "aulc_gain_ppm": -29759, + "chapter_id": "C23-and124", + "cold_aulc_ppm": 881333, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 284, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 851574, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": false, + "persistent_recovery_event": null, + "transfer_gain_events": null + }, + { + "aulc_gain_ppm": -28782, + "chapter_id": "C24-or234", + "cold_aulc_ppm": 875124, + "cold_candidates": 256, + "cold_recovered": true, + "cold_recovery_event": 195, + "developmental_role": "novel", + "persistent_accepted_priority": 0, + "persistent_aulc_ppm": 846342, + "persistent_candidates": 64, + "persistent_primed": true, + "persistent_priority_candidates": 17, + "persistent_recovered": false, + "persistent_recovery_event": null, + "transfer_gain_events": null + } + ], + "episode_chain_valid": true, + "episodic_memory_count": 25, + "experiment": "prime-m22-developmental-laboratory", + "mean_aulc_gain_ppm": -37837, + "mean_transfer_gain_events": 11, + "meta_sources": { + "verified-memory": { + "accepted": 4, + "attempts": 4, + "cumulative_gain_ppm": 400000, + "priority": 440, + "rejected": 0 + }, + "verified-schema": { + "accepted": 6, + "attempts": 6, + "cumulative_gain_ppm": 600000, + "priority": 660, + "rejected": 0 + } + }, + "negative_transfer_chapters": 0, + "persistent_recovery_count": 20, + "persistent_rows": [ + { + "accepted_priority_count": 0, + "accuracy_ppm": 946289, + "active_construction_count": 0, + "aulc_ppm": 942241, + "authorized_ids": [], + "chapter_id": "C00-current", + "developmental_role": "novel", + "final_accuracy_ppm": 937500, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": true, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22000, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 836586, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C01-lag1", + "developmental_role": "novel", + "final_accuracy_ppm": 949218, + "first_authorization_event": 60, + "first_recovery_event": 60, + "initial_candidate_count": 256, + "initial_threshold": 32768, + "persistent": true, + "primed": false, + "priority_candidate_count": 0, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22001, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 913085, + "active_construction_count": 1, + "aulc_ppm": 843059, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C02-xor1-4", + "developmental_role": "novel", + "final_accuracy_ppm": 925781, + "first_authorization_event": 45, + "first_recovery_event": 45, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 1, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22002, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 925781, + "active_construction_count": 1, + "aulc_ppm": 873201, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C03-and1-4", + "developmental_role": "novel", + "final_accuracy_ppm": 945312, + "first_authorization_event": 158, + "first_recovery_event": 158, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 2, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22003, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 855072, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C04-lag1-repeat", + "developmental_role": "repeat", + "final_accuracy_ppm": 972656, + "first_authorization_event": 45, + "first_recovery_event": 45, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22004, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 916015, + "active_construction_count": 1, + "aulc_ppm": 850685, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C05-xor1-4-repeat", + "developmental_role": "repeat", + "final_accuracy_ppm": 933593, + "first_authorization_event": 58, + "first_recovery_event": 58, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22005, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 931640, + "active_construction_count": 1, + "aulc_ppm": 886528, + "authorized_ids": [ + "cx:42abd5d1a3e8e86595bc4095b539f4c741eb974c967956e2d6660915fc75e711" + ], + "chapter_id": "C06-and1-4-repeat", + "developmental_role": "repeat", + "final_accuracy_ppm": 933593, + "first_authorization_event": 125, + "first_recovery_event": 125, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22006, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 861331, + "authorized_ids": [ + "cx:69bd2ef3e74f9643af24859bea628bfd2c4e00a5a10c598922442a8ef785885c" + ], + "chapter_id": "C07-xor2-5", + "developmental_role": "family-learning", + "final_accuracy_ppm": 960937, + "first_authorization_event": 54, + "first_recovery_event": 54, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 3, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22007, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 936523, + "active_construction_count": 1, + "aulc_ppm": 892124, + "authorized_ids": [ + "cx:9641b24fbdee515b24a003a7dc9b9be0b87f0292d44101b88987f7b96297e9ef" + ], + "chapter_id": "C08-xor3-6", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 941406, + "first_authorization_event": 70, + "first_recovery_event": 70, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 4, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22008, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 861075, + "authorized_ids": [ + "cx:026cf589a29f8fa72a1f5ce6b57c7d72cb17ac6f2a3b35d9a813f84e7c82aba7" + ], + "chapter_id": "C09-xor4-7", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 945312, + "first_authorization_event": 49, + "first_recovery_event": 49, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 8, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22009, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 928710, + "active_construction_count": 1, + "aulc_ppm": 890530, + "authorized_ids": [ + "cx:a6118412a2161cb245196a224ca639f05a7e97d7f7697304ef3cc1c039de4bd0" + ], + "chapter_id": "C10-and2-5", + "developmental_role": "family-learning", + "final_accuracy_ppm": 941406, + "first_authorization_event": 120, + "first_recovery_event": 120, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 8, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22010, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 881568, + "authorized_ids": [ + "cx:99808bb3af376ae1e4e3944d16b64ec286efd32146edfce97ddd60fb0978c7d3" + ], + "chapter_id": "C11-and3-6", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 953125, + "first_authorization_event": 164, + "first_recovery_event": 164, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 12, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22011, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 923828, + "active_construction_count": 1, + "aulc_ppm": 880772, + "authorized_ids": [ + "cx:56f9e955c4ff07d6812692e0563ec9b9b9ac6e64bc246819e44098318944789d" + ], + "chapter_id": "C12-and4-7", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 964843, + "first_authorization_event": 111, + "first_recovery_event": 111, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 12, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22012, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 908203, + "active_construction_count": 1, + "aulc_ppm": 840388, + "authorized_ids": [ + "cx:3c381ca4b7647494bd90e31fa8ca4301d8188691e9b1a82b0bf3fe292256bdbd" + ], + "chapter_id": "C13-or1-4", + "developmental_role": "novel", + "final_accuracy_ppm": 945312, + "first_authorization_event": 109, + "first_recovery_event": 109, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 12, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22013, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 927734, + "active_construction_count": 1, + "aulc_ppm": 860419, + "authorized_ids": [ + "cx:2a6df23137dd1f89a7a145497796aa0023f55106867871974c990f54454e8f10" + ], + "chapter_id": "C14-or2-5", + "developmental_role": "family-learning", + "final_accuracy_ppm": 945312, + "first_authorization_event": 68, + "first_recovery_event": 68, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 13, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22014, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 929687, + "active_construction_count": 1, + "aulc_ppm": 859475, + "authorized_ids": [ + "cx:869ff5f4e15edfa7d543e017916c7df91e793dec5b3cc0e39905f70cde6c2c12" + ], + "chapter_id": "C15-or3-6", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 960937, + "first_authorization_event": 63, + "first_recovery_event": 63, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22015, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 509765, + "active_construction_count": 0, + "aulc_ppm": 496733, + "authorized_ids": [], + "chapter_id": "C16-xor123", + "developmental_role": "novel", + "final_accuracy_ppm": 527343, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": false, + "seed": 22016, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 501953, + "active_construction_count": 0, + "aulc_ppm": 513210, + "authorized_ids": [], + "chapter_id": "C17-xor234", + "developmental_role": "family-learning", + "final_accuracy_ppm": 433593, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": false, + "seed": 22017, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 506835, + "active_construction_count": 0, + "aulc_ppm": 517736, + "authorized_ids": [], + "chapter_id": "C18-xor345", + "developmental_role": "schema-transfer", + "final_accuracy_ppm": 515625, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": false, + "seed": 22018, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 925781, + "active_construction_count": 1, + "aulc_ppm": 848164, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C19-eq1-4", + "developmental_role": "quotient-transfer", + "final_accuracy_ppm": 960937, + "first_authorization_event": 43, + "first_recovery_event": 43, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22019, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 952148, + "active_construction_count": 0, + "aulc_ppm": 934241, + "authorized_ids": [], + "chapter_id": "C20-current", + "developmental_role": "negative-transfer", + "final_accuracy_ppm": 992187, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22020, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 904296, + "active_construction_count": 1, + "aulc_ppm": 836882, + "authorized_ids": [ + "cx:7b2a3d07dfd59cdaa7310a05eed971c92977c1ab6848b8fde5f03b9470e7b9cd" + ], + "chapter_id": "C21-xor1-4-long-return", + "developmental_role": "long-range-recall", + "final_accuracy_ppm": 914062, + "first_authorization_event": 49, + "first_recovery_event": 49, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22021, + "steps": 1024 + }, + { + "accepted_priority_count": 1, + "accuracy_ppm": 929687, + "active_construction_count": 1, + "aulc_ppm": 857383, + "authorized_ids": [ + "cx:bb3c2e7b22e56f7cd3754ded8cbe9205e3c4f803b3289533adda217313e4f6c3" + ], + "chapter_id": "C22-lag1-long-return", + "developmental_role": "long-range-recall", + "final_accuracy_ppm": 933593, + "first_authorization_event": 43, + "first_recovery_event": 43, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": true, + "seed": 22022, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 859375, + "active_construction_count": 0, + "aulc_ppm": 851574, + "authorized_ids": [], + "chapter_id": "C23-and124", + "developmental_role": "novel", + "final_accuracy_ppm": 863281, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": false, + "seed": 22023, + "steps": 1024 + }, + { + "accepted_priority_count": 0, + "accuracy_ppm": 862304, + "active_construction_count": 0, + "aulc_ppm": 846342, + "authorized_ids": [], + "chapter_id": "C24-or234", + "developmental_role": "novel", + "final_accuracy_ppm": 863281, + "first_authorization_event": null, + "first_recovery_event": null, + "initial_candidate_count": 64, + "initial_threshold": 8192, + "persistent": true, + "primed": true, + "priority_candidate_count": 17, + "receipt_chain_valid": true, + "recovered": false, + "seed": 22024, + "steps": 1024 + } + ], + "positive_transfer_chapters": 17, + "primed_chapter_count": 23, + "schema_count": 3, + "schemas": [ + { + "normalized_offsets": [ + 0, + 3 + ], + "operator": "and", + "schema_id": "schema:42b3f2cb70d66cea2e5ce694d2f70d7f8ed37ab07a29f4d1407f119e55a96018", + "support": 4 + }, + { + "normalized_offsets": [ + 0, + 3 + ], + "operator": "xor", + "schema_id": "schema:bbc71a61a51d533de6de5bc1b84d4b883591bf078a815ccc7f1e216e0fa4ad84", + "support": 3 + }, + { + "normalized_offsets": [ + 0, + 3 + ], + "operator": "or", + "schema_id": "schema:da6ccb74c4ba308b2772f2a57bd4a5660c16bde37462280c9f5158cb302392df", + "support": 3 + } + ], + "semantic_memory_classes": 12, + "status": "DEVELOPMENT_ONLY", + "tied_transfer_chapters": 1 +} diff --git a/experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.sha256 b/experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.sha256 new file mode 100644 index 0000000..6dd2997 --- /dev/null +++ b/experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.sha256 @@ -0,0 +1 @@ +204b45227508c60e44173a456572e8114a99fb5077dae99a83c69d444e71daf7 experiments/prime_m22_developmental_world/DEVELOPMENT_V0_1_RESULT.json diff --git a/experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.md b/experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.md new file mode 100644 index 0000000..ead2e54 --- /dev/null +++ b/experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.md @@ -0,0 +1,54 @@ +# PRIME M22 Cognitive Search Ecology — Development Result + +Status: + + DEVELOPMENT ONLY + +Cold recovery: + + 25 / 25 + +Persistent recovery: + + 25 / 25 + +Mean recovery-event transfer gain: + + +3 events + +Positive / tied / negative comparable chapters: + + 11 / 1 / 11 + +Mean AULC gain: + + +3947 ppm + +Persistent cognition: + + semantic memory classes: 17 + episodic memories: 25 + verified schema proposals: 4 + episodic chain valid: true + +Interpretation: + +The weighted hypothesis ecology repaired the catastrophic negative-transfer +failure of M22 v0.1. + +Persistent prior knowledge no longer deletes the universal hypothesis field. + +Novel higher-order constructions again recover successfully. + +However transfer efficiency remains heterogeneous. + +The current prior-allocation mechanism should therefore be treated as an +architectural proof that prior knowledge may bias verifier resources without +destroying novelty, not as a final meta-learning algorithm. + +The 25-chapter developmental curriculum has now been inspected repeatedly and +must not be treated as held-out evidence. + +Next architectural target: + + active causal developmental intelligence. diff --git a/experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.sha256 b/experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.sha256 new file mode 100644 index 0000000..4077664 --- /dev/null +++ b/experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.sha256 @@ -0,0 +1 @@ +351bc54306d2206b1a9842d2f1f29cda9f3ce250f0fe60fa3a8bcb3a6c6af689 experiments/prime_m22_developmental_world/ECOLOGY_V0_2_RESULT.md diff --git a/experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.md b/experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.md new file mode 100644 index 0000000..de7dcdc --- /dev/null +++ b/experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.md @@ -0,0 +1,100 @@ +# PRIME M22 Developmental Laboratory v0.1 Diagnosis + +Status: + + DEVELOPMENT FAILURE PRESERVED + +The first M22 developmental experiment compared: + + COLD PRIME + +against: + + PERSISTENT PRIME + +across 25 sequential developmental chapters. + +Results: + + cold recovery: + 25 / 25 + + persistent recovery: + 20 / 25 + + comparable recoveries: + 18 + + mean transfer gain: + +11 events + + positive / tied / negative: + 17 / 1 / 0 + + mean AULC gain: + -37837 ppm + +Persistent cognition accumulated: + + 12 semantic-memory classes + 25 episodic memories + valid episodic hash chain + 3 schema proposals + +Schemas: + + AND offsets (0,3), support 4 + XOR offsets (0,3), support 3 + OR offsets (0,3), support 3 + +The failure was highly structured. + +Persistent PRIME failed to recover: + + XOR-1-2-3 + XOR-2-3-4 + XOR-3-4-5 + AND-1-2-4 + OR-2-3-4 + +These are higher-order constructions. + +The persistent engine reduced the candidate field from the cold universal +256-candidate field to 64 candidates whenever prior memory existed. + +As persistent memory grew, prior proposals occupied increasing fractions of +this 64-candidate field. + +The result was representational search collapse: + + prior knowledge improved discovery latency for hypotheses that remained + available; + +but: + + prior knowledge removed novel higher-order hypotheses from consideration. + +This is negative transfer caused by overconfident proposal-space compression. + +The result falsifies the naive rule: + + accumulated knowledge + -> + globally shrink future search space. + +It motivates a stronger architecture: + + accumulated knowledge + -> + redistribute search/evidence budget + +while maintaining universal hypothesis coverage. + +The next M22 architecture therefore replaces hard candidate truncation with a +weighted hypothesis ecology. + +Memory may increase evidence budget for likely hypotheses. + +It may not delete the universal safety field. + +No M22 held-out evaluation has been performed. diff --git a/experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.sha256 b/experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.sha256 new file mode 100644 index 0000000..d4b7867 --- /dev/null +++ b/experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.sha256 @@ -0,0 +1 @@ +613f7fad11efb179a6e7f68daefbd31a2b100605766e137c0e3031bb3211f27e experiments/prime_m22_developmental_world/V0_1_DIAGNOSIS.md diff --git a/experiments/prime_m22_developmental_world/__init__.py b/experiments/prime_m22_developmental_world/__init__.py new file mode 100644 index 0000000..f08d92c --- /dev/null +++ b/experiments/prime_m22_developmental_world/__init__.py @@ -0,0 +1 @@ +"""PRIME M22 developmental laboratory.""" diff --git a/experiments/prime_m22_developmental_world/candidate_source.py b/experiments/prime_m22_developmental_world/candidate_source.py new file mode 100644 index 0000000..2fcc66f --- /dev/null +++ b/experiments/prime_m22_developmental_world/candidate_source.py @@ -0,0 +1,234 @@ +"""Persistent-memory and schema-derived candidate generation.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition import ( + MegaPrimeCognition, +) +from core.construction.grammar import ( + binary, + description_length, + lag, +) +from core.construction.scaffold import ( + fold_commutative, +) +from core.construction.types import ( + ConstructionSpec, + FeatureOp, +) + + +@dataclass(frozen=True) +class DevelopmentalCandidate: + spec: ConstructionSpec + source: str + score: int + memory_id: str | None = None + schema_id: str | None = None + + +def instantiate_schema( + operator: str, + offsets: tuple[int, ...], + *, + max_lag: int = 8, +) -> tuple[ + ConstructionSpec, + ..., +]: + op = FeatureOp( + operator + ) + + if not offsets: + return () + + largest = max( + offsets + ) + + result = {} + + for base in range( + 1, + max_lag - largest + 1, + ): + atoms = tuple( + lag( + base + offset + ) + for offset in offsets + ) + + if len(atoms) == 2: + expr = binary( + op, + atoms[0], + atoms[1], + ) + + elif ( + len(atoms) >= 3 + and op + in ( + FeatureOp.XOR, + FeatureOp.AND, + FeatureOp.OR, + ) + ): + expr = ( + fold_commutative( + op, + atoms, + ) + ) + + else: + continue + + spec = ( + ConstructionSpec( + expression=expr, + proposal_source=( + "m22-schema-instantiation" + ), + ) + ) + + result[ + spec.construction_id + ] = spec + + return tuple( + sorted( + result.values(), + key=lambda spec: ( + description_length( + spec.expression + ), + spec.construction_id, + ), + ) + ) + + +class DevelopmentalCandidateSource: + def __init__( + self, + cognition: MegaPrimeCognition, + ) -> None: + self.cognition = ( + cognition + ) + + def propose( + self, + *, + context_tokens: tuple[ + str, + ..., + ], + max_candidates: int = 64, + ) -> tuple[ + DevelopmentalCandidate, + ..., + ]: + candidates: dict[ + str, + DevelopmentalCandidate, + ] = {} + + # Exact / quotient memory recall. + recalled = ( + self.cognition.transfer_engine.recall( + context_tokens=( + context_tokens + ), + max_candidates=( + max_candidates + ), + ) + ) + + for proposal in recalled: + candidates[ + proposal.spec.construction_id + ] = DevelopmentalCandidate( + spec=proposal.spec, + source="verified-memory", + score=proposal.score, + memory_id=( + proposal.memory_id + ), + ) + + # Generalized schema instantiation. + for schema in ( + self.cognition.mine_schemas() + ): + instantiated = ( + instantiate_schema( + schema.operator, + schema.normalized_offsets, + ) + ) + + for spec in instantiated: + field_score = ( + self.cognition.proposal_field.score( + spec, + context_tokens, + ) + ) + + score = ( + 50 + * schema.support + + field_score + - description_length( + spec.expression + ) + ) + + current = ( + candidates.get( + spec.construction_id + ) + ) + + proposed = ( + DevelopmentalCandidate( + spec=spec, + source="verified-schema", + score=score, + schema_id=( + schema.schema_id + ), + ) + ) + + if ( + current is None + or proposed.score + > current.score + ): + candidates[ + spec.construction_id + ] = proposed + + ordered = sorted( + candidates.values(), + key=lambda row: ( + -row.score, + row.spec.construction_id, + ), + ) + + return tuple( + ordered[ + :max_candidates + ] + ) diff --git a/experiments/prime_m22_developmental_world/ecological_engine.py b/experiments/prime_m22_developmental_world/ecological_engine.py new file mode 100644 index 0000000..fcae104 --- /dev/null +++ b/experiments/prime_m22_developmental_world/ecological_engine.py @@ -0,0 +1,262 @@ +"""Full-coverage memory-weighted construction search for PRIME M22.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition.hypothesis_ecology import ( + HypothesisAllocation, + WeightedEvidenceEpoch, + allocate_hypothesis_mass, +) +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.types import ( + ConstructionSpec, +) + + +@dataclass(frozen=True) +class EcologySnapshot: + candidate_count: int + priority_candidate_count: int + total_mass: int + priority_mass: int + priority_mass_ppm: int + minimum_threshold: int + maximum_threshold: int + uniform_equivalent_threshold: int + + +class EcologicalConstructionEngine( + CompositionalAdaptiveConstructionEngine +): + """Universal coverage + past-informed verifier weighting.""" + + def __init__( + self, + *, + priority_specs: tuple[ + ConstructionSpec, + ..., + ] = (), + max_lag: int = 8, + universal_candidate_limit: int = 256, + ) -> None: + self._priority_specs_m22 = ( + priority_specs + ) + + self._priority_ids_m22 = tuple( + spec.construction_id + for spec + in priority_specs + ) + + self._allocation: ( + HypothesisAllocation + | None + ) = None + + super().__init__( + max_lag=max_lag, + max_candidates=( + universal_candidate_limit + ), + enable_scaffolds=True, + ) + + @property + def primed(self) -> bool: + return bool( + self._priority_specs_m22 + ) + + def _candidate_field( + self, + ) -> tuple[ + ConstructionSpec, + ..., + ]: + # Frozen M20 universal field. + universal = tuple( + super()._candidate_field() + ) + + active = set( + self.registry.active_ids() + ) + + combined = {} + + # Past-informed candidates are inserted first, but universal + # candidates are NEVER truncated away. + for spec in ( + self._priority_specs_m22 + ): + if ( + spec.construction_id + not in active + ): + combined[ + spec.construction_id + ] = spec + + for spec in universal: + if ( + spec.construction_id + not in active + ): + combined.setdefault( + spec.construction_id, + spec, + ) + + return tuple( + combined.values() + ) + + def _build_epoch( + self, + ) -> WeightedEvidenceEpoch: + candidates = ( + self._candidate_field() + ) + + for spec in candidates: + self.registry.propose( + spec + ) + + self._candidate_specs = ( + candidates + ) + + priority_ids = tuple( + construction_id + for construction_id + in self._priority_ids_m22 + if any( + spec.construction_id + == construction_id + for spec in candidates + ) + ) + + allocation = ( + allocate_hypothesis_mass( + candidates, + priority_ids=( + priority_ids + ), + ) + ) + + self._allocation = ( + allocation + ) + + return WeightedEvidenceEpoch( + candidates, + epoch_index=( + self._epoch_index + ), + allocation=allocation, + ) + + @property + def priority_construction_ids( + self, + ) -> tuple[str, ...]: + if self._allocation is None: + return () + + return ( + self._allocation.priority_ids + ) + + @property + def candidate_construction_ids( + self, + ) -> tuple[str, ...]: + return tuple( + spec.construction_id + for spec in self._candidate_specs + ) + + def ecology_snapshot( + self, + ) -> EcologySnapshot: + if self._allocation is None: + raise RuntimeError( + "no ecology allocation" + ) + + allocation = ( + self._allocation + ) + + thresholds = tuple( + self._epoch.threshold_for( + construction_id + ) + for construction_id + in allocation.mass_by_id + ) + + priority_mass = sum( + allocation.mass_by_id[ + construction_id + ] + for construction_id + in allocation.priority_ids + ) + + base_denominator = ( + 64 + * ( + 1 + << ( + self._epoch_index + + 1 + ) + ) + ) + + return EcologySnapshot( + candidate_count=len( + allocation.mass_by_id + ), + priority_candidate_count=len( + allocation.priority_ids + ), + total_mass=( + allocation.total_mass + ), + priority_mass=( + priority_mass + ), + priority_mass_ppm=( + 0 + if allocation.total_mass + == 0 + else ( + 1_000_000 + * priority_mass + // allocation.total_mass + ) + ), + minimum_threshold=min( + thresholds + ), + maximum_threshold=max( + thresholds + ), + uniform_equivalent_threshold=( + base_denominator + * len( + allocation.mass_by_id + ) + ), + ) diff --git a/experiments/prime_m22_developmental_world/primed_engine.py b/experiments/prime_m22_developmental_world/primed_engine.py new file mode 100644 index 0000000..dcaf8a1 --- /dev/null +++ b/experiments/prime_m22_developmental_world/primed_engine.py @@ -0,0 +1,106 @@ +"""Transfer-primed M20 construction engine for M22.""" + +from __future__ import annotations + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.types import ( + ConstructionSpec, +) + + +class PrimedConstructionEngine( + CompositionalAdaptiveConstructionEngine +): + """M20 construction with externally ranked proposal candidates. + + External candidates change proposal search only. + + Verifier authority remains inherited unchanged from M20. + """ + + def __init__( + self, + *, + priority_specs: tuple[ + ConstructionSpec, + ..., + ] = (), + max_lag: int = 8, + cold_candidate_limit: int = 256, + primed_candidate_limit: int = 64, + ) -> None: + self._priority_specs = ( + priority_specs + ) + + self.primed = bool( + priority_specs + ) + + limit = ( + primed_candidate_limit + if self.primed + else cold_candidate_limit + ) + + super().__init__( + max_lag=max_lag, + max_candidates=limit, + enable_scaffolds=True, + ) + + def _candidate_field( + self, + ): + base = list( + super()._candidate_field() + ) + + active = set( + self.registry.active_ids() + ) + + combined = {} + + # Deliberately preserve learned proposal order. + for spec in ( + self._priority_specs + ): + if ( + spec.construction_id + not in active + ): + combined[ + spec.construction_id + ] = spec + + for spec in base: + if ( + spec.construction_id + not in active + and spec.construction_id + not in combined + ): + combined[ + spec.construction_id + ] = spec + + return tuple( + list( + combined.values() + )[ + :self.max_candidates + ] + ) + + @property + def priority_construction_ids( + self, + ) -> tuple[str, ...]: + return tuple( + spec.construction_id + for spec + in self._priority_specs + ) diff --git a/experiments/prime_m22_developmental_world/run_development.py b/experiments/prime_m22_developmental_world/run_development.py new file mode 100644 index 0000000..f2f9698 --- /dev/null +++ b/experiments/prime_m22_developmental_world/run_development.py @@ -0,0 +1,379 @@ +"""PRIME M22 developmental accumulation experiment.""" + +from __future__ import annotations + +import json + +from .runner import ( + run_curriculum, +) + + +def mean_floor( + values, +): + values = list( + values + ) + + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def main() -> None: + cold, _ = run_curriculum( + persistent=False + ) + + persistent, brain = ( + run_curriculum( + persistent=True + ) + ) + + assert brain is not None + + cold_by_id = { + row["chapter_id"]: row + for row in cold + } + + persistent_by_id = { + row["chapter_id"]: row + for row in persistent + } + + if ( + set(cold_by_id) + != set(persistent_by_id) + ): + raise RuntimeError( + "cold/persistent curriculum mismatch" + ) + + comparisons = [] + + for chapter_id in cold_by_id: + c = cold_by_id[ + chapter_id + ] + + p = persistent_by_id[ + chapter_id + ] + + cold_event = c[ + "first_recovery_event" + ] + + persistent_event = p[ + "first_recovery_event" + ] + + transfer_gain = None + + if ( + cold_event is not None + and persistent_event + is not None + ): + transfer_gain = ( + cold_event + - persistent_event + ) + + comparisons.append( + { + "chapter_id": ( + chapter_id + ), + "developmental_role": ( + c[ + "developmental_role" + ] + ), + "cold_recovered": ( + c["recovered"] + ), + "persistent_recovered": ( + p["recovered"] + ), + "cold_recovery_event": ( + cold_event + ), + "persistent_recovery_event": ( + persistent_event + ), + "transfer_gain_events": ( + transfer_gain + ), + "cold_aulc_ppm": ( + c["aulc_ppm"] + ), + "persistent_aulc_ppm": ( + p["aulc_ppm"] + ), + "aulc_gain_ppm": ( + p["aulc_ppm"] + - c["aulc_ppm"] + ), + "cold_candidates": ( + c[ + "initial_candidate_count" + ] + ), + "persistent_candidates": ( + p[ + "initial_candidate_count" + ] + ), + "persistent_primed": ( + p["primed"] + ), + "persistent_priority_candidates": ( + p[ + "priority_candidate_count" + ] + ), + "persistent_accepted_priority": ( + p[ + "accepted_priority_count" + ] + ), + } + ) + + comparable = [ + row + for row in comparisons + if row[ + "transfer_gain_events" + ] + is not None + ] + + primed = [ + row + for row in comparisons + if row[ + "persistent_primed" + ] + ] + + by_role = {} + + roles = sorted( + { + row[ + "developmental_role" + ] + for row + in comparisons + } + ) + + for role in roles: + subset = [ + row + for row in comparisons + if row[ + "developmental_role" + ] == role + ] + + gains = [ + row[ + "transfer_gain_events" + ] + for row in subset + if row[ + "transfer_gain_events" + ] + is not None + ] + + by_role[ + role + ] = { + "chapter_count": ( + len(subset) + ), + "mean_transfer_gain_events": ( + mean_floor( + gains + ) + ), + "positive_transfer": sum( + gain > 0 + for gain in gains + ), + "ties": sum( + gain == 0 + for gain in gains + ), + "negative_transfer": sum( + gain < 0 + for gain in gains + ), + "mean_aulc_gain_ppm": ( + mean_floor( + row[ + "aulc_gain_ppm" + ] + for row + in subset + ) + ), + } + + schemas = ( + brain.mine_schemas() + ) + + report = { + "experiment": ( + "prime-m22-developmental-laboratory" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "chapter_count": ( + len(comparisons) + ), + "cold_recovery_count": sum( + row[ + "cold_recovered" + ] + for row + in comparisons + ), + "persistent_recovery_count": sum( + row[ + "persistent_recovered" + ] + for row + in comparisons + ), + "comparable_recovery_count": ( + len(comparable) + ), + "mean_transfer_gain_events": ( + mean_floor( + row[ + "transfer_gain_events" + ] + for row + in comparable + ) + ), + "positive_transfer_chapters": sum( + row[ + "transfer_gain_events" + ] > 0 + for row + in comparable + ), + "tied_transfer_chapters": sum( + row[ + "transfer_gain_events" + ] == 0 + for row + in comparable + ), + "negative_transfer_chapters": sum( + row[ + "transfer_gain_events" + ] < 0 + for row + in comparable + ), + "mean_aulc_gain_ppm": ( + mean_floor( + row[ + "aulc_gain_ppm" + ] + for row + in comparisons + ) + ), + "primed_chapter_count": ( + len(primed) + ), + "semantic_memory_classes": ( + len( + brain.semantic_memory.entries + ) + ), + "episodic_memory_count": ( + len( + brain.episodic_memory.records + ) + ), + "episode_chain_valid": ( + brain.episodic_memory.verify_chain() + ), + "schema_count": ( + len(schemas) + ), + "schemas": [ + { + "schema_id": ( + schema.schema_id + ), + "operator": ( + schema.operator + ), + "normalized_offsets": list( + schema.normalized_offsets + ), + "support": ( + schema.support + ), + } + for schema in schemas + ], + "meta_sources": { + source: { + "attempts": stats.attempts, + "accepted": stats.accepted, + "rejected": stats.rejected, + "cumulative_gain_ppm": ( + stats.cumulative_gain_ppm + ), + "priority": stats.priority, + } + for source, stats + in sorted( + brain.meta_memory.sources.items() + ) + }, + "by_role": ( + by_role + ), + "comparisons": ( + comparisons + ), + "cold_rows": ( + cold + ), + "persistent_rows": ( + persistent + ), + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m22_developmental_world/run_ecology_development.py b/experiments/prime_m22_developmental_world/run_ecology_development.py new file mode 100644 index 0000000..71ad7f6 --- /dev/null +++ b/experiments/prime_m22_developmental_world/run_ecology_development.py @@ -0,0 +1,379 @@ +"""PRIME M22 developmental accumulation experiment.""" + +from __future__ import annotations + +import json + +from .runner_ecological import ( + run_curriculum, +) + + +def mean_floor( + values, +): + values = list( + values + ) + + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def main() -> None: + cold, _ = run_curriculum( + persistent=False + ) + + persistent, brain = ( + run_curriculum( + persistent=True + ) + ) + + assert brain is not None + + cold_by_id = { + row["chapter_id"]: row + for row in cold + } + + persistent_by_id = { + row["chapter_id"]: row + for row in persistent + } + + if ( + set(cold_by_id) + != set(persistent_by_id) + ): + raise RuntimeError( + "cold/persistent curriculum mismatch" + ) + + comparisons = [] + + for chapter_id in cold_by_id: + c = cold_by_id[ + chapter_id + ] + + p = persistent_by_id[ + chapter_id + ] + + cold_event = c[ + "first_recovery_event" + ] + + persistent_event = p[ + "first_recovery_event" + ] + + transfer_gain = None + + if ( + cold_event is not None + and persistent_event + is not None + ): + transfer_gain = ( + cold_event + - persistent_event + ) + + comparisons.append( + { + "chapter_id": ( + chapter_id + ), + "developmental_role": ( + c[ + "developmental_role" + ] + ), + "cold_recovered": ( + c["recovered"] + ), + "persistent_recovered": ( + p["recovered"] + ), + "cold_recovery_event": ( + cold_event + ), + "persistent_recovery_event": ( + persistent_event + ), + "transfer_gain_events": ( + transfer_gain + ), + "cold_aulc_ppm": ( + c["aulc_ppm"] + ), + "persistent_aulc_ppm": ( + p["aulc_ppm"] + ), + "aulc_gain_ppm": ( + p["aulc_ppm"] + - c["aulc_ppm"] + ), + "cold_candidates": ( + c[ + "initial_candidate_count" + ] + ), + "persistent_candidates": ( + p[ + "initial_candidate_count" + ] + ), + "persistent_primed": ( + p["primed"] + ), + "persistent_priority_candidates": ( + p[ + "priority_candidate_count" + ] + ), + "persistent_accepted_priority": ( + p[ + "accepted_priority_count" + ] + ), + } + ) + + comparable = [ + row + for row in comparisons + if row[ + "transfer_gain_events" + ] + is not None + ] + + primed = [ + row + for row in comparisons + if row[ + "persistent_primed" + ] + ] + + by_role = {} + + roles = sorted( + { + row[ + "developmental_role" + ] + for row + in comparisons + } + ) + + for role in roles: + subset = [ + row + for row in comparisons + if row[ + "developmental_role" + ] == role + ] + + gains = [ + row[ + "transfer_gain_events" + ] + for row in subset + if row[ + "transfer_gain_events" + ] + is not None + ] + + by_role[ + role + ] = { + "chapter_count": ( + len(subset) + ), + "mean_transfer_gain_events": ( + mean_floor( + gains + ) + ), + "positive_transfer": sum( + gain > 0 + for gain in gains + ), + "ties": sum( + gain == 0 + for gain in gains + ), + "negative_transfer": sum( + gain < 0 + for gain in gains + ), + "mean_aulc_gain_ppm": ( + mean_floor( + row[ + "aulc_gain_ppm" + ] + for row + in subset + ) + ), + } + + schemas = ( + brain.mine_schemas() + ) + + report = { + "experiment": ( + "prime-m22-cognitive-search-ecology" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "chapter_count": ( + len(comparisons) + ), + "cold_recovery_count": sum( + row[ + "cold_recovered" + ] + for row + in comparisons + ), + "persistent_recovery_count": sum( + row[ + "persistent_recovered" + ] + for row + in comparisons + ), + "comparable_recovery_count": ( + len(comparable) + ), + "mean_transfer_gain_events": ( + mean_floor( + row[ + "transfer_gain_events" + ] + for row + in comparable + ) + ), + "positive_transfer_chapters": sum( + row[ + "transfer_gain_events" + ] > 0 + for row + in comparable + ), + "tied_transfer_chapters": sum( + row[ + "transfer_gain_events" + ] == 0 + for row + in comparable + ), + "negative_transfer_chapters": sum( + row[ + "transfer_gain_events" + ] < 0 + for row + in comparable + ), + "mean_aulc_gain_ppm": ( + mean_floor( + row[ + "aulc_gain_ppm" + ] + for row + in comparisons + ) + ), + "primed_chapter_count": ( + len(primed) + ), + "semantic_memory_classes": ( + len( + brain.semantic_memory.entries + ) + ), + "episodic_memory_count": ( + len( + brain.episodic_memory.records + ) + ), + "episode_chain_valid": ( + brain.episodic_memory.verify_chain() + ), + "schema_count": ( + len(schemas) + ), + "schemas": [ + { + "schema_id": ( + schema.schema_id + ), + "operator": ( + schema.operator + ), + "normalized_offsets": list( + schema.normalized_offsets + ), + "support": ( + schema.support + ), + } + for schema in schemas + ], + "meta_sources": { + source: { + "attempts": stats.attempts, + "accepted": stats.accepted, + "rejected": stats.rejected, + "cumulative_gain_ppm": ( + stats.cumulative_gain_ppm + ), + "priority": stats.priority, + } + for source, stats + in sorted( + brain.meta_memory.sources.items() + ) + }, + "by_role": ( + by_role + ), + "comparisons": ( + comparisons + ), + "cold_rows": ( + cold + ), + "persistent_rows": ( + persistent + ), + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m22_developmental_world/runner.py b/experiments/prime_m22_developmental_world/runner.py new file mode 100644 index 0000000..7cf1681 --- /dev/null +++ b/experiments/prime_m22_developmental_world/runner.py @@ -0,0 +1,492 @@ +"""Cold versus persistent developmental PRIME.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition import ( + MegaPrimeCognition, +) +from core.construction.quotient import ( + active_partition_matches, +) + +from .candidate_source import ( + DevelopmentalCandidate, + DevelopmentalCandidateSource, +) +from .primed_engine import ( + PrimedConstructionEngine, +) +from .world import ( + ChapterSpec, + binary_stream, + curriculum, + splitmix64, +) + + +PPM = 1_000_000 +FINAL_WINDOW = 256 + + +class OnlineTableLearner: + def __init__( + self, + seed: int, + ) -> None: + self.seed = seed + + self.counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + def choose( + self, + state: tuple[int, ...], + event_index: int, + ) -> int: + # Identical action randomness for cold/persistent modes. + explore = ( + splitmix64( + self.seed + ^ splitmix64( + event_index + ) + ) + % 10 + == 0 + ) + + if explore: + return ( + splitmix64( + self.seed + ^ 0x4D32324143544E + ^ splitmix64( + event_index + ) + ) + & 1 + ) + + counts = self.counts.get( + state, + [0, 0], + ) + + return int( + counts[1] + > counts[0] + ) + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + counts = ( + self.counts.setdefault( + state, + [0, 0], + ) + ) + + counts[ + target + ] += 1 + + +@dataclass(frozen=True) +class ChapterResult: + payload: dict + + +def target_recovered( + engine: PrimedConstructionEngine, + chapter: ChapterSpec, +) -> bool: + if chapter.expression is None: + return ( + len( + engine.active_construction_ids + ) + == 0 + ) + + return bool( + active_partition_matches( + engine.registry, + chapter.expression, + max_lag=8, + ) + ) + + +def run_chapter( + chapter: ChapterSpec, + *, + cognition: ( + MegaPrimeCognition + | None + ), + persistent: bool, +) -> ChapterResult: + if ( + persistent + and cognition is None + ): + raise ValueError( + "persistent mode requires cognition" + ) + + priority_rows: tuple[ + DevelopmentalCandidate, + ..., + ] = () + + if persistent: + assert cognition is not None + + source = ( + DevelopmentalCandidateSource( + cognition + ) + ) + + priority_rows = ( + source.propose( + context_tokens=( + chapter.context_tokens + ), + max_candidates=64, + ) + ) + + priority_specs = tuple( + row.spec + for row in priority_rows + ) + + engine = ( + PrimedConstructionEngine( + priority_specs=( + priority_specs + ), + max_lag=8, + cold_candidate_limit=256, + primed_candidate_limit=64, + ) + ) + + initial_field = ( + engine.candidate_field_snapshot() + ) + + engine.begin_episode() + + learner = ( + OnlineTableLearner( + splitmix64( + chapter.seed + ^ 0x4D32324C4541524E + ) + ) + ) + + stream = ( + binary_stream( + chapter.seed + ) + ) + + history: list[int] = [] + + outcomes = [] + + cumulative_correct = 0 + curve_sum = 0 + + first_authorization_event = None + first_recovery_event = None + + authorized_ids = [] + + accepted_priority: set[ + str + ] = set() + + for event_index in range( + chapter.steps + ): + observation = next( + stream + ) + + history.append( + observation + ) + + if len(history) > 9: + del history[:-9] + + target = ( + chapter.target( + tuple(history) + ) + ) + + state = engine.observe( + observation + ) + + action = learner.choose( + state, + event_index, + ) + + correct = int( + action == target + ) + + learner.update( + state, + target, + ) + + decision = ( + engine.finalize( + target + ) + ) + + if decision.authorized: + assert ( + decision.construction_id + is not None + ) + + authorized_ids.append( + decision.construction_id + ) + + if ( + first_authorization_event + is None + ): + first_authorization_event = ( + event_index + ) + + if ( + decision.construction_id + in engine.priority_construction_ids + ): + accepted_priority.add( + decision.construction_id + ) + + if ( + first_recovery_event + is None + and target_recovered( + engine, + chapter, + ) + ): + first_recovery_event = ( + event_index + ) + + outcomes.append( + correct + ) + + cumulative_correct += ( + correct + ) + + curve_sum += ( + PPM + * cumulative_correct + // ( + event_index + + 1 + ) + ) + + recovered = ( + target_recovered( + engine, + chapter, + ) + ) + + accuracy_ppm = ( + PPM + * sum(outcomes) + // len(outcomes) + ) + + final = outcomes[ + -min( + FINAL_WINDOW, + len(outcomes), + ): + ] + + final_accuracy_ppm = ( + PPM + * sum(final) + // len(final) + ) + + if persistent: + assert cognition is not None + + priority_lookup = { + row.spec.construction_id: row + for row in priority_rows + } + + for construction_id in ( + accepted_priority + ): + row = priority_lookup[ + construction_id + ] + + cognition.proposal_field.update( + row.spec, + chapter.context_tokens, + accepted=True, + gain_ppm=100000, + ) + + cognition.meta_memory.record( + row.source, + accepted=True, + gain_ppm=100000, + ) + + if row.memory_id is not None: + cognition.semantic_memory.record_transfer_outcome( + row.memory_id, + accepted=True, + gain_ppm=100000, + ) + + cognition.close_world( + engine.registry, + context_id=( + chapter.chapter_id + ), + context_tokens=( + chapter.context_tokens + ), + reward_ppm=( + accuracy_ppm + ), + tensions=( + () + if recovered + else ( + "representation-unresolved", + ) + ), + ) + + return ChapterResult( + payload={ + "chapter_id": ( + chapter.chapter_id + ), + "seed": ( + chapter.seed + ), + "developmental_role": ( + chapter.developmental_role + ), + "persistent": persistent, + "steps": chapter.steps, + "primed": engine.primed, + "priority_candidate_count": ( + len(priority_rows) + ), + "initial_candidate_count": ( + initial_field.candidate_count + ), + "initial_threshold": ( + initial_field.threshold + ), + "first_authorization_event": ( + first_authorization_event + ), + "first_recovery_event": ( + first_recovery_event + ), + "recovered": recovered, + "active_construction_count": ( + len( + engine.active_construction_ids + ) + ), + "authorized_ids": ( + authorized_ids + ), + "accepted_priority_count": ( + len( + accepted_priority + ) + ), + "aulc_ppm": ( + curve_sum + // chapter.steps + ), + "accuracy_ppm": ( + accuracy_ppm + ), + "final_accuracy_ppm": ( + final_accuracy_ppm + ), + "receipt_chain_valid": ( + all( + True + for _ in [ + engine.receipt_chain + ] + ) + ), + } + ) + + +def run_curriculum( + *, + persistent: bool, +) -> tuple[ + list[dict], + MegaPrimeCognition | None, +]: + brain = ( + MegaPrimeCognition() + if persistent + else None + ) + + rows = [] + + for chapter in curriculum(): + rows.append( + run_chapter( + chapter, + cognition=brain, + persistent=persistent, + ).payload + ) + + return ( + rows, + brain, + ) diff --git a/experiments/prime_m22_developmental_world/runner_ecological.py b/experiments/prime_m22_developmental_world/runner_ecological.py new file mode 100644 index 0000000..8910f2f --- /dev/null +++ b/experiments/prime_m22_developmental_world/runner_ecological.py @@ -0,0 +1,513 @@ +"""Cold versus persistent developmental PRIME.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition import ( + MegaPrimeCognition, +) +from core.construction.quotient import ( + active_partition_matches, +) +from core.construction.receipts import ( + verify_receipt_chain, +) + +from .candidate_source import ( + DevelopmentalCandidate, + DevelopmentalCandidateSource, +) +from .ecological_engine import ( + EcologicalConstructionEngine, +) +from .world import ( + ChapterSpec, + binary_stream, + curriculum, + splitmix64, +) + + +PPM = 1_000_000 +FINAL_WINDOW = 256 + + +class OnlineTableLearner: + def __init__( + self, + seed: int, + ) -> None: + self.seed = seed + + self.counts: dict[ + tuple[int, ...], + list[int], + ] = {} + + def choose( + self, + state: tuple[int, ...], + event_index: int, + ) -> int: + # Identical action randomness for cold/persistent modes. + explore = ( + splitmix64( + self.seed + ^ splitmix64( + event_index + ) + ) + % 10 + == 0 + ) + + if explore: + return ( + splitmix64( + self.seed + ^ 0x4D32324143544E + ^ splitmix64( + event_index + ) + ) + & 1 + ) + + counts = self.counts.get( + state, + [0, 0], + ) + + return int( + counts[1] + > counts[0] + ) + + def update( + self, + state: tuple[int, ...], + target: int, + ) -> None: + counts = ( + self.counts.setdefault( + state, + [0, 0], + ) + ) + + counts[ + target + ] += 1 + + +@dataclass(frozen=True) +class ChapterResult: + payload: dict + + +def target_recovered( + engine: EcologicalConstructionEngine, + chapter: ChapterSpec, +) -> bool: + if chapter.expression is None: + return ( + len( + engine.active_construction_ids + ) + == 0 + ) + + return bool( + active_partition_matches( + engine.registry, + chapter.expression, + max_lag=8, + ) + ) + + +def run_chapter( + chapter: ChapterSpec, + *, + cognition: ( + MegaPrimeCognition + | None + ), + persistent: bool, +) -> ChapterResult: + if ( + persistent + and cognition is None + ): + raise ValueError( + "persistent mode requires cognition" + ) + + priority_rows: tuple[ + DevelopmentalCandidate, + ..., + ] = () + + if persistent: + assert cognition is not None + + source = ( + DevelopmentalCandidateSource( + cognition + ) + ) + + priority_rows = ( + source.propose( + context_tokens=( + chapter.context_tokens + ), + max_candidates=64, + ) + ) + + priority_specs = tuple( + row.spec + for row in priority_rows + ) + + engine = ( + EcologicalConstructionEngine( + priority_specs=( + priority_specs + ), + max_lag=8, + universal_candidate_limit=256, + ) + ) + + initial_field = ( + engine.candidate_field_snapshot() + ) + + initial_ecology = ( + engine.ecology_snapshot() + ) + + engine.begin_episode() + + learner = ( + OnlineTableLearner( + splitmix64( + chapter.seed + ^ 0x4D32324C4541524E + ) + ) + ) + + stream = ( + binary_stream( + chapter.seed + ) + ) + + history: list[int] = [] + + outcomes = [] + + cumulative_correct = 0 + curve_sum = 0 + + first_authorization_event = None + first_recovery_event = None + + authorized_ids = [] + + accepted_priority: set[ + str + ] = set() + + for event_index in range( + chapter.steps + ): + observation = next( + stream + ) + + history.append( + observation + ) + + if len(history) > 9: + del history[:-9] + + target = ( + chapter.target( + tuple(history) + ) + ) + + state = engine.observe( + observation + ) + + action = learner.choose( + state, + event_index, + ) + + correct = int( + action == target + ) + + learner.update( + state, + target, + ) + + decision = ( + engine.finalize( + target + ) + ) + + if decision.authorized: + assert ( + decision.construction_id + is not None + ) + + authorized_ids.append( + decision.construction_id + ) + + if ( + first_authorization_event + is None + ): + first_authorization_event = ( + event_index + ) + + if ( + decision.construction_id + in engine.priority_construction_ids + ): + accepted_priority.add( + decision.construction_id + ) + + if ( + first_recovery_event + is None + and target_recovered( + engine, + chapter, + ) + ): + first_recovery_event = ( + event_index + ) + + outcomes.append( + correct + ) + + cumulative_correct += ( + correct + ) + + curve_sum += ( + PPM + * cumulative_correct + // ( + event_index + + 1 + ) + ) + + recovered = ( + target_recovered( + engine, + chapter, + ) + ) + + accuracy_ppm = ( + PPM + * sum(outcomes) + // len(outcomes) + ) + + final = outcomes[ + -min( + FINAL_WINDOW, + len(outcomes), + ): + ] + + final_accuracy_ppm = ( + PPM + * sum(final) + // len(final) + ) + + if persistent: + assert cognition is not None + + priority_lookup = { + row.spec.construction_id: row + for row in priority_rows + } + + for construction_id in ( + accepted_priority + ): + row = priority_lookup[ + construction_id + ] + + cognition.proposal_field.update( + row.spec, + chapter.context_tokens, + accepted=True, + gain_ppm=100000, + ) + + cognition.meta_memory.record( + row.source, + accepted=True, + gain_ppm=100000, + ) + + if row.memory_id is not None: + cognition.semantic_memory.record_transfer_outcome( + row.memory_id, + accepted=True, + gain_ppm=100000, + ) + + cognition.close_world( + engine.registry, + context_id=( + chapter.chapter_id + ), + context_tokens=( + chapter.context_tokens + ), + reward_ppm=( + accuracy_ppm + ), + tensions=( + () + if recovered + else ( + "representation-unresolved", + ) + ), + ) + + return ChapterResult( + payload={ + "chapter_id": ( + chapter.chapter_id + ), + "seed": ( + chapter.seed + ), + "developmental_role": ( + chapter.developmental_role + ), + "persistent": persistent, + "steps": chapter.steps, + "primed": engine.primed, + "priority_candidate_count": ( + len(priority_rows) + ), + "initial_candidate_count": ( + initial_field.candidate_count + ), + "initial_threshold": ( + initial_field.threshold + ), + "ecology_priority_count": ( + initial_ecology.priority_candidate_count + ), + "ecology_priority_mass_ppm": ( + initial_ecology.priority_mass_ppm + ), + "ecology_minimum_threshold": ( + initial_ecology.minimum_threshold + ), + "ecology_maximum_threshold": ( + initial_ecology.maximum_threshold + ), + "ecology_uniform_threshold": ( + initial_ecology.uniform_equivalent_threshold + ), + "first_authorization_event": ( + first_authorization_event + ), + "first_recovery_event": ( + first_recovery_event + ), + "recovered": recovered, + "active_construction_count": ( + len( + engine.active_construction_ids + ) + ), + "authorized_ids": ( + authorized_ids + ), + "accepted_priority_count": ( + len( + accepted_priority + ) + ), + "aulc_ppm": ( + curve_sum + // chapter.steps + ), + "accuracy_ppm": ( + accuracy_ppm + ), + "final_accuracy_ppm": ( + final_accuracy_ppm + ), + "receipt_chain_valid": ( + verify_receipt_chain( + engine.receipt_chain, + expected_count=len( + engine.receipt_chain + ), + ) + ), + } + ) + + +def run_curriculum( + *, + persistent: bool, +) -> tuple[ + list[dict], + MegaPrimeCognition | None, +]: + brain = ( + MegaPrimeCognition() + if persistent + else None + ) + + rows = [] + + for chapter in curriculum(): + rows.append( + run_chapter( + chapter, + cognition=brain, + persistent=persistent, + ).payload + ) + + return ( + rows, + brain, + ) diff --git a/experiments/prime_m22_developmental_world/world.py b/experiments/prime_m22_developmental_world/world.py new file mode 100644 index 0000000..607cf59 --- /dev/null +++ b/experiments/prime_m22_developmental_world/world.py @@ -0,0 +1,401 @@ +"""Procedural developmental curriculum for PRIME M22.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.grammar import ( + binary, + evaluate, + lag, +) +from core.construction.scaffold import ( + fold_commutative, +) +from core.construction.types import ( + FeatureExpr, + FeatureOp, +) + + +MASK64 = ( + (1 << 64) + - 1 +) + + +def splitmix64( + value: int, +) -> int: + z = ( + value + + 0x9E3779B97F4A7C15 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 30) + ) + * 0xBF58476D1CE4E5B9 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 27) + ) + * 0x94D049BB133111EB + ) & MASK64 + + return ( + z + ^ (z >> 31) + ) & MASK64 + + +def binary_stream( + seed: int, +): + state = splitmix64( + seed + ^ 0x4D32324445564C42 + ) + + while True: + state = splitmix64( + state + ) + + yield ( + state >> 63 + ) & 1 + + +def pair( + op: FeatureOp, + a: int, + b: int, +) -> FeatureExpr: + return binary( + op, + lag(a), + lag(b), + ) + + +def triple( + op: FeatureOp, + a: int, + b: int, + c: int, +) -> FeatureExpr: + return fold_commutative( + op, + ( + lag(a), + lag(b), + lag(c), + ), + ) + + +@dataclass(frozen=True) +class ChapterSpec: + chapter_id: str + seed: int + expression: FeatureExpr | None + developmental_role: str + steps: int = 1024 + + @property + def context_tokens( + self, + ) -> tuple[str, ...]: + # Deliberately does not reveal the hidden operator or lags. + return ( + "prime-m22-developmental-lab", + "binary-partial-observation", + "persistent-curriculum", + ) + + def target( + self, + history: tuple[ + int, + ..., + ], + ) -> int: + if self.expression is None: + if not history: + return 0 + + return history[-1] + + return evaluate( + self.expression, + history, + ) + + +def curriculum() -> tuple[ + ChapterSpec, + ..., +]: + chapters = ( + # Foundation. + ChapterSpec( + "C00-current", + 22000, + None, + "novel", + ), + ChapterSpec( + "C01-lag1", + 22001, + lag(1), + "novel", + ), + ChapterSpec( + "C02-xor1-4", + 22002, + pair( + FeatureOp.XOR, + 1, + 4, + ), + "novel", + ), + ChapterSpec( + "C03-and1-4", + 22003, + pair( + FeatureOp.AND, + 1, + 4, + ), + "novel", + ), + + # Exact recurrence. + ChapterSpec( + "C04-lag1-repeat", + 22004, + lag(1), + "repeat", + ), + ChapterSpec( + "C05-xor1-4-repeat", + 22005, + pair( + FeatureOp.XOR, + 1, + 4, + ), + "repeat", + ), + ChapterSpec( + "C06-and1-4-repeat", + 22006, + pair( + FeatureOp.AND, + 1, + 4, + ), + "repeat", + ), + + # Shifted families: enough evidence for schema formation. + ChapterSpec( + "C07-xor2-5", + 22007, + pair( + FeatureOp.XOR, + 2, + 5, + ), + "family-learning", + ), + ChapterSpec( + "C08-xor3-6", + 22008, + pair( + FeatureOp.XOR, + 3, + 6, + ), + "schema-transfer", + ), + ChapterSpec( + "C09-xor4-7", + 22009, + pair( + FeatureOp.XOR, + 4, + 7, + ), + "schema-transfer", + ), + + ChapterSpec( + "C10-and2-5", + 22010, + pair( + FeatureOp.AND, + 2, + 5, + ), + "family-learning", + ), + ChapterSpec( + "C11-and3-6", + 22011, + pair( + FeatureOp.AND, + 3, + 6, + ), + "schema-transfer", + ), + ChapterSpec( + "C12-and4-7", + 22012, + pair( + FeatureOp.AND, + 4, + 7, + ), + "schema-transfer", + ), + + # OR family. + ChapterSpec( + "C13-or1-4", + 22013, + pair( + FeatureOp.OR, + 1, + 4, + ), + "novel", + ), + ChapterSpec( + "C14-or2-5", + 22014, + pair( + FeatureOp.OR, + 2, + 5, + ), + "family-learning", + ), + ChapterSpec( + "C15-or3-6", + 22015, + pair( + FeatureOp.OR, + 3, + 6, + ), + "schema-transfer", + ), + + # Higher-order family. + ChapterSpec( + "C16-xor123", + 22016, + triple( + FeatureOp.XOR, + 1, + 2, + 3, + ), + "novel", + ), + ChapterSpec( + "C17-xor234", + 22017, + triple( + FeatureOp.XOR, + 2, + 3, + 4, + ), + "family-learning", + ), + ChapterSpec( + "C18-xor345", + 22018, + triple( + FeatureOp.XOR, + 3, + 4, + 5, + ), + "schema-transfer", + ), + + # Complement-equivalent family. + ChapterSpec( + "C19-eq1-4", + 22019, + pair( + FeatureOp.EQ, + 1, + 4, + ), + "quotient-transfer", + ), + + # Stress: no representation should be invented. + ChapterSpec( + "C20-current", + 22020, + None, + "negative-transfer", + ), + + # Return to old knowledge after intervening worlds. + ChapterSpec( + "C21-xor1-4-long-return", + 22021, + pair( + FeatureOp.XOR, + 1, + 4, + ), + "long-range-recall", + ), + ChapterSpec( + "C22-lag1-long-return", + 22022, + lag(1), + "long-range-recall", + ), + + # Higher-order conjunction/disjunction. + ChapterSpec( + "C23-and124", + 22023, + triple( + FeatureOp.AND, + 1, + 2, + 4, + ), + "novel", + ), + ChapterSpec( + "C24-or234", + 22024, + triple( + FeatureOp.OR, + 2, + 3, + 4, + ), + "novel", + ), + ) + + return chapters diff --git a/experiments/prime_m23_causal_world/episode.py b/experiments/prime_m23_causal_world/episode.py new file mode 100644 index 0000000..80f57b6 --- /dev/null +++ b/experiments/prime_m23_causal_world/episode.py @@ -0,0 +1,130 @@ +"""End-to-end causal discovery and planning episode.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from .lab import ( + CONFIGURATIONS, + CausalLab, + DoorLaw, + evaluate_law, +) +from .scientist import ( + CausalScientist, +) + + +@dataclass(frozen=True) +class EpisodeResult: + law: DoorLaw + prior: DoorLaw | None + prior_correct: bool | None + verified: bool + interventions: int + discovery_steps: int + total_steps: int + goal_reached: bool + verified_law: DoorLaw | None + + +def solve_episode( + law: DoorLaw, + *, + prior: DoorLaw | None = None, +) -> EpisodeResult: + lab = CausalLab( + law + ) + + scientist = ( + CausalScientist( + prior=prior + ) + ) + + while ( + scientist.verified_law + is None + ): + configuration = ( + scientist.choose_intervention() + ) + + outcome = ( + lab.perform_intervention( + configuration + ) + ) + + scientist.observe( + configuration, + outcome, + ) + + verified_law = ( + scientist.verified_law + ) + + assert verified_law is not None + + discovery_steps = ( + lab.state.steps + ) + + opening = [ + configuration + for configuration + in CONFIGURATIONS + if evaluate_law( + verified_law, + configuration[0], + configuration[1], + ) + == 1 + ] + + if not opening: + raise RuntimeError( + "verified law has no opening state" + ) + + # Choose cheapest reachable opening configuration. + opening.sort() + + lab.set_configuration( + opening[0] + ) + + lab.walk_to( + lab.layout.goal + ) + + return EpisodeResult( + law=law, + prior=prior, + prior_correct=( + None + if prior is None + else ( + prior + == law + ) + ), + verified=True, + interventions=len( + scientist.observations + ), + discovery_steps=( + discovery_steps + ), + total_steps=( + lab.state.steps + ), + goal_reached=( + lab.state.goal_reached + ), + verified_law=( + verified_law + ), + ) diff --git a/experiments/prime_m23_causal_world/lab.py b/experiments/prime_m23_causal_world/lab.py new file mode 100644 index 0000000..a31ce66 --- /dev/null +++ b/experiments/prime_m23_causal_world/lab.py @@ -0,0 +1,402 @@ +"""PRIME M23 causal developmental laboratory.""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum +from collections import deque + + +class DoorLaw(str, Enum): + A = "A" + B = "B" + NOT_A = "NOT_A" + NOT_B = "NOT_B" + AND = "AND" + OR = "OR" + XOR = "XOR" + EQ = "EQ" + + +ALL_LAWS = tuple( + DoorLaw +) + + +def evaluate_law( + law: DoorLaw, + a: int, + b: int, +) -> int: + if law == DoorLaw.A: + return a + + if law == DoorLaw.B: + return b + + if law == DoorLaw.NOT_A: + return 1 - a + + if law == DoorLaw.NOT_B: + return 1 - b + + if law == DoorLaw.AND: + return a & b + + if law == DoorLaw.OR: + return a | b + + if law == DoorLaw.XOR: + return a ^ b + + if law == DoorLaw.EQ: + return int( + a == b + ) + + raise ValueError( + law + ) + + +CONFIGURATIONS = ( + (0, 0), + (0, 1), + (1, 0), + (1, 1), +) + + +@dataclass(frozen=True) +class LabLayout: + width: int = 7 + height: int = 5 + + start: tuple[int, int] = ( + 0, + 2, + ) + + switch_a: tuple[int, int] = ( + 1, + 1, + ) + + switch_b: tuple[int, int] = ( + 1, + 3, + ) + + door: tuple[int, int] = ( + 3, + 2, + ) + + sensor: tuple[int, int] = ( + 2, + 2, + ) + + goal: tuple[int, int] = ( + 6, + 2, + ) + + +@dataclass +class LabState: + position: tuple[int, int] + switch_a: int = 0 + switch_b: int = 0 + steps: int = 0 + goal_reached: bool = False + + +class CausalLab: + def __init__( + self, + law: DoorLaw, + *, + layout: LabLayout | None = None, + ) -> None: + self.law = law + + self.layout = ( + layout + if layout is not None + else LabLayout() + ) + + self.state = LabState( + position=( + self.layout.start + ) + ) + + @property + def door_open(self) -> bool: + return bool( + evaluate_law( + self.law, + self.state.switch_a, + self.state.switch_b, + ) + ) + + def _inside( + self, + position: tuple[int, int], + ) -> bool: + x, y = position + + return ( + 0 <= x < self.layout.width + and 0 <= y < self.layout.height + ) + + def _passable( + self, + position: tuple[int, int], + ) -> bool: + if not self._inside( + position + ): + return False + + # Wall across x=3 except for the causal door. + x, y = position + + if ( + x == 3 + and position + != self.layout.door + ): + return False + + if ( + position + == self.layout.door + and not self.door_open + ): + return False + + return True + + def move( + self, + dx: int, + dy: int, + ) -> bool: + current = ( + self.state.position + ) + + target = ( + current[0] + dx, + current[1] + dy, + ) + + self.state.steps += 1 + + if not self._passable( + target + ): + return False + + self.state.position = ( + target + ) + + if ( + target + == self.layout.goal + ): + self.state.goal_reached = ( + True + ) + + return True + + def interact(self) -> bool: + self.state.steps += 1 + + if ( + self.state.position + == self.layout.switch_a + ): + self.state.switch_a ^= 1 + return True + + if ( + self.state.position + == self.layout.switch_b + ): + self.state.switch_b ^= 1 + return True + + return False + + def probe_door( + self, + ) -> int: + if ( + self.state.position + != self.layout.sensor + ): + raise RuntimeError( + "door may only be probed from sensor" + ) + + self.state.steps += 1 + + return int( + self.door_open + ) + + def shortest_path( + self, + start: tuple[int, int], + target: tuple[int, int], + ) -> tuple[ + tuple[int, int], + ..., + ] | None: + if start == target: + return () + + moves = ( + (1, 0), + (-1, 0), + (0, 1), + (0, -1), + ) + + queue = deque( + [ + ( + start, + (), + ) + ] + ) + + seen = { + start + } + + while queue: + position, path = ( + queue.popleft() + ) + + for move in moves: + nxt = ( + position[0] + + move[0], + position[1] + + move[1], + ) + + if nxt in seen: + continue + + if not self._passable( + nxt + ): + continue + + new_path = ( + path + + ( + move, + ) + ) + + if nxt == target: + return new_path + + seen.add( + nxt + ) + + queue.append( + ( + nxt, + new_path, + ) + ) + + return None + + def walk_to( + self, + target: tuple[int, int], + ) -> None: + path = self.shortest_path( + self.state.position, + target, + ) + + if path is None: + raise RuntimeError( + "target unreachable" + ) + + for dx, dy in path: + moved = self.move( + dx, + dy, + ) + + if not moved: + raise RuntimeError( + "planned move failed" + ) + + def set_configuration( + self, + configuration: tuple[ + int, + int, + ], + ) -> None: + desired_a, desired_b = ( + configuration + ) + + if ( + self.state.switch_a + != desired_a + ): + self.walk_to( + self.layout.switch_a + ) + + self.interact() + + if ( + self.state.switch_b + != desired_b + ): + self.walk_to( + self.layout.switch_b + ) + + self.interact() + + def perform_intervention( + self, + configuration: tuple[ + int, + int, + ], + ) -> int: + self.set_configuration( + configuration + ) + + self.walk_to( + self.layout.sensor + ) + + return self.probe_door() diff --git a/experiments/prime_m23_causal_world/scientist.py b/experiments/prime_m23_causal_world/scientist.py new file mode 100644 index 0000000..6e7a795 --- /dev/null +++ b/experiments/prime_m23_causal_world/scientist.py @@ -0,0 +1,307 @@ +"""Active causal hypothesis testing for PRIME M23.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition import ( + ActiveStudySelector, + StudyAction, +) + +from .lab import ( + ALL_LAWS, + CONFIGURATIONS, + DoorLaw, + evaluate_law, +) + + +@dataclass(frozen=True) +class CausalVerification: + law: DoorLaw + interventions: tuple[ + tuple[ + tuple[int, int], + int, + ], + ..., + ] + surviving_laws: tuple[ + DoorLaw, + ..., + ] + verified: bool + + +class CausalScientist: + def __init__( + self, + *, + prior: DoorLaw | None = None, + ) -> None: + self.prior = prior + + self.survivors = set( + ALL_LAWS + ) + + self.observations: list[ + tuple[ + tuple[int, int], + int, + ] + ] = [] + + self.selector = ( + ActiveStudySelector() + ) + + def _predictions( + self, + configuration: tuple[ + int, + int, + ], + ) -> dict[str, int]: + a, b = configuration + + return { + law.value: ( + evaluate_law( + law, + a, + b, + ) + ) + for law + in sorted( + self.survivors, + key=lambda row: ( + row.value + ), + ) + } + + def choose_intervention( + self, + ) -> tuple[int, int]: + observed = { + configuration + for configuration, _ + in self.observations + } + + actions = [] + + for configuration in ( + CONFIGURATIONS + ): + if configuration in observed: + continue + + predictions = ( + self._predictions( + configuration + ) + ) + + action = StudyAction( + action_id=( + str( + configuration + ) + ), + candidate_predictions=( + predictions + ), + cost=0, + ) + + actions.append( + action + ) + + if not actions: + raise RuntimeError( + "no interventions remain" + ) + + ranked = ( + self.selector.rank( + tuple(actions) + ) + ) + + # If we have a prior, prefer an equally informative study that + # directly challenges it. + best_score = ( + ranked[0].score + ) + + equally_good = { + row.action_id + for row in ranked + if row.score + == best_score + } + + if ( + self.prior is not None + and self.prior + in self.survivors + ): + alternatives = ( + self.survivors + - { + self.prior + } + ) + + challenging = [] + + for configuration in ( + CONFIGURATIONS + ): + if configuration in observed: + continue + + a, b = configuration + + prior_prediction = ( + evaluate_law( + self.prior, + a, + b, + ) + ) + + separated = sum( + evaluate_law( + other, + a, + b, + ) + != prior_prediction + for other + in alternatives + ) + + challenging.append( + ( + -separated, + configuration, + ) + ) + + challenging.sort() + + for _, configuration in ( + challenging + ): + if ( + str( + configuration + ) + in equally_good + ): + return configuration + + action_id = ( + ranked[0].action_id + ) + + mapping = { + str(configuration): configuration + for configuration + in CONFIGURATIONS + } + + return mapping[ + action_id + ] + + def observe( + self, + configuration: tuple[ + int, + int, + ], + outcome: int, + ) -> None: + self.observations.append( + ( + configuration, + outcome, + ) + ) + + a, b = configuration + + self.survivors = { + law + for law + in self.survivors + if ( + evaluate_law( + law, + a, + b, + ) + == outcome + ) + } + + if not self.survivors: + raise RuntimeError( + "causal hypothesis class falsified" + ) + + @property + def verified_law( + self, + ) -> DoorLaw | None: + if len( + self.survivors + ) != 1: + return None + + return next( + iter( + self.survivors + ) + ) + + def receipt( + self, + ) -> CausalVerification: + law = ( + self.verified_law + ) + + return CausalVerification( + law=( + law + if law is not None + else sorted( + self.survivors, + key=lambda row: ( + row.value + ), + )[0] + ), + interventions=tuple( + self.observations + ), + surviving_laws=tuple( + sorted( + self.survivors, + key=lambda row: ( + row.value + ), + ) + ), + verified=( + law is not None + ), + ) diff --git a/experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.json b/experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.json new file mode 100644 index 0000000..94d9700 --- /dev/null +++ b/experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.json @@ -0,0 +1,722 @@ +{ + "causal_memory_size": 26, + "causal_schema_count": 7, + "causal_schemas": [ + { + "offsets": [ + 0, + 1 + ], + "operator": "AND", + "support": 3 + }, + { + "offsets": [ + 0, + 1 + ], + "operator": "EQ", + "support": 3 + }, + { + "offsets": [ + 0, + 1 + ], + "operator": "OR", + "support": 3 + }, + { + "offsets": [ + 0, + 1 + ], + "operator": "XOR", + "support": 3 + }, + { + "offsets": [ + 0, + 1, + 2 + ], + "operator": "AND", + "support": 2 + }, + { + "offsets": [ + 0, + 1, + 2 + ], + "operator": "OR", + "support": 2 + }, + { + "offsets": [ + 0, + 1, + 2 + ], + "operator": "XOR", + "support": 2 + } + ], + "chapter_count": 32, + "cold_authority_chain_valid": true, + "cold_goal_count": 32, + "episodic_chain_valid": true, + "exact_memory_hits": 3, + "experiment": "prime-m24-causal-program-development", + "mean_intervention_gain": -0.25, + "mean_step_gain": -1.8125, + "negative_intervention_transfer": 14, + "persistent_authority_chain_valid": true, + "persistent_goal_count": 32, + "positive_intervention_transfer": 9, + "rows": [ + { + "attempted_priority_count": 0, + "certificate_size": 4, + "chapter_id": "C00-A", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 75, + "exact_memory_hit": false, + "falsified_priority_count": 0, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 75, + "priority_count": 0, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 0, + "target": "A", + "target_in_priority": false + }, + { + "attempted_priority_count": 1, + "certificate_size": 3, + "chapter_id": "C01-XOR-AB", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 79, + "exact_memory_hit": false, + "falsified_priority_count": 1, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 77, + "priority_count": 1, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 2, + "target": "XOR(A,B)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 4, + "chapter_id": "C02-AND-AB", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 76, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 98, + "priority_count": 2, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": -22, + "target": "AND(A,B)", + "target_in_priority": false + }, + { + "attempted_priority_count": 1, + "certificate_size": 4, + "chapter_id": "C03-OR-AB", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 67, + "exact_memory_hit": false, + "falsified_priority_count": 1, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 67, + "priority_count": 3, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 0, + "target": "OR(A,B)", + "target_in_priority": false + }, + { + "attempted_priority_count": 1, + "certificate_size": 3, + "chapter_id": "C04-NOT-A", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 65, + "exact_memory_hit": false, + "falsified_priority_count": 1, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 67, + "priority_count": 4, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": -2, + "target": "NOT(A)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 3, + "chapter_id": "C05-XOR-AB-repeat", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 79, + "exact_memory_hit": true, + "falsified_priority_count": 2, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 82, + "priority_count": 5, + "role": "repeat", + "schema_or_generalized_hit": false, + "step_gain": -3, + "target": "XOR(A,B)", + "target_in_priority": true + }, + { + "attempted_priority_count": 1, + "certificate_size": 3, + "chapter_id": "C06-XOR-BC", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 83, + "exact_memory_hit": false, + "falsified_priority_count": 1, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 62, + "priority_count": 5, + "role": "family-learning", + "schema_or_generalized_hit": false, + "step_gain": 21, + "target": "XOR(B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 3, + "chapter_id": "C07-XOR-CD", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 67, + "exact_memory_hit": false, + "falsified_priority_count": 1, + "intervention_gain": 2, + "persistent_goal": true, + "persistent_interventions": 4, + "persistent_total_steps": 64, + "priority_count": 7, + "role": "schema-transfer", + "schema_or_generalized_hit": true, + "step_gain": 3, + "target": "XOR(C,D)", + "target_in_priority": true + }, + { + "attempted_priority_count": 2, + "certificate_size": 4, + "chapter_id": "C08-AND-AB-repeat", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 76, + "exact_memory_hit": true, + "falsified_priority_count": 1, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 73, + "priority_count": 7, + "role": "repeat", + "schema_or_generalized_hit": false, + "step_gain": 3, + "target": "AND(A,B)", + "target_in_priority": true + }, + { + "attempted_priority_count": 2, + "certificate_size": 4, + "chapter_id": "C09-AND-BC", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 65, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": -2, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 79, + "priority_count": 7, + "role": "family-learning", + "schema_or_generalized_hit": false, + "step_gain": -14, + "target": "AND(B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 4, + "certificate_size": 4, + "chapter_id": "C10-AND-CD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 71, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 86, + "priority_count": 8, + "role": "schema-transfer", + "schema_or_generalized_hit": true, + "step_gain": -15, + "target": "AND(C,D)", + "target_in_priority": true + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C11-OR-AB-repeat", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 67, + "exact_memory_hit": true, + "falsified_priority_count": 2, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 76, + "priority_count": 8, + "role": "repeat", + "schema_or_generalized_hit": false, + "step_gain": -9, + "target": "OR(A,B)", + "target_in_priority": true + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C12-OR-BC", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 76, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 89, + "priority_count": 8, + "role": "family-learning", + "schema_or_generalized_hit": false, + "step_gain": -13, + "target": "OR(B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C13-OR-CD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 73, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 67, + "priority_count": 8, + "role": "schema-transfer", + "schema_or_generalized_hit": false, + "step_gain": 6, + "target": "OR(C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 1, + "certificate_size": 3, + "chapter_id": "C14-EQ-AB", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 78, + "exact_memory_hit": false, + "falsified_priority_count": 1, + "intervention_gain": 2, + "persistent_goal": true, + "persistent_interventions": 4, + "persistent_total_steps": 46, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 32, + "target": "EQ(A,B)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 3, + "chapter_id": "C15-EQ-BC", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 84, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 55, + "priority_count": 8, + "role": "family-learning", + "schema_or_generalized_hit": false, + "step_gain": 29, + "target": "EQ(B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 3, + "chapter_id": "C16-EQ-CD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 65, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 75, + "priority_count": 8, + "role": "schema-transfer", + "schema_or_generalized_hit": false, + "step_gain": -10, + "target": "EQ(C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C17-XOR-ABC", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 83, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 60, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 23, + "target": "XOR(A,B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C18-XOR-BCD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 66, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 75, + "priority_count": 8, + "role": "schema-transfer", + "schema_or_generalized_hit": false, + "step_gain": -9, + "target": "XOR(B,C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 5, + "chapter_id": "C19-AND-ABC", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 83, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 86, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": -3, + "target": "AND(A,B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 5, + "chapter_id": "C20-AND-BCD", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 89, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 96, + "priority_count": 8, + "role": "schema-transfer", + "schema_or_generalized_hit": false, + "step_gain": -7, + "target": "AND(B,C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 4, + "certificate_size": 5, + "chapter_id": "C21-OR-ABC", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 76, + "exact_memory_hit": false, + "falsified_priority_count": 4, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 91, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": -15, + "target": "OR(A,B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 4, + "certificate_size": 5, + "chapter_id": "C22-OR-BCD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 66, + "exact_memory_hit": false, + "falsified_priority_count": 4, + "intervention_gain": -3, + "persistent_goal": true, + "persistent_interventions": 8, + "persistent_total_steps": 106, + "priority_count": 8, + "role": "schema-transfer", + "schema_or_generalized_hit": false, + "step_gain": -40, + "target": "OR(B,C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C23-XOR-ABCD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 60, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 81, + "priority_count": 8, + "role": "higher-order", + "schema_or_generalized_hit": false, + "step_gain": -21, + "target": "XOR(A,B,C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 4, + "chapter_id": "C24-AND-ABCD", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 86, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 95, + "priority_count": 8, + "role": "higher-order", + "schema_or_generalized_hit": false, + "step_gain": -9, + "target": "AND(A,B,C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 4, + "certificate_size": 5, + "chapter_id": "C25-OR-ABCD", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 66, + "exact_memory_hit": false, + "falsified_priority_count": 4, + "intervention_gain": -3, + "persistent_goal": true, + "persistent_interventions": 8, + "persistent_total_steps": 99, + "priority_count": 8, + "role": "higher-order", + "schema_or_generalized_hit": false, + "step_gain": -33, + "target": "OR(A,B,C,D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 3, + "chapter_id": "C26-NOT-B", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 71, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 59, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 12, + "target": "NOT(B)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 3, + "chapter_id": "C27-NOT-C", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 57, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 4, + "persistent_total_steps": 43, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 14, + "target": "NOT(C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 3, + "chapter_id": "C28-NOT-D", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 73, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": 0, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 54, + "priority_count": 8, + "role": "novel", + "schema_or_generalized_hit": false, + "step_gain": 19, + "target": "NOT(D)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 3, + "chapter_id": "C29-XOR-AB-return", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 79, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": 1, + "persistent_goal": true, + "persistent_interventions": 5, + "persistent_total_steps": 67, + "priority_count": 8, + "role": "long-return", + "schema_or_generalized_hit": false, + "step_gain": 12, + "target": "XOR(A,B)", + "target_in_priority": false + }, + { + "attempted_priority_count": 3, + "certificate_size": 5, + "chapter_id": "C30-AND-ABC-return", + "cold_goal": true, + "cold_interventions": 6, + "cold_total_steps": 83, + "exact_memory_hit": false, + "falsified_priority_count": 3, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 7, + "persistent_total_steps": 86, + "priority_count": 8, + "role": "long-return", + "schema_or_generalized_hit": false, + "step_gain": -3, + "target": "AND(A,B,C)", + "target_in_priority": false + }, + { + "attempted_priority_count": 2, + "certificate_size": 5, + "chapter_id": "C31-OR-BCD-return", + "cold_goal": true, + "cold_interventions": 5, + "cold_total_steps": 66, + "exact_memory_hit": false, + "falsified_priority_count": 2, + "intervention_gain": -1, + "persistent_goal": true, + "persistent_interventions": 6, + "persistent_total_steps": 72, + "priority_count": 8, + "role": "long-return", + "schema_or_generalized_hit": false, + "step_gain": -6, + "target": "OR(B,C,D)", + "target_in_priority": false + } + ], + "schema_or_generalized_hits": 2, + "status": "DEVELOPMENT_ONLY", + "tied_intervention_transfer": 9 +} diff --git a/experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.sha256 b/experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.sha256 new file mode 100644 index 0000000..77f94a0 --- /dev/null +++ b/experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.sha256 @@ -0,0 +1 @@ +283787ef9c11beab69632003c434f3826f61eb837b2c7221733693e05502e224 experiments/prime_m24_causal_program_world/DEVELOPMENT_V0_1_RESULT.json diff --git a/experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.md b/experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.md new file mode 100644 index 0000000..3750d8a --- /dev/null +++ b/experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.md @@ -0,0 +1,97 @@ +# PRIME M24 Causal Program Development v0.1 + +Status: + + DEVELOPMENT RESULT — PERSISTENT EPISTEMIC CONTROL NOT SUPPORTED + +Goals: + + COLD: + 32 / 32 + + PERSISTENT: + 32 / 32 + +Mean intervention gain: + + -0.25 + +Mean primitive-step gain: + + -1.8125 + +Positive / tied / negative intervention transfer: + + 9 / 9 / 14 + +Accumulated persistent cognition: + + 26 verified causal programs + 7 induced causal schemas + +Authority: + + cold authority chain: + valid + + persistent authority chain: + valid + + episodic chain: + valid + +The failure is not inability to discover or use causal mechanisms. + +Both systems identify mechanisms and solve every world. + +The failure is epistemic-control strategy. + +M24 v0.1 treats remembered programs as an ordered sequence of candidate +theories. + +A high-ranked wrong remembered theory may therefore consume targeted +experiments before a lower-ranked correct theory is considered. + +Even an exact remembered program does not necessarily reduce intervention +count. + +Example: + + XOR(A,B) repeat + + certificate size: + 3 + + cold interventions: + 6 + + persistent interventions: + 6 + + exact memory hit: + true + +The correct theory existed in memory but memory was not used as a global +hypothesis distribution. + +The architecture therefore confuses: + + prioritized theory testing + +with: + + globally optimized experiment selection. + +M25 must replace sequential prior testing with a universal weighted causal +hypothesis ecology. + +Every frozen causal program remains possible until contradicted. + +Prior verified experience changes proposal mass, not authority. + +Each intervention must be selected against the entire surviving hypothesis +population. + +Spatial / primitive action cost must enter the study objective. + +No M24 result is held-out evidence. diff --git a/experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.sha256 b/experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.sha256 new file mode 100644 index 0000000..40df53c --- /dev/null +++ b/experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.sha256 @@ -0,0 +1 @@ +0d2265993cce913536340be23e534276605819086efee4656e0e47ebab218689 experiments/prime_m24_causal_program_world/V0_1_DIAGNOSIS.md diff --git a/experiments/prime_m24_causal_program_world/__init__.py b/experiments/prime_m24_causal_program_world/__init__.py new file mode 100644 index 0000000..5f0b877 --- /dev/null +++ b/experiments/prime_m24_causal_program_world/__init__.py @@ -0,0 +1 @@ +"""PRIME M24 causal program induction.""" diff --git a/experiments/prime_m24_causal_program_world/development.py b/experiments/prime_m24_causal_program_world/development.py new file mode 100644 index 0000000..bbbc80f --- /dev/null +++ b/experiments/prime_m24_causal_program_world/development.py @@ -0,0 +1,631 @@ +"""Persistent causal-program development for PRIME M24.""" + +from __future__ import annotations + +from dataclasses import dataclass +import json + +from core.cognition import ( + MegaPrimeCognition, +) +from core.cognition.causal_certificate import ( + CausalAuthorityLedger, +) +from core.cognition.causal_program import ( + CausalProgram, + ProgramOp, +) + +from .episode import ( + run_program_episode, +) + + +@dataclass(frozen=True) +class CausalChapter: + chapter_id: str + role: str + program: CausalProgram + + +def P( + op, + *variables, +): + return CausalProgram( + op, + tuple( + variables + ), + ) + + +def curriculum(): + return ( + CausalChapter( + "C00-A", + "novel", + P( + ProgramOp.VAR, + 0, + ), + ), + CausalChapter( + "C01-XOR-AB", + "novel", + P( + ProgramOp.XOR, + 0, + 1, + ), + ), + CausalChapter( + "C02-AND-AB", + "novel", + P( + ProgramOp.AND, + 0, + 1, + ), + ), + CausalChapter( + "C03-OR-AB", + "novel", + P( + ProgramOp.OR, + 0, + 1, + ), + ), + CausalChapter( + "C04-NOT-A", + "novel", + P( + ProgramOp.NOT, + 0, + ), + ), + + CausalChapter( + "C05-XOR-AB-repeat", + "repeat", + P( + ProgramOp.XOR, + 0, + 1, + ), + ), + CausalChapter( + "C06-XOR-BC", + "family-learning", + P( + ProgramOp.XOR, + 1, + 2, + ), + ), + CausalChapter( + "C07-XOR-CD", + "schema-transfer", + P( + ProgramOp.XOR, + 2, + 3, + ), + ), + + CausalChapter( + "C08-AND-AB-repeat", + "repeat", + P( + ProgramOp.AND, + 0, + 1, + ), + ), + CausalChapter( + "C09-AND-BC", + "family-learning", + P( + ProgramOp.AND, + 1, + 2, + ), + ), + CausalChapter( + "C10-AND-CD", + "schema-transfer", + P( + ProgramOp.AND, + 2, + 3, + ), + ), + + CausalChapter( + "C11-OR-AB-repeat", + "repeat", + P( + ProgramOp.OR, + 0, + 1, + ), + ), + CausalChapter( + "C12-OR-BC", + "family-learning", + P( + ProgramOp.OR, + 1, + 2, + ), + ), + CausalChapter( + "C13-OR-CD", + "schema-transfer", + P( + ProgramOp.OR, + 2, + 3, + ), + ), + + CausalChapter( + "C14-EQ-AB", + "novel", + P( + ProgramOp.EQ, + 0, + 1, + ), + ), + CausalChapter( + "C15-EQ-BC", + "family-learning", + P( + ProgramOp.EQ, + 1, + 2, + ), + ), + CausalChapter( + "C16-EQ-CD", + "schema-transfer", + P( + ProgramOp.EQ, + 2, + 3, + ), + ), + + CausalChapter( + "C17-XOR-ABC", + "novel", + P( + ProgramOp.XOR, + 0, + 1, + 2, + ), + ), + CausalChapter( + "C18-XOR-BCD", + "schema-transfer", + P( + ProgramOp.XOR, + 1, + 2, + 3, + ), + ), + + CausalChapter( + "C19-AND-ABC", + "novel", + P( + ProgramOp.AND, + 0, + 1, + 2, + ), + ), + CausalChapter( + "C20-AND-BCD", + "schema-transfer", + P( + ProgramOp.AND, + 1, + 2, + 3, + ), + ), + + CausalChapter( + "C21-OR-ABC", + "novel", + P( + ProgramOp.OR, + 0, + 1, + 2, + ), + ), + CausalChapter( + "C22-OR-BCD", + "schema-transfer", + P( + ProgramOp.OR, + 1, + 2, + 3, + ), + ), + + CausalChapter( + "C23-XOR-ABCD", + "higher-order", + P( + ProgramOp.XOR, + 0, + 1, + 2, + 3, + ), + ), + CausalChapter( + "C24-AND-ABCD", + "higher-order", + P( + ProgramOp.AND, + 0, + 1, + 2, + 3, + ), + ), + CausalChapter( + "C25-OR-ABCD", + "higher-order", + P( + ProgramOp.OR, + 0, + 1, + 2, + 3, + ), + ), + + CausalChapter( + "C26-NOT-B", + "novel", + P( + ProgramOp.NOT, + 1, + ), + ), + CausalChapter( + "C27-NOT-C", + "novel", + P( + ProgramOp.NOT, + 2, + ), + ), + CausalChapter( + "C28-NOT-D", + "novel", + P( + ProgramOp.NOT, + 3, + ), + ), + + CausalChapter( + "C29-XOR-AB-return", + "long-return", + P( + ProgramOp.XOR, + 0, + 1, + ), + ), + CausalChapter( + "C30-AND-ABC-return", + "long-return", + P( + ProgramOp.AND, + 0, + 1, + 2, + ), + ), + CausalChapter( + "C31-OR-BCD-return", + "long-return", + P( + ProgramOp.OR, + 1, + 2, + 3, + ), + ), + ) + + +def main(): + brain = ( + MegaPrimeCognition() + ) + + cold_ledger = ( + CausalAuthorityLedger() + ) + + persistent_ledger = ( + CausalAuthorityLedger() + ) + + rows = [] + + for chapter in curriculum(): + cold = run_program_episode( + chapter.program, + priority_program_ids=(), + authority_ledger=( + cold_ledger + ), + ) + + memory = ( + brain.causal_program_memory + ) + + seen_before = ( + chapter.program.program_id + in memory.entries + ) + + priorities = ( + memory.priority_program_ids( + limit=8 + ) + ) + + persistent = ( + run_program_episode( + chapter.program, + priority_program_ids=( + priorities + ), + authority_ledger=( + persistent_ledger + ), + ) + ) + + target_prior = ( + chapter.program.program_id + in priorities + ) + + for program_id in ( + persistent.falsified_priority_ids + ): + memory.record_reuse( + program_id, + success=False, + ) + + memory.ingest( + persistent.authorization + ) + + if target_prior: + memory.record_reuse( + chapter.program.program_id, + success=True, + ) + + brain.episodic_memory.append( + context_id=( + chapter.chapter_id + ), + context_tokens=( + "m24-causal-program-world", + chapter.role, + ), + verified_construction_ids=( + chapter.program.program_id, + ), + reward_ppm=max( + 0, + ( + 1_000_000 + - 5_000 + * persistent.total_steps + ), + ), + studies=tuple( + str(configuration) + for configuration + in () + ), + ) + + rows.append( + { + "chapter_id": ( + chapter.chapter_id + ), + "role": ( + chapter.role + ), + "target": ( + chapter.program.label + ), + "cold_interventions": ( + cold.interventions + ), + "persistent_interventions": ( + persistent.interventions + ), + "intervention_gain": ( + cold.interventions + - persistent.interventions + ), + "cold_total_steps": ( + cold.total_steps + ), + "persistent_total_steps": ( + persistent.total_steps + ), + "step_gain": ( + cold.total_steps + - persistent.total_steps + ), + "certificate_size": ( + persistent.certificate_size + ), + "priority_count": ( + len(priorities) + ), + "target_in_priority": ( + target_prior + ), + "exact_memory_hit": ( + target_prior + and seen_before + ), + "schema_or_generalized_hit": ( + target_prior + and not seen_before + ), + "attempted_priority_count": len( + persistent.attempted_priority_ids + ), + "falsified_priority_count": len( + persistent.falsified_priority_ids + ), + "cold_goal": ( + cold.goal_reached + ), + "persistent_goal": ( + persistent.goal_reached + ), + } + ) + + report = { + "experiment": ( + "prime-m24-causal-program-development" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "chapter_count": ( + len(rows) + ), + "cold_goal_count": sum( + row[ + "cold_goal" + ] + for row in rows + ), + "persistent_goal_count": sum( + row[ + "persistent_goal" + ] + for row in rows + ), + "mean_intervention_gain": ( + sum( + row[ + "intervention_gain" + ] + for row in rows + ) + / len(rows) + ), + "mean_step_gain": ( + sum( + row[ + "step_gain" + ] + for row in rows + ) + / len(rows) + ), + "positive_intervention_transfer": sum( + row[ + "intervention_gain" + ] > 0 + for row in rows + ), + "tied_intervention_transfer": sum( + row[ + "intervention_gain" + ] == 0 + for row in rows + ), + "negative_intervention_transfer": sum( + row[ + "intervention_gain" + ] < 0 + for row in rows + ), + "exact_memory_hits": sum( + row[ + "exact_memory_hit" + ] + for row in rows + ), + "schema_or_generalized_hits": sum( + row[ + "schema_or_generalized_hit" + ] + for row in rows + ), + "causal_memory_size": len( + brain.causal_program_memory.entries + ), + "causal_schema_count": len( + brain.causal_program_memory.schemas() + ), + "causal_schemas": [ + { + "operator": ( + schema.operator.value + ), + "offsets": list( + schema.normalized_offsets + ), + "support": ( + schema.support + ), + } + for schema + in brain.causal_program_memory.schemas() + ], + "cold_authority_chain_valid": ( + cold_ledger.verify_chain() + ), + "persistent_authority_chain_valid": ( + persistent_ledger.verify_chain() + ), + "episodic_chain_valid": ( + brain.episodic_memory.verify_chain() + ), + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m24_causal_program_world/episode.py b/experiments/prime_m24_causal_program_world/episode.py new file mode 100644 index 0000000..4b99798 --- /dev/null +++ b/experiments/prime_m24_causal_program_world/episode.py @@ -0,0 +1,210 @@ +"""Causal-program discovery -> authority -> planning.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition.causal_certificate import ( + CausalAuthorityLedger, + CausalAuthorization, + minimal_certificate, +) +from core.cognition.causal_program import ( + CONFIGURATIONS, + CausalProgram, + program_lookup, +) + +from .lab import ( + ProgramLab, +) +from .scientist import ( + CausalProgramScientist, +) + + +@dataclass(frozen=True) +class ProgramEpisodeResult: + target_program_id: str + target_label: str + priority_count: int + target_was_priority: bool + certificate_size: int + interventions: int + discovery_steps: int + total_steps: int + attempted_priority_ids: tuple[ + str, + ..., + ] + falsified_priority_ids: tuple[ + str, + ..., + ] + goal_reached: bool + authorization: ( + CausalAuthorization + ) + + +def run_program_episode( + target: CausalProgram, + *, + priority_program_ids=(), + authority_ledger=None, +) -> ProgramEpisodeResult: + ledger = ( + authority_ledger + if authority_ledger is not None + else CausalAuthorityLedger() + ) + + scientist = ( + CausalProgramScientist( + priority_program_ids=( + priority_program_ids + ) + ) + ) + + lab = ProgramLab( + target + ) + + while ( + scientist.identified_program_id + is None + ): + configuration = ( + scientist.choose_intervention() + ) + + outcome = ( + lab.intervene( + configuration + ) + ) + + scientist.observe( + configuration, + outcome, + ) + + identified = ( + scientist.identified_program_id + ) + + if ( + identified + != target.program_id + ): + raise RuntimeError( + "causal scientist identified wrong program" + ) + + authorization = ( + ledger.authorize( + identified, + scientist.observations, + ) + ) + + if not authorization.verdict: + raise RuntimeError( + "causal authority rejected unique program" + ) + + discovery_steps = ( + lab.state.steps + ) + + verified = ( + program_lookup()[ + authorization.program_id + ] + ) + + opening = [ + configuration + for configuration + in CONFIGURATIONS + if verified.evaluate( + configuration + ) + ] + + ranked = [] + + for configuration in opening: + cost = lab.cost_to_goal( + configuration + ) + + if cost is not None: + ranked.append( + ( + cost, + configuration, + ) + ) + + if not ranked: + raise RuntimeError( + "verified program yields no reachable opening" + ) + + ranked.sort() + + _, selected = ( + ranked[0] + ) + + lab.set_configuration( + selected + ) + + lab.walk_to( + lab.layout.goal + ) + + return ProgramEpisodeResult( + target_program_id=( + target.program_id + ), + target_label=( + target.label + ), + priority_count=len( + priority_program_ids + ), + target_was_priority=( + target.program_id + in priority_program_ids + ), + certificate_size=len( + minimal_certificate( + target.program_id + ) + ), + interventions=len( + scientist.observations + ), + discovery_steps=( + discovery_steps + ), + total_steps=( + lab.state.steps + ), + attempted_priority_ids=tuple( + scientist.attempted_priority_ids + ), + falsified_priority_ids=tuple( + scientist.falsified_priority_ids + ), + goal_reached=( + lab.state.goal_reached + ), + authorization=( + authorization + ), + ) diff --git a/experiments/prime_m24_causal_program_world/lab.py b/experiments/prime_m24_causal_program_world/lab.py new file mode 100644 index 0000000..9bd1bb3 --- /dev/null +++ b/experiments/prime_m24_causal_program_world/lab.py @@ -0,0 +1,389 @@ +"""Spatial causal-program laboratory for PRIME M24.""" + +from __future__ import annotations + +from collections import deque +from dataclasses import dataclass + +from core.cognition.causal_program import ( + CONFIGURATIONS, + CausalProgram, +) + + +@dataclass(frozen=True) +class ProgramLabLayout: + width: int = 9 + height: int = 7 + + start: tuple[int, int] = ( + 0, + 3, + ) + + switches: tuple[ + tuple[int, int], + ..., + ] = ( + (1, 1), + (1, 2), + (1, 4), + (1, 5), + ) + + sensor: tuple[int, int] = ( + 3, + 3, + ) + + door: tuple[int, int] = ( + 5, + 3, + ) + + goal: tuple[int, int] = ( + 8, + 3, + ) + + +@dataclass +class ProgramLabState: + position: tuple[int, int] + switches: list[int] + steps: int = 0 + goal_reached: bool = False + + +class ProgramLab: + def __init__( + self, + program: CausalProgram, + ) -> None: + self.program = program + + self.layout = ( + ProgramLabLayout() + ) + + self.state = ( + ProgramLabState( + position=( + self.layout.start + ), + switches=[ + 0, + 0, + 0, + 0, + ], + ) + ) + + @property + def configuration( + self, + ) -> tuple[int, ...]: + return tuple( + self.state.switches + ) + + @property + def door_open(self) -> bool: + return bool( + self.program.evaluate( + self.configuration + ) + ) + + def clone(self): + other = ProgramLab( + self.program + ) + + other.state.position = ( + self.state.position + ) + + other.state.switches = list( + self.state.switches + ) + + other.state.steps = ( + self.state.steps + ) + + other.state.goal_reached = ( + self.state.goal_reached + ) + + return other + + def _inside( + self, + position, + ) -> bool: + x, y = position + + return ( + 0 <= x + < self.layout.width + and 0 <= y + < self.layout.height + ) + + def _passable( + self, + position, + ) -> bool: + if not self._inside( + position + ): + return False + + x, _ = position + + if ( + x == self.layout.door[0] + and position + != self.layout.door + ): + return False + + if ( + position + == self.layout.door + and not self.door_open + ): + return False + + return True + + def shortest_path( + self, + start, + target, + ): + if start == target: + return () + + moves = ( + (1, 0), + (-1, 0), + (0, 1), + (0, -1), + ) + + queue = deque( + [ + ( + start, + (), + ) + ] + ) + + seen = { + start + } + + while queue: + position, path = ( + queue.popleft() + ) + + for move in moves: + nxt = ( + position[0] + + move[0], + position[1] + + move[1], + ) + + if nxt in seen: + continue + + if not self._passable( + nxt + ): + continue + + new_path = ( + path + + ( + move, + ) + ) + + if nxt == target: + return new_path + + seen.add( + nxt + ) + + queue.append( + ( + nxt, + new_path, + ) + ) + + return None + + def walk_to( + self, + target, + ) -> None: + path = self.shortest_path( + self.state.position, + target, + ) + + if path is None: + raise RuntimeError( + "target unreachable" + ) + + for dx, dy in path: + target_position = ( + self.state.position[0] + + dx, + self.state.position[1] + + dy, + ) + + self.state.steps += 1 + + if not self._passable( + target_position + ): + raise RuntimeError( + "planned movement invalid" + ) + + self.state.position = ( + target_position + ) + + if ( + target_position + == self.layout.goal + ): + self.state.goal_reached = ( + True + ) + + def toggle( + self, + index: int, + ) -> None: + self.walk_to( + self.layout.switches[ + index + ] + ) + + self.state.steps += 1 + + self.state.switches[ + index + ] ^= 1 + + def set_configuration( + self, + configuration, + ) -> None: + for index, desired in ( + enumerate( + configuration + ) + ): + if ( + self.state.switches[ + index + ] + != desired + ): + self.toggle( + index + ) + + def probe( + self, + ) -> int: + self.walk_to( + self.layout.sensor + ) + + self.state.steps += 1 + + return int( + self.door_open + ) + + def intervene( + self, + configuration, + ) -> int: + self.set_configuration( + configuration + ) + + return self.probe() + + def cost_to_probe( + self, + configuration, + ) -> int: + """Primitive action cost of running an intervention now.""" + + clone = self.clone() + + start_steps = ( + clone.state.steps + ) + + clone.set_configuration( + configuration + ) + + clone.probe() + + return ( + clone.state.steps + - start_steps + ) + + def cost_to_goal( + self, + configuration, + ) -> int | None: + if configuration not in ( + CONFIGURATIONS + ): + return None + + if not self.program.evaluate( + configuration + ): + return None + + clone = self.clone() + + start_steps = ( + clone.state.steps + ) + + clone.set_configuration( + configuration + ) + + clone.walk_to( + clone.layout.goal + ) + + return ( + clone.state.steps + - start_steps + ) diff --git a/experiments/prime_m24_causal_program_world/scientist.py b/experiments/prime_m24_causal_program_world/scientist.py new file mode 100644 index 0000000..3a4a110 --- /dev/null +++ b/experiments/prime_m24_causal_program_world/scientist.py @@ -0,0 +1,245 @@ +"""Active causal-program scientist for PRIME M24.""" + +from __future__ import annotations + +from core.cognition.causal_certificate import ( + compatible_program_ids, + minimal_certificate, +) +from core.cognition.causal_program import ( + CONFIGURATIONS, + program_lookup, +) + + +class CausalProgramScientist: + def __init__( + self, + *, + priority_program_ids=(), + ) -> None: + self.priority_program_ids = tuple( + priority_program_ids + ) + + self.observations = {} + + self.survivors = set( + program_lookup() + ) + + self.attempted_priority_ids = [] + self.falsified_priority_ids = [] + + @property + def identified_program_id( + self, + ): + if len( + self.survivors + ) != 1: + return None + + return next( + iter( + self.survivors + ) + ) + + def _active_priority( + self, + ): + for program_id in ( + self.priority_program_ids + ): + if program_id not in ( + self.survivors + ): + continue + + if program_id not in ( + self.attempted_priority_ids + ): + self.attempted_priority_ids.append( + program_id + ) + + return program_id + + return None + + def _targeted_configuration( + self, + program_id, + ): + lookup = ( + program_lookup() + ) + + target = lookup[ + program_id + ] + + certificate = ( + minimal_certificate( + program_id + ) + ) + + available = [ + configuration + for configuration + in certificate + if configuration + not in self.observations + ] + + if not available: + return None + + def score( + configuration, + ): + prediction = ( + target.evaluate( + configuration + ) + ) + + separated = sum( + lookup[ + other_id + ].evaluate( + configuration + ) + != prediction + for other_id + in self.survivors + if ( + other_id + != program_id + ) + ) + + return ( + -separated, + configuration, + ) + + return min( + available, + key=score, + ) + + def _cold_configuration( + self, + ): + lookup = ( + program_lookup() + ) + + available = [ + configuration + for configuration + in CONFIGURATIONS + if configuration + not in self.observations + ] + + if not available: + raise RuntimeError( + "all interventions exhausted" + ) + + def score( + configuration, + ): + zero = 0 + one = 0 + + for program_id in ( + self.survivors + ): + value = ( + lookup[ + program_id + ].evaluate( + configuration + ) + ) + + if value: + one += 1 + else: + zero += 1 + + disagreement_pairs = ( + zero + * one + ) + + return ( + -disagreement_pairs, + configuration, + ) + + return min( + available, + key=score, + ) + + def choose_intervention( + self, + ): + priority = ( + self._active_priority() + ) + + if priority is not None: + configuration = ( + self._targeted_configuration( + priority + ) + ) + + if configuration is not None: + return configuration + + return ( + self._cold_configuration() + ) + + def observe( + self, + configuration, + outcome, + ) -> None: + self.observations[ + configuration + ] = int( + outcome + ) + + self.survivors = set( + compatible_program_ids( + self.observations + ) + ) + + if not self.survivors: + raise RuntimeError( + "M24 causal program universe falsified" + ) + + for program_id in ( + self.attempted_priority_ids + ): + if ( + program_id + not in self.survivors + and program_id + not in self.falsified_priority_ids + ): + self.falsified_priority_ids.append( + program_id + ) diff --git a/experiments/prime_m25_epistemic_control/__init__.py b/experiments/prime_m25_epistemic_control/__init__.py new file mode 100644 index 0000000..f78ba39 --- /dev/null +++ b/experiments/prime_m25_epistemic_control/__init__.py @@ -0,0 +1 @@ +"""PRIME M25 epistemic control.""" diff --git a/experiments/prime_m25_epistemic_control/development.py b/experiments/prime_m25_epistemic_control/development.py new file mode 100644 index 0000000..368165d --- /dev/null +++ b/experiments/prime_m25_epistemic_control/development.py @@ -0,0 +1,578 @@ +"""128-chapter lifelong causal epistemic-control experiment.""" + +from __future__ import annotations + +import json + +from core.cognition import ( + MegaPrimeCognition, +) +from core.cognition.causal_certificate import ( + CausalAuthorityLedger, +) +from core.cognition.causal_ecology import ( + build_causal_mass_field, +) +from core.cognition.causal_program import ( + program_universe, +) + +from .episode import ( + run_epistemic_episode, +) + + +MASK64 = ( + (1 << 64) + - 1 +) + + +def splitmix64( + value: int, +) -> int: + z = ( + value + + 0x9E3779B97F4A7C15 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 30) + ) + * 0xBF58476D1CE4E5B9 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 27) + ) + * 0x94D049BB133111EB + ) & MASK64 + + return ( + z + ^ (z >> 31) + ) & MASK64 + + +def curriculum(): + universe = list( + program_universe() + ) + + # Deterministic permutation. + universe.sort( + key=lambda program: ( + splitmix64( + int( + program.program_id[ + 3:19 + ], + 16, + ) + ^ 0x4D32354341555345 + ) + ) + ) + + rows = [] + + # Phase 1: + # broad but incomplete foundation. + for index in range(24): + rows.append( + ( + "foundation", + universe[index], + ) + ) + + # Phase 2: + # alternate old and previously unseen structure. + unseen = ( + universe[ + 24: + ] + ) + + for index in range(40): + if index % 2 == 0: + selector = ( + splitmix64( + 0x4D32355048415345 + ^ index + ) + % 24 + ) + + program = ( + universe[ + selector + ] + ) + + phase = ( + "reuse-and-transfer" + ) + + else: + selector = ( + (index // 2) + % len( + unseen + ) + ) + + program = ( + unseen[ + selector + ] + ) + + phase = ( + "novel-after-development" + ) + + rows.append( + ( + phase, + program, + ) + ) + + # Phase 3: + # mature mixed lifetime. + for index in range(64): + selector = ( + splitmix64( + 0x4D32354D41545552 + ^ index + ) + % len( + universe + ) + ) + + rows.append( + ( + "mature-mixed", + universe[ + selector + ], + ) + ) + + if len(rows) != 128: + raise RuntimeError( + "M25 curriculum size changed" + ) + + return tuple( + rows + ) + + +def mean( + values, +): + values = list( + values + ) + + if not values: + return None + + return ( + sum(values) + / len(values) + ) + + +def main(): + brain = ( + MegaPrimeCognition() + ) + + cold_authority = ( + CausalAuthorityLedger() + ) + + persistent_authority = ( + CausalAuthorityLedger() + ) + + cold_field = ( + build_causal_mass_field( + None + ) + ) + + rows = [] + + seen = set() + + for index, ( + phase, + target, + ) in enumerate( + curriculum() + ): + cold = ( + run_epistemic_episode( + target, + mass_field=( + cold_field + ), + authority_ledger=( + cold_authority + ), + ) + ) + + memory = ( + brain.causal_program_memory + ) + + exact_seen = ( + target.program_id + in memory.entries + ) + + persistent_field = ( + build_causal_mass_field( + memory + ) + ) + + target_schema_biased = ( + not exact_seen + and persistent_field.mass( + target.program_id + ) + > persistent_field.base_mass + ) + + persistent = ( + run_epistemic_episode( + target, + mass_field=( + persistent_field + ), + authority_ledger=( + persistent_authority + ), + ) + ) + + intervention_gain = ( + cold.interventions + - persistent.interventions + ) + + step_gain = ( + cold.total_steps + - persistent.total_steps + ) + + # Meta-memory feedback applies only to exact reuse. + if exact_seen: + if intervention_gain > 0: + memory.record_reuse( + target.program_id, + success=True, + ) + + elif intervention_gain < 0: + memory.record_reuse( + target.program_id, + success=False, + ) + + memory.ingest( + persistent.authorization + ) + + seen.add( + target.program_id + ) + + brain.episodic_memory.append( + context_id=( + "m25-" + + str(index) + ), + context_tokens=( + "m25-lifelong-causal-world", + phase, + ), + verified_construction_ids=( + target.program_id, + ), + reward_ppm=max( + 0, + ( + 1_000_000 + - 5_000 + * persistent.total_steps + ), + ), + studies=tuple( + str( + row[ + "configuration" + ] + ) + for row + in persistent.study_trace + ), + ) + + rows.append( + { + "index": index, + "phase": phase, + "target": ( + target.label + ), + "exact_seen_before": ( + exact_seen + ), + "schema_biased_novel": ( + target_schema_biased + ), + "cold_interventions": ( + cold.interventions + ), + "persistent_interventions": ( + persistent.interventions + ), + "intervention_gain": ( + intervention_gain + ), + "cold_steps": ( + cold.total_steps + ), + "persistent_steps": ( + persistent.total_steps + ), + "step_gain": ( + step_gain + ), + "target_prior_mass": ( + persistent.target_initial_mass + ), + "target_prior_rank": ( + persistent.target_initial_rank + ), + "prior_bonus_mass": ( + persistent.prior_bonus_mass + ), + "cold_goal": ( + cold.goal_reached + ), + "persistent_goal": ( + persistent.goal_reached + ), + } + ) + + phases = {} + + for phase in sorted( + { + row["phase"] + for row in rows + } + ): + subset = [ + row + for row in rows + if row[ + "phase" + ] == phase + ] + + phases[ + phase + ] = { + "count": len( + subset + ), + "mean_intervention_gain": mean( + row[ + "intervention_gain" + ] + for row in subset + ), + "mean_step_gain": mean( + row[ + "step_gain" + ] + for row in subset + ), + "positive": sum( + row[ + "intervention_gain" + ] > 0 + for row in subset + ), + "ties": sum( + row[ + "intervention_gain" + ] == 0 + for row in subset + ), + "negative": sum( + row[ + "intervention_gain" + ] < 0 + for row in subset + ), + } + + thirds = [] + + for start in ( + 0, + 42, + 85, + ): + end = ( + 42 + if start == 0 + else ( + 85 + if start == 42 + else 128 + ) + ) + + subset = ( + rows[ + start:end + ] + ) + + thirds.append( + { + "start": start, + "end": end, + "mean_intervention_gain": mean( + row[ + "intervention_gain" + ] + for row in subset + ), + "mean_step_gain": mean( + row[ + "step_gain" + ] + for row in subset + ), + } + ) + + report = { + "experiment": ( + "prime-m25-lifelong-epistemic-control" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "chapter_count": len( + rows + ), + "cold_goal_count": sum( + row[ + "cold_goal" + ] + for row in rows + ), + "persistent_goal_count": sum( + row[ + "persistent_goal" + ] + for row in rows + ), + "mean_intervention_gain": mean( + row[ + "intervention_gain" + ] + for row in rows + ), + "mean_step_gain": mean( + row[ + "step_gain" + ] + for row in rows + ), + "positive": sum( + row[ + "intervention_gain" + ] > 0 + for row in rows + ), + "ties": sum( + row[ + "intervention_gain" + ] == 0 + for row in rows + ), + "negative": sum( + row[ + "intervention_gain" + ] < 0 + for row in rows + ), + "exact_reuse_chapters": sum( + row[ + "exact_seen_before" + ] + for row in rows + ), + "schema_biased_novel_chapters": sum( + row[ + "schema_biased_novel" + ] + for row in rows + ), + "causal_memory_size": len( + brain.causal_program_memory.entries + ), + "causal_schema_count": len( + brain.causal_program_memory.schemas() + ), + "cold_authority_chain_valid": ( + cold_authority.verify_chain() + ), + "persistent_authority_chain_valid": ( + persistent_authority.verify_chain() + ), + "episodic_chain_valid": ( + brain.episodic_memory.verify_chain() + ), + "phase_summaries": ( + phases + ), + "developmental_thirds": ( + thirds + ), + "rows": ( + rows + ), + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m25_epistemic_control/episode.py b/experiments/prime_m25_epistemic_control/episode.py new file mode 100644 index 0000000..0a0b3d2 --- /dev/null +++ b/experiments/prime_m25_epistemic_control/episode.py @@ -0,0 +1,240 @@ +"""Epistemic-control causal episode for PRIME M25.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.cognition.causal_certificate import ( + CausalAuthorityLedger, +) +from core.cognition.causal_ecology import ( + CausalMassField, +) +from core.cognition.causal_program import ( + CONFIGURATIONS, + CausalProgram, + program_lookup, +) + +from experiments.prime_m24_causal_program_world.lab import ( + ProgramLab, +) + +from .scientist import ( + EcologicalCausalScientist, +) + + +@dataclass(frozen=True) +class EpistemicEpisodeResult: + target_program_id: str + target_label: str + interventions: int + discovery_steps: int + total_steps: int + target_initial_mass: int + target_initial_rank: int + prior_bonus_mass: int + goal_reached: bool + receipt_hash: str + authorization: object + study_trace: tuple[dict, ...] + + +def run_epistemic_episode( + target: CausalProgram, + *, + mass_field: CausalMassField, + authority_ledger: ( + CausalAuthorityLedger + | None + ) = None, +) -> EpistemicEpisodeResult: + ledger = ( + authority_ledger + if authority_ledger is not None + else CausalAuthorityLedger() + ) + + lab = ProgramLab( + target + ) + + scientist = ( + EcologicalCausalScientist( + mass_field=( + mass_field + ) + ) + ) + + while ( + scientist.identified_program_id + is None + ): + configuration = ( + scientist.choose_intervention( + intervention_cost=( + lab.cost_to_probe + ) + ) + ) + + outcome = ( + lab.intervene( + configuration + ) + ) + + scientist.observe( + configuration, + outcome, + ) + + identified = ( + scientist.identified_program_id + ) + + if ( + identified + != target.program_id + ): + raise RuntimeError( + "wrong causal program identified" + ) + + authorization = ( + ledger.authorize( + identified, + scientist.observations, + ) + ) + + if not authorization.verdict: + raise RuntimeError( + "causal authority rejected singleton identification" + ) + + discovery_steps = ( + lab.state.steps + ) + + verified = ( + program_lookup()[ + identified + ] + ) + + openings = [ + configuration + for configuration + in CONFIGURATIONS + if verified.evaluate( + configuration + ) + ] + + goal_options = [] + + for configuration in openings: + cost = ( + lab.cost_to_goal( + configuration + ) + ) + + if cost is not None: + goal_options.append( + ( + cost, + configuration, + ) + ) + + if not goal_options: + raise RuntimeError( + "no reachable verified goal plan" + ) + + goal_options.sort() + + _, selected = ( + goal_options[0] + ) + + lab.set_configuration( + selected + ) + + lab.walk_to( + lab.layout.goal + ) + + trace = tuple( + { + "configuration": list( + study.configuration + ), + "primitive_cost": ( + study.primitive_cost + ), + "zero_mass": ( + study.zero_mass + ), + "one_mass": ( + study.one_mass + ), + "zero_count": ( + study.zero_count + ), + "one_count": ( + study.one_count + ), + } + for study in ( + scientist.study_trace + ) + ) + + return EpistemicEpisodeResult( + target_program_id=( + target.program_id + ), + target_label=( + target.label + ), + interventions=len( + scientist.observations + ), + discovery_steps=( + discovery_steps + ), + total_steps=( + lab.state.steps + ), + target_initial_mass=( + mass_field.mass( + target.program_id + ) + ), + target_initial_rank=( + mass_field.rank( + target.program_id + ) + ), + prior_bonus_mass=( + mass_field.bonus_mass + ), + goal_reached=( + lab.state.goal_reached + ), + receipt_hash=( + authorization.receipt_hash + ), + authorization=( + authorization + ), + study_trace=( + trace + ), + ) diff --git a/experiments/prime_m25_epistemic_control/scientist.py b/experiments/prime_m25_epistemic_control/scientist.py new file mode 100644 index 0000000..1f235e5 --- /dev/null +++ b/experiments/prime_m25_epistemic_control/scientist.py @@ -0,0 +1,109 @@ +"""Global weighted active causal scientist for PRIME M25.""" + +from __future__ import annotations + +from core.cognition.causal_certificate import ( + compatible_program_ids, +) +from core.cognition.causal_ecology import ( + CausalMassField, + WeightedCausalStudySelector, +) +from core.cognition.causal_program import ( + program_lookup, +) + + +class EcologicalCausalScientist: + def __init__( + self, + *, + mass_field: CausalMassField, + ) -> None: + self.mass_field = ( + mass_field + ) + + self.observations: dict[ + tuple[int, ...], + int, + ] = {} + + self.survivors = set( + program_lookup() + ) + + self.selector = ( + WeightedCausalStudySelector() + ) + + self.study_trace = [] + + @property + def identified_program_id( + self, + ) -> str | None: + if len( + self.survivors + ) != 1: + return None + + return next( + iter( + self.survivors + ) + ) + + def choose_intervention( + self, + *, + intervention_cost, + ): + study = ( + self.selector.choose( + surviving_program_ids=( + self.survivors + ), + observations=( + self.observations + ), + mass_field=( + self.mass_field + ), + intervention_cost=( + intervention_cost + ), + ) + ) + + self.study_trace.append( + study + ) + + return study.configuration + + def observe( + self, + configuration, + outcome, + ) -> None: + self.observations[ + configuration + ] = int( + outcome + ) + + compatible = set( + compatible_program_ids( + self.observations + ) + ) + + self.survivors &= ( + compatible + ) + + if not self.survivors: + raise RuntimeError( + "causal program universe falsified" + ) diff --git a/experiments/prime_m26_comparative_cognition/__init__.py b/experiments/prime_m26_comparative_cognition/__init__.py new file mode 100644 index 0000000..f6fe9dd --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/__init__.py @@ -0,0 +1 @@ +"""PRIME M26 comparative cognition arena.""" diff --git a/experiments/prime_m26_comparative_cognition/development.py b/experiments/prime_m26_comparative_cognition/development.py new file mode 100644 index 0000000..be38892 --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/development.py @@ -0,0 +1,301 @@ +"""Development analysis for PRIME M26 comparative cognition.""" + +from __future__ import annotations + +import json + +from .runner import ( + CONDITIONS, + DEVELOPMENT_SEEDS, + run_world, +) +from .tasks import ( + tasks, +) + + +def mean_floor( + values, +): + values = list(values) + + if not values: + return None + + return ( + sum(values) + // len(values) + ) + + +def main(): + rows = [] + + for task in tasks(): + for seed in DEVELOPMENT_SEEDS: + for condition in CONDITIONS: + rows.append( + run_world( + task, + seed, + condition, + ).payload + ) + + by_condition = {} + + for condition in CONDITIONS: + subset = [ + row + for row in rows + if row["condition"] + == condition + ] + + by_condition[ + condition + ] = { + "world_count": ( + len(subset) + ), + "mean_aulc_ppm": ( + mean_floor( + row["aulc_ppm"] + for row in subset + ) + ), + "mean_accuracy_ppm": ( + mean_floor( + row["accuracy_ppm"] + for row in subset + ) + ), + "mean_final_accuracy_ppm": ( + mean_floor( + row[ + "final_accuracy_ppm" + ] + for row in subset + ) + ), + "mean_mistakes": ( + mean_floor( + row["mistakes"] + for row in subset + ) + ), + } + + families = sorted( + { + task.family + for task in tasks() + } + ) + + by_family = {} + + for family in families: + by_family[family] = {} + + for condition in CONDITIONS: + subset = [ + row + for row in rows + if ( + row["family"] + == family + and row["condition"] + == condition + ) + ] + + by_family[ + family + ][ + condition + ] = { + "aulc_ppm": ( + mean_floor( + row["aulc_ppm"] + for row in subset + ) + ), + "final_accuracy_ppm": ( + mean_floor( + row[ + "final_accuracy_ppm" + ] + for row in subset + ) + ), + } + + by_task = [] + + for task in tasks(): + output = { + "task": task.name, + "family": task.family, + } + + for condition in CONDITIONS: + subset = [ + candidate + for candidate in rows + if ( + candidate["task"] + == task.name + and candidate[ + "condition" + ] + == condition + ) + ] + + output[ + condition + ] = { + "aulc_ppm": ( + mean_floor( + candidate[ + "aulc_ppm" + ] + for candidate + in subset + ) + ), + "final_accuracy_ppm": ( + mean_floor( + candidate[ + "final_accuracy_ppm" + ] + for candidate + in subset + ) + ), + } + + prime_rows = [ + candidate + for candidate in rows + if ( + candidate["task"] + == task.name + and candidate[ + "condition" + ] + == "PRIME" + ) + ] + + recoveries = [ + candidate[ + "prime_explicit_recovery" + ] + for candidate + in prime_rows + if candidate[ + "prime_explicit_recovery" + ] + is not None + ] + + output[ + "prime_explicit_recovery" + ] = ( + None + if not recoveries + else ( + f"{sum(recoveries)}/" + f"{len(recoveries)}" + ) + ) + + output[ + "prime_mean_first_authorization" + ] = mean_floor( + candidate[ + "prime_first_authorization" + ] + for candidate + in prime_rows + if candidate[ + "prime_first_authorization" + ] + is not None + ) + + by_task.append( + output + ) + + prime_integrity = all( + row["prime_receipts_valid"] + for row in rows + if row["condition"] + == "PRIME" + ) + + gru_rows = [ + row + for row in rows + if row["condition"] + == "GRU32" + ] + + report = { + "benchmark": ( + "prime-m26-comparative-cognition-v0.1" + ), + "status": ( + "DEVELOPMENT_ONLY" + ), + "task_count": ( + len(tasks()) + ), + "development_seed_count": ( + len( + DEVELOPMENT_SEEDS + ) + ), + "worlds_per_condition": ( + len(tasks()) + * len( + DEVELOPMENT_SEEDS + ) + ), + "row_count": ( + len(rows) + ), + "condition_summaries": ( + by_condition + ), + "family_summaries": ( + by_family + ), + "task_summaries": ( + by_task + ), + "prime_receipt_integrity": ( + prime_integrity + ), + "gru_parameter_count": ( + gru_rows[0][ + "gru_parameter_count" + ] + ), + "rows": rows, + } + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/experiments/prime_m26_comparative_cognition/gru_agent.py b/experiments/prime_m26_comparative_cognition/gru_agent.py new file mode 100644 index 0000000..a787290 --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/gru_agent.py @@ -0,0 +1,220 @@ +"""Deterministic online GRU baseline for PRIME M26.""" + +from __future__ import annotations + +import torch +from torch import nn + + +class GRUOnlinePredictor: + def __init__( + self, + *, + seed: int, + hidden_size: int = 32, + learning_rate: float = 0.01, + chunk_length: int = 32, + ) -> None: + torch.set_num_threads(1) + + torch.manual_seed(seed) + + try: + torch.use_deterministic_algorithms( + True + ) + except Exception: + pass + + self.hidden_size = hidden_size + + self.cell = nn.GRUCell( + input_size=1, + hidden_size=hidden_size, + ) + + self.output = nn.Linear( + hidden_size, + 1, + ) + + self.parameters = ( + list( + self.cell.parameters() + ) + + list( + self.output.parameters() + ) + ) + + self.optimizer = torch.optim.Adam( + self.parameters, + lr=learning_rate, + ) + + self.loss_function = ( + nn.BCEWithLogitsLoss() + ) + + self.hidden = torch.zeros( + 1, + hidden_size, + ) + + self.chunk_length = ( + chunk_length + ) + + self.chunk_h0 = None + self.chunk_x = [] + self.chunk_y = [] + + self.last_loss = None + + @property + def parameter_count( + self, + ) -> int: + return sum( + parameter.numel() + for parameter + in self.parameters + ) + + def predict( + self, + observation: int, + ) -> int: + if not self.chunk_x: + self.chunk_h0 = ( + self.hidden + .detach() + .clone() + ) + + x = torch.tensor( + [[ + float( + observation + ) + ]], + dtype=torch.float32, + ) + + with torch.no_grad(): + self.hidden = ( + self.cell( + x, + self.hidden, + ) + ) + + logit = ( + self.output( + self.hidden + ) + ) + + self.chunk_x.append( + float( + observation + ) + ) + + return int( + logit.item() + >= 0.0 + ) + + def learn( + self, + target: int, + ) -> None: + self.chunk_y.append( + float( + target + ) + ) + + if ( + len( + self.chunk_y + ) + >= self.chunk_length + ): + self._train_chunk() + + def _train_chunk( + self, + ) -> None: + if not self.chunk_y: + return + + if self.chunk_h0 is None: + raise RuntimeError( + "missing GRU chunk initial state" + ) + + self.optimizer.zero_grad( + set_to_none=True + ) + + hidden = ( + self.chunk_h0 + ) + + logits = [] + + for observation in self.chunk_x: + x = torch.tensor( + [[observation]], + dtype=torch.float32, + ) + + hidden = self.cell( + x, + hidden, + ) + + logits.append( + self.output( + hidden + ) + ) + + logit_tensor = ( + torch.cat( + logits, + dim=0, + ) + .reshape(-1) + ) + + target_tensor = torch.tensor( + self.chunk_y, + dtype=torch.float32, + ) + + loss = ( + self.loss_function( + logit_tensor, + target_tensor, + ) + ) + + loss.backward() + + torch.nn.utils.clip_grad_norm_( + self.parameters, + max_norm=1.0, + ) + + self.optimizer.step() + + self.last_loss = float( + loss.detach().item() + ) + + self.chunk_x = [] + self.chunk_y = [] + self.chunk_h0 = None diff --git a/experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.json b/experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.json new file mode 100644 index 0000000..c66ab4c --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.json @@ -0,0 +1,6657 @@ +{ + "benchmark": "prime-m26-comparative-cognition-v0.1", + "condition_summaries": { + "GRU32": { + "mean_accuracy_ppm": 605070, + "mean_aulc_ppm": 575721, + "mean_final_accuracy_ppm": 628688, + "mean_mistakes": 606, + "world_count": 108 + }, + "H16": { + "mean_accuracy_ppm": 503761, + "mean_aulc_ppm": 502811, + "mean_final_accuracy_ppm": 511248, + "mean_mistakes": 762, + "world_count": 108 + }, + "H8": { + "mean_accuracy_ppm": 729322, + "mean_aulc_ppm": 670708, + "mean_final_accuracy_ppm": 769675, + "mean_mistakes": 415, + "world_count": 108 + }, + "PRIME": { + "mean_accuracy_ppm": 803951, + "mean_aulc_ppm": 776370, + "mean_final_accuracy_ppm": 808955, + "mean_mistakes": 301, + "world_count": 108 + }, + "REACTIVE": { + "mean_accuracy_ppm": 580813, + "mean_aulc_ppm": 579852, + "mean_final_accuracy_ppm": 583079, + "mean_mistakes": 643, + "world_count": 108 + } + }, + "development_seed_count": 6, + "family_summaries": { + "explicit-relational": { + "GRU32": { + "aulc_ppm": 619531, + "final_accuracy_ppm": 711262 + }, + "H16": { + "aulc_ppm": 502376, + "final_accuracy_ppm": 523274 + }, + "H8": { + "aulc_ppm": 797423, + "final_accuracy_ppm": 998616 + }, + "PRIME": { + "aulc_ppm": 921795, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 625532, + "final_accuracy_ppm": 618407 + } + }, + "nonstationary": { + "GRU32": { + "aulc_ppm": 506934, + "final_accuracy_ppm": 744791 + }, + "H16": { + "aulc_ppm": 496167, + "final_accuracy_ppm": 498697 + }, + "H8": { + "aulc_ppm": 702210, + "final_accuracy_ppm": 541666 + }, + "PRIME": { + "aulc_ppm": 794830, + "final_accuracy_ppm": 449218 + }, + "REACTIVE": { + "aulc_ppm": 537026, + "final_accuracy_ppm": 744791 + } + }, + "recurrent-state": { + "GRU32": { + "aulc_ppm": 572031, + "final_accuracy_ppm": 575683 + }, + "H16": { + "aulc_ppm": 500092, + "final_accuracy_ppm": 497558 + }, + "H8": { + "aulc_ppm": 588187, + "final_accuracy_ppm": 648600 + }, + "PRIME": { + "aulc_ppm": 586761, + "final_accuracy_ppm": 624185 + }, + "REACTIVE": { + "aulc_ppm": 558848, + "final_accuracy_ppm": 555012 + } + }, + "scaling": { + "GRU32": { + "aulc_ppm": 522335, + "final_accuracy_ppm": 515754 + }, + "H16": { + "aulc_ppm": 507010, + "final_accuracy_ppm": 505468 + }, + "H8": { + "aulc_ppm": 527682, + "final_accuracy_ppm": 545832 + }, + "PRIME": { + "aulc_ppm": 691686, + "final_accuracy_ppm": 723046 + }, + "REACTIVE": { + "aulc_ppm": 532133, + "final_accuracy_ppm": 516666 + } + } + }, + "gru_parameter_count": 3393, + "prime_receipt_integrity": true, + "row_count": 540, + "rows": [ + { + "accuracy_ppm": 999348, + "aulc_ppm": 995497, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "seed": 26000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 920572, + "aulc_ppm": 820699, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 122, + "seed": 26000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 500000, + "aulc_ppm": 518936, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 531250, + "mistakes": 768, + "seed": 26000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 926432, + "aulc_ppm": 789090, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.05511694401502609, + "gru_parameter_count": 3393, + "mistakes": 113, + "seed": 26000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 995497, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26000, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 994846, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "seed": 26001, + "task": "CURRENT" + }, + { + "accuracy_ppm": 912760, + "aulc_ppm": 791853, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 134, + "seed": 26001, + "task": "CURRENT" + }, + { + "accuracy_ppm": 519531, + "aulc_ppm": 513260, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "mistakes": 738, + "seed": 26001, + "task": "CURRENT" + }, + { + "accuracy_ppm": 875651, + "aulc_ppm": 724693, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.06507036089897156, + "gru_parameter_count": 3393, + "mistakes": 191, + "seed": 26001, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 994846, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26001, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 994846, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "seed": 26002, + "task": "CURRENT" + }, + { + "accuracy_ppm": 919270, + "aulc_ppm": 815119, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 124, + "seed": 26002, + "task": "CURRENT" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 492410, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 519531, + "mistakes": 775, + "seed": 26002, + "task": "CURRENT" + }, + { + "accuracy_ppm": 903645, + "aulc_ppm": 778911, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.05293895676732063, + "gru_parameter_count": 3393, + "mistakes": 148, + "seed": 26002, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 994846, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26002, + "task": "CURRENT" + }, + { + "accuracy_ppm": 998697, + "aulc_ppm": 991050, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 2, + "seed": 26003, + "task": "CURRENT" + }, + { + "accuracy_ppm": 919270, + "aulc_ppm": 800413, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 124, + "seed": 26003, + "task": "CURRENT" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 500263, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 445312, + "mistakes": 782, + "seed": 26003, + "task": "CURRENT" + }, + { + "accuracy_ppm": 947265, + "aulc_ppm": 832038, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.07344500720500946, + "gru_parameter_count": 3393, + "mistakes": 81, + "seed": 26003, + "task": "CURRENT" + }, + { + "accuracy_ppm": 998697, + "aulc_ppm": 991050, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 2, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26003, + "task": "CURRENT" + }, + { + "accuracy_ppm": 998697, + "aulc_ppm": 990345, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 2, + "seed": 26004, + "task": "CURRENT" + }, + { + "accuracy_ppm": 917317, + "aulc_ppm": 788598, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 127, + "seed": 26004, + "task": "CURRENT" + }, + { + "accuracy_ppm": 487630, + "aulc_ppm": 474901, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 787, + "seed": 26004, + "task": "CURRENT" + }, + { + "accuracy_ppm": 923177, + "aulc_ppm": 796704, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.05317782610654831, + "gru_parameter_count": 3393, + "mistakes": 118, + "seed": 26004, + "task": "CURRENT" + }, + { + "accuracy_ppm": 998697, + "aulc_ppm": 990345, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 2, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26004, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 994846, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "seed": 26005, + "task": "CURRENT" + }, + { + "accuracy_ppm": 910807, + "aulc_ppm": 787242, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 137, + "seed": 26005, + "task": "CURRENT" + }, + { + "accuracy_ppm": 490234, + "aulc_ppm": 486398, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 535156, + "mistakes": 783, + "seed": 26005, + "task": "CURRENT" + }, + { + "accuracy_ppm": 944010, + "aulc_ppm": 826053, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.06108067184686661, + "gru_parameter_count": 3393, + "mistakes": 86, + "seed": 26005, + "task": "CURRENT" + }, + { + "accuracy_ppm": 999348, + "aulc_ppm": 994846, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 1, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26005, + "task": "CURRENT" + }, + { + "accuracy_ppm": 493489, + "aulc_ppm": 497565, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 519531, + "mistakes": 778, + "seed": 26000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 917968, + "aulc_ppm": 804998, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 126, + "seed": 26000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 520833, + "aulc_ppm": 518322, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 550781, + "mistakes": 736, + "seed": 26000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 850260, + "aulc_ppm": 678344, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.008030925877392292, + "gru_parameter_count": 3393, + "mistakes": 230, + "seed": 26000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 981119, + "aulc_ppm": 921879, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 29, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 62, + "prime_receipts_valid": true, + "seed": 26000, + "task": "LAG-1" + }, + { + "accuracy_ppm": 489583, + "aulc_ppm": 489502, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 496093, + "mistakes": 784, + "seed": 26001, + "task": "LAG-1" + }, + { + "accuracy_ppm": 920572, + "aulc_ppm": 807453, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 122, + "seed": 26001, + "task": "LAG-1" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 515477, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 492187, + "mistakes": 756, + "seed": 26001, + "task": "LAG-1" + }, + { + "accuracy_ppm": 805989, + "aulc_ppm": 635193, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.00790573749691248, + "gru_parameter_count": 3393, + "mistakes": 298, + "seed": 26001, + "task": "LAG-1" + }, + { + "accuracy_ppm": 977864, + "aulc_ppm": 907379, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 34, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 63, + "prime_receipts_valid": true, + "seed": 26001, + "task": "LAG-1" + }, + { + "accuracy_ppm": 475260, + "aulc_ppm": 482629, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 496093, + "mistakes": 806, + "seed": 26002, + "task": "LAG-1" + }, + { + "accuracy_ppm": 920572, + "aulc_ppm": 796669, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 122, + "seed": 26002, + "task": "LAG-1" + }, + { + "accuracy_ppm": 513020, + "aulc_ppm": 509156, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 748, + "seed": 26002, + "task": "LAG-1" + }, + { + "accuracy_ppm": 854817, + "aulc_ppm": 709944, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.0035449452698230743, + "gru_parameter_count": 3393, + "mistakes": 223, + "seed": 26002, + "task": "LAG-1" + }, + { + "accuracy_ppm": 978515, + "aulc_ppm": 911701, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 33, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 70, + "prime_receipts_valid": true, + "seed": 26002, + "task": "LAG-1" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 497571, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 531250, + "mistakes": 756, + "seed": 26003, + "task": "LAG-1" + }, + { + "accuracy_ppm": 911458, + "aulc_ppm": 785241, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 136, + "seed": 26003, + "task": "LAG-1" + }, + { + "accuracy_ppm": 494791, + "aulc_ppm": 482267, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 484375, + "mistakes": 776, + "seed": 26003, + "task": "LAG-1" + }, + { + "accuracy_ppm": 843098, + "aulc_ppm": 660170, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.009472605772316456, + "gru_parameter_count": 3393, + "mistakes": 241, + "seed": 26003, + "task": "LAG-1" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 910720, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 60, + "prime_receipts_valid": true, + "seed": 26003, + "task": "LAG-1" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 518979, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 756, + "seed": 26004, + "task": "LAG-1" + }, + { + "accuracy_ppm": 914713, + "aulc_ppm": 797113, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 131, + "seed": 26004, + "task": "LAG-1" + }, + { + "accuracy_ppm": 505859, + "aulc_ppm": 499381, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 531250, + "mistakes": 759, + "seed": 26004, + "task": "LAG-1" + }, + { + "accuracy_ppm": 837239, + "aulc_ppm": 658353, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.011074711568653584, + "gru_parameter_count": 3393, + "mistakes": 250, + "seed": 26004, + "task": "LAG-1" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 906486, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 65, + "prime_receipts_valid": true, + "seed": 26004, + "task": "LAG-1" + }, + { + "accuracy_ppm": 502604, + "aulc_ppm": 497521, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 764, + "seed": 26005, + "task": "LAG-1" + }, + { + "accuracy_ppm": 915364, + "aulc_ppm": 803837, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 130, + "seed": 26005, + "task": "LAG-1" + }, + { + "accuracy_ppm": 514973, + "aulc_ppm": 512498, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 539062, + "mistakes": 745, + "seed": 26005, + "task": "LAG-1" + }, + { + "accuracy_ppm": 859375, + "aulc_ppm": 698961, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "gru_last_loss": 0.005418999120593071, + "gru_parameter_count": 3393, + "mistakes": 216, + "seed": 26005, + "task": "LAG-1" + }, + { + "accuracy_ppm": 978515, + "aulc_ppm": 909917, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 33, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 68, + "prime_receipts_valid": true, + "seed": 26005, + "task": "LAG-1" + }, + { + "accuracy_ppm": 524739, + "aulc_ppm": 540187, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "mistakes": 730, + "seed": 26000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 918619, + "aulc_ppm": 810898, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 125, + "seed": 26000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 509114, + "aulc_ppm": 502040, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 554687, + "mistakes": 754, + "seed": 26000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 630208, + "aulc_ppm": 577917, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 687500, + "gru_last_loss": 0.6391139030456543, + "gru_parameter_count": 3393, + "mistakes": 568, + "seed": 26000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 979166, + "aulc_ppm": 917621, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 32, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 53, + "prime_receipts_valid": true, + "seed": 26000, + "task": "LAG-4" + }, + { + "accuracy_ppm": 508463, + "aulc_ppm": 522388, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "mistakes": 755, + "seed": 26001, + "task": "LAG-4" + }, + { + "accuracy_ppm": 916666, + "aulc_ppm": 785159, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 128, + "seed": 26001, + "task": "LAG-4" + }, + { + "accuracy_ppm": 511718, + "aulc_ppm": 505871, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 550781, + "mistakes": 750, + "seed": 26001, + "task": "LAG-4" + }, + { + "accuracy_ppm": 559895, + "aulc_ppm": 492472, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 664062, + "gru_last_loss": 0.6412868499755859, + "gru_parameter_count": 3393, + "mistakes": 676, + "seed": 26001, + "task": "LAG-4" + }, + { + "accuracy_ppm": 978515, + "aulc_ppm": 915497, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 33, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 81, + "prime_receipts_valid": true, + "seed": 26001, + "task": "LAG-4" + }, + { + "accuracy_ppm": 511067, + "aulc_ppm": 522316, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 523437, + "mistakes": 751, + "seed": 26002, + "task": "LAG-4" + }, + { + "accuracy_ppm": 919270, + "aulc_ppm": 803708, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 124, + "seed": 26002, + "task": "LAG-4" + }, + { + "accuracy_ppm": 530598, + "aulc_ppm": 517185, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 539062, + "mistakes": 721, + "seed": 26002, + "task": "LAG-4" + }, + { + "accuracy_ppm": 625000, + "aulc_ppm": 555369, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 753906, + "gru_last_loss": 0.5602039098739624, + "gru_parameter_count": 3393, + "mistakes": 576, + "seed": 26002, + "task": "LAG-4" + }, + { + "accuracy_ppm": 973958, + "aulc_ppm": 896219, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 40, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 66, + "prime_receipts_valid": true, + "seed": 26002, + "task": "LAG-4" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 503118, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "mistakes": 758, + "seed": 26003, + "task": "LAG-4" + }, + { + "accuracy_ppm": 919270, + "aulc_ppm": 816497, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 124, + "seed": 26003, + "task": "LAG-4" + }, + { + "accuracy_ppm": 513671, + "aulc_ppm": 513419, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 558593, + "mistakes": 747, + "seed": 26003, + "task": "LAG-4" + }, + { + "accuracy_ppm": 564453, + "aulc_ppm": 531455, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 628906, + "gru_last_loss": 0.6285144090652466, + "gru_parameter_count": 3393, + "mistakes": 669, + "seed": 26003, + "task": "LAG-4" + }, + { + "accuracy_ppm": 978515, + "aulc_ppm": 911625, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 33, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 53, + "prime_receipts_valid": true, + "seed": 26003, + "task": "LAG-4" + }, + { + "accuracy_ppm": 494791, + "aulc_ppm": 494480, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 503906, + "mistakes": 776, + "seed": 26004, + "task": "LAG-4" + }, + { + "accuracy_ppm": 920572, + "aulc_ppm": 821122, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 992187, + "mistakes": 122, + "seed": 26004, + "task": "LAG-4" + }, + { + "accuracy_ppm": 492838, + "aulc_ppm": 507264, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "mistakes": 779, + "seed": 26004, + "task": "LAG-4" + }, + { + "accuracy_ppm": 630859, + "aulc_ppm": 568199, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 703125, + "gru_last_loss": 0.579215943813324, + "gru_parameter_count": 3393, + "mistakes": 567, + "seed": 26004, + "task": "LAG-4" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 910568, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 63, + "prime_receipts_valid": true, + "seed": 26004, + "task": "LAG-4" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 503802, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 500000, + "mistakes": 772, + "seed": 26005, + "task": "LAG-4" + }, + { + "accuracy_ppm": 908854, + "aulc_ppm": 788956, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 140, + "seed": 26005, + "task": "LAG-4" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 481624, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "mistakes": 772, + "seed": 26005, + "task": "LAG-4" + }, + { + "accuracy_ppm": 628906, + "aulc_ppm": 583362, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 707031, + "gru_last_loss": 0.5030885934829712, + "gru_parameter_count": 3393, + "mistakes": 570, + "seed": 26005, + "task": "LAG-4" + }, + { + "accuracy_ppm": 974609, + "aulc_ppm": 902535, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 39, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 83, + "prime_receipts_valid": true, + "seed": 26005, + "task": "LAG-4" + }, + { + "accuracy_ppm": 515625, + "aulc_ppm": 509312, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 539062, + "mistakes": 744, + "seed": 26000, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 914062, + "aulc_ppm": 803342, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 132, + "seed": 26000, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 505859, + "aulc_ppm": 516469, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 542968, + "mistakes": 759, + "seed": 26000, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 512369, + "aulc_ppm": 527038, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "gru_last_loss": 0.6851980686187744, + "gru_parameter_count": 3393, + "mistakes": 749, + "seed": 26000, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 979166, + "aulc_ppm": 913465, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 32, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 67, + "prime_receipts_valid": true, + "seed": 26000, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 489583, + "aulc_ppm": 509417, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 457031, + "mistakes": 784, + "seed": 26001, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 919270, + "aulc_ppm": 809221, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 124, + "seed": 26001, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 510416, + "aulc_ppm": 518925, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 554687, + "mistakes": 752, + "seed": 26001, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 479817, + "aulc_ppm": 480086, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 480468, + "gru_last_loss": 0.6945158839225769, + "gru_parameter_count": 3393, + "mistakes": 799, + "seed": 26001, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 976562, + "aulc_ppm": 910021, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 36, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 72, + "prime_receipts_valid": true, + "seed": 26001, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 494791, + "aulc_ppm": 498370, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 492187, + "mistakes": 776, + "seed": 26002, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 901041, + "aulc_ppm": 772499, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 152, + "seed": 26002, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 481119, + "aulc_ppm": 458123, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 542968, + "mistakes": 797, + "seed": 26002, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 502966, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 523437, + "gru_last_loss": 0.6763046979904175, + "gru_parameter_count": 3393, + "mistakes": 763, + "seed": 26002, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 972656, + "aulc_ppm": 892118, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 42, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 70, + "prime_receipts_valid": true, + "seed": 26002, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 491536, + "aulc_ppm": 501457, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 503906, + "mistakes": 781, + "seed": 26003, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 910807, + "aulc_ppm": 793850, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 137, + "seed": 26003, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 484356, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 542968, + "mistakes": 760, + "seed": 26003, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 505788, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6832906007766724, + "gru_parameter_count": 3393, + "mistakes": 756, + "seed": 26003, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 975260, + "aulc_ppm": 903215, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 38, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 70, + "prime_receipts_valid": true, + "seed": 26003, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 511399, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 496093, + "mistakes": 756, + "seed": 26004, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 917317, + "aulc_ppm": 803018, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 127, + "seed": 26004, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 511067, + "aulc_ppm": 508141, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 531250, + "mistakes": 751, + "seed": 26004, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 511718, + "aulc_ppm": 520751, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 539062, + "gru_last_loss": 0.6816064715385437, + "gru_parameter_count": 3393, + "mistakes": 750, + "seed": 26004, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 977864, + "aulc_ppm": 906166, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 34, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 52, + "prime_receipts_valid": true, + "seed": 26004, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 480030, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 464843, + "mistakes": 782, + "seed": 26005, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 914062, + "aulc_ppm": 804755, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 132, + "seed": 26005, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 522135, + "aulc_ppm": 520646, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 589843, + "mistakes": 734, + "seed": 26005, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 492886, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 511718, + "gru_last_loss": 0.6935739517211914, + "gru_parameter_count": 3393, + "mistakes": 780, + "seed": 26005, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 977864, + "aulc_ppm": 905238, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 34, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 53, + "prime_receipts_valid": true, + "seed": 26005, + "task": "XOR-1-4" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 502064, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 460937, + "mistakes": 763, + "seed": 26000, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 915364, + "aulc_ppm": 789869, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 130, + "seed": 26000, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 478946, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 496093, + "mistakes": 769, + "seed": 26000, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 500651, + "aulc_ppm": 483270, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 562500, + "gru_last_loss": 0.6931259036064148, + "gru_parameter_count": 3393, + "mistakes": 767, + "seed": 26000, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 975260, + "aulc_ppm": 895169, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 38, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 54, + "prime_receipts_valid": true, + "seed": 26000, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 512162, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 445312, + "mistakes": 775, + "seed": 26001, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 915364, + "aulc_ppm": 801469, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 130, + "seed": 26001, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 509114, + "aulc_ppm": 505745, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 476562, + "mistakes": 754, + "seed": 26001, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 495572, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 441406, + "gru_last_loss": 0.6999094486236572, + "gru_parameter_count": 3393, + "mistakes": 782, + "seed": 26001, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 908775, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 67, + "prime_receipts_valid": true, + "seed": 26001, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 511146, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 468750, + "mistakes": 773, + "seed": 26002, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 910156, + "aulc_ppm": 784508, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 138, + "seed": 26002, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 486687, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "mistakes": 763, + "seed": 26002, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 509765, + "aulc_ppm": 511729, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 523437, + "gru_last_loss": 0.6934194564819336, + "gru_parameter_count": 3393, + "mistakes": 753, + "seed": 26002, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 909507, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 64, + "prime_receipts_valid": true, + "seed": 26002, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 493489, + "aulc_ppm": 500698, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 535156, + "mistakes": 778, + "seed": 26003, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 917317, + "aulc_ppm": 789649, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 127, + "seed": 26003, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 537109, + "aulc_ppm": 513600, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 554687, + "mistakes": 711, + "seed": 26003, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 498697, + "aulc_ppm": 514631, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 546875, + "gru_last_loss": 0.6919170618057251, + "gru_parameter_count": 3393, + "mistakes": 770, + "seed": 26003, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 979166, + "aulc_ppm": 917874, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 32, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 62, + "prime_receipts_valid": true, + "seed": 26003, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 510458, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 445312, + "mistakes": 774, + "seed": 26004, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 911458, + "aulc_ppm": 776454, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 136, + "seed": 26004, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 494140, + "aulc_ppm": 479768, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "mistakes": 777, + "seed": 26004, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 505859, + "aulc_ppm": 491422, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "gru_last_loss": 0.7154170274734497, + "gru_parameter_count": 3393, + "mistakes": 759, + "seed": 26004, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 975911, + "aulc_ppm": 906382, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 37, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 67, + "prime_receipts_valid": true, + "seed": 26004, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 489583, + "aulc_ppm": 493397, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 503906, + "mistakes": 784, + "seed": 26005, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 910807, + "aulc_ppm": 799868, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 137, + "seed": 26005, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 511718, + "aulc_ppm": 517744, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 535156, + "mistakes": 750, + "seed": 26005, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 503132, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 527343, + "gru_last_loss": 0.7101403474807739, + "gru_parameter_count": 3393, + "mistakes": 760, + "seed": 26005, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 976562, + "aulc_ppm": 906990, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 36, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 59, + "prime_receipts_valid": true, + "seed": 26005, + "task": "EQ-1-4" + }, + { + "accuracy_ppm": 774088, + "aulc_ppm": 807239, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 750000, + "mistakes": 347, + "seed": 26000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 919270, + "aulc_ppm": 820507, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 124, + "seed": 26000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 498697, + "aulc_ppm": 513354, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 476562, + "mistakes": 770, + "seed": 26000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 774088, + "aulc_ppm": 807239, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 750000, + "gru_last_loss": 0.5428681373596191, + "gru_parameter_count": 3393, + "mistakes": 347, + "seed": 26000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 979166, + "aulc_ppm": 943682, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 32, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 201, + "prime_receipts_valid": true, + "seed": 26000, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 748697, + "aulc_ppm": 730742, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 679687, + "mistakes": 386, + "seed": 26001, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 907552, + "aulc_ppm": 786948, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 142, + "seed": 26001, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 493459, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 546875, + "mistakes": 758, + "seed": 26001, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 762369, + "aulc_ppm": 745488, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 746093, + "gru_last_loss": 0.3778325915336609, + "gru_parameter_count": 3393, + "mistakes": 365, + "seed": 26001, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 976562, + "aulc_ppm": 908169, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 36, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 71, + "prime_receipts_valid": true, + "seed": 26001, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 747395, + "aulc_ppm": 723159, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 812500, + "mistakes": 388, + "seed": 26002, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 917317, + "aulc_ppm": 802452, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 127, + "seed": 26002, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 492838, + "aulc_ppm": 515411, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 500000, + "mistakes": 779, + "seed": 26002, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 742187, + "aulc_ppm": 698994, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 812500, + "gru_last_loss": 0.21734493970870972, + "gru_parameter_count": 3393, + "mistakes": 396, + "seed": 26002, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 979817, + "aulc_ppm": 926280, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 31, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 100, + "prime_receipts_valid": true, + "seed": 26002, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 724609, + "aulc_ppm": 735793, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 742187, + "mistakes": 423, + "seed": 26003, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 908203, + "aulc_ppm": 785359, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 988281, + "mistakes": 141, + "seed": 26003, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 513020, + "aulc_ppm": 512985, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 550781, + "mistakes": 748, + "seed": 26003, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 701171, + "aulc_ppm": 635309, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 742187, + "gru_last_loss": 0.3800061345100403, + "gru_parameter_count": 3393, + "mistakes": 459, + "seed": 26003, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 978515, + "aulc_ppm": 930562, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 33, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 140, + "prime_receipts_valid": true, + "seed": 26003, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 738281, + "aulc_ppm": 730544, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 742187, + "mistakes": 402, + "seed": 26004, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 907552, + "aulc_ppm": 784140, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 142, + "seed": 26004, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 488281, + "aulc_ppm": 479113, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 468750, + "mistakes": 786, + "seed": 26004, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 745442, + "aulc_ppm": 735243, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 781250, + "gru_last_loss": 0.5731300115585327, + "gru_parameter_count": 3393, + "mistakes": 391, + "seed": 26004, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 977864, + "aulc_ppm": 926548, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 34, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 122, + "prime_receipts_valid": true, + "seed": 26004, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 751953, + "aulc_ppm": 775647, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 707031, + "mistakes": 381, + "seed": 26005, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 920572, + "aulc_ppm": 794645, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 122, + "seed": 26005, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 510416, + "aulc_ppm": 507589, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 523437, + "mistakes": 752, + "seed": 26005, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 738932, + "aulc_ppm": 703199, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 718750, + "gru_last_loss": 0.536264181137085, + "gru_parameter_count": 3393, + "mistakes": 401, + "seed": 26005, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 975260, + "aulc_ppm": 922534, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 38, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 155, + "prime_receipts_valid": true, + "seed": 26005, + "task": "AND-1-4" + }, + { + "accuracy_ppm": 748046, + "aulc_ppm": 718359, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 746093, + "mistakes": 387, + "seed": 26000, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 915364, + "aulc_ppm": 805304, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 130, + "seed": 26000, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 524739, + "aulc_ppm": 520178, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 535156, + "mistakes": 730, + "seed": 26000, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 736979, + "aulc_ppm": 679856, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 746093, + "gru_last_loss": 0.4597169756889343, + "gru_parameter_count": 3393, + "mistakes": 404, + "seed": 26000, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 977864, + "aulc_ppm": 915211, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 34, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 75, + "prime_receipts_valid": true, + "seed": 26000, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 733723, + "aulc_ppm": 743678, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 703125, + "mistakes": 409, + "seed": 26001, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 923828, + "aulc_ppm": 834299, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 117, + "seed": 26001, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 514322, + "aulc_ppm": 528943, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 523437, + "mistakes": 746, + "seed": 26001, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 705078, + "aulc_ppm": 638932, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 703125, + "gru_last_loss": 0.5785590410232544, + "gru_parameter_count": 3393, + "mistakes": 453, + "seed": 26001, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 975911, + "aulc_ppm": 913921, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 37, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 104, + "prime_receipts_valid": true, + "seed": 26001, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 746744, + "aulc_ppm": 716486, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 804687, + "mistakes": 389, + "seed": 26002, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 916666, + "aulc_ppm": 805089, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 988281, + "mistakes": 128, + "seed": 26002, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 520833, + "aulc_ppm": 519986, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 550781, + "mistakes": 736, + "seed": 26002, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 748046, + "aulc_ppm": 720827, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 804687, + "gru_last_loss": 0.44849705696105957, + "gru_parameter_count": 3393, + "mistakes": 387, + "seed": 26002, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 975911, + "aulc_ppm": 910015, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 37, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 96, + "prime_receipts_valid": true, + "seed": 26002, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 715494, + "aulc_ppm": 731358, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 648437, + "mistakes": 437, + "seed": 26003, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 914713, + "aulc_ppm": 806418, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 131, + "seed": 26003, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 494791, + "aulc_ppm": 503077, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 492187, + "mistakes": 776, + "seed": 26003, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 707031, + "aulc_ppm": 692488, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 648437, + "gru_last_loss": 0.5625674724578857, + "gru_parameter_count": 3393, + "mistakes": 450, + "seed": 26003, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 978515, + "aulc_ppm": 920712, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 33, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 87, + "prime_receipts_valid": true, + "seed": 26003, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 748046, + "aulc_ppm": 751278, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 722656, + "mistakes": 387, + "seed": 26004, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 905598, + "aulc_ppm": 775619, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 145, + "seed": 26004, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 516927, + "aulc_ppm": 498062, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 582031, + "mistakes": 742, + "seed": 26004, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 742838, + "aulc_ppm": 730550, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 722656, + "gru_last_loss": 0.7321702241897583, + "gru_parameter_count": 3393, + "mistakes": 395, + "seed": 26004, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 975911, + "aulc_ppm": 913451, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 37, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 118, + "prime_receipts_valid": true, + "seed": 26004, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 750000, + "aulc_ppm": 743276, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 734375, + "mistakes": 384, + "seed": 26005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 910156, + "aulc_ppm": 771877, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 138, + "seed": 26005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 484062, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 766, + "seed": 26005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 753255, + "aulc_ppm": 755460, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 734375, + "gru_last_loss": 0.5739125609397888, + "gru_parameter_count": 3393, + "mistakes": 379, + "seed": 26005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 914034, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 110, + "prime_receipts_valid": true, + "seed": 26005, + "task": "OR-2-7" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 526112, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 484375, + "mistakes": 758, + "seed": 26000, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 916015, + "aulc_ppm": 792079, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 129, + "seed": 26000, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 496463, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 554687, + "mistakes": 773, + "seed": 26000, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 509765, + "aulc_ppm": 542202, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 457031, + "gru_last_loss": 0.7020281553268433, + "gru_parameter_count": 3393, + "mistakes": 753, + "seed": 26000, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 977864, + "aulc_ppm": 912385, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 34, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 54, + "prime_receipts_valid": true, + "seed": 26000, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 512369, + "aulc_ppm": 533236, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 468750, + "mistakes": 749, + "seed": 26001, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 910807, + "aulc_ppm": 788150, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 137, + "seed": 26001, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 489350, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 546875, + "mistakes": 772, + "seed": 26001, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 512369, + "aulc_ppm": 528990, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 468750, + "gru_last_loss": 0.692335844039917, + "gru_parameter_count": 3393, + "mistakes": 749, + "seed": 26001, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 976562, + "aulc_ppm": 908795, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 36, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 76, + "prime_receipts_valid": true, + "seed": 26001, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 501953, + "aulc_ppm": 511857, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 765, + "seed": 26002, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 914713, + "aulc_ppm": 792073, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 131, + "seed": 26002, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 511343, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 464843, + "mistakes": 763, + "seed": 26002, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 513020, + "aulc_ppm": 520827, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6934974789619446, + "gru_parameter_count": 3393, + "mistakes": 748, + "seed": 26002, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 911131, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 67, + "prime_receipts_valid": true, + "seed": 26002, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 507049, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 542968, + "mistakes": 760, + "seed": 26003, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 914713, + "aulc_ppm": 791702, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 131, + "seed": 26003, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 502341, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 535156, + "mistakes": 773, + "seed": 26003, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 501953, + "aulc_ppm": 512140, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 457031, + "gru_last_loss": 0.6993427276611328, + "gru_parameter_count": 3393, + "mistakes": 765, + "seed": 26003, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 979817, + "aulc_ppm": 918164, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 31, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 62, + "prime_receipts_valid": true, + "seed": 26003, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 470703, + "aulc_ppm": 455799, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 496093, + "mistakes": 813, + "seed": 26004, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 914713, + "aulc_ppm": 779476, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 996093, + "mistakes": 131, + "seed": 26004, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 507161, + "aulc_ppm": 492880, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 500000, + "mistakes": 757, + "seed": 26004, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 485677, + "aulc_ppm": 479866, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6964246034622192, + "gru_parameter_count": 3393, + "mistakes": 790, + "seed": 26004, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 975911, + "aulc_ppm": 899730, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 37, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 54, + "prime_receipts_valid": true, + "seed": 26004, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 512557, + "condition": "REACTIVE", + "family": "explicit-relational", + "final_accuracy_ppm": 488281, + "mistakes": 772, + "seed": 26005, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 916015, + "aulc_ppm": 806136, + "condition": "H8", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 129, + "seed": 26005, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 505673, + "condition": "H16", + "family": "explicit-relational", + "final_accuracy_ppm": 503906, + "mistakes": 769, + "seed": 26005, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 487630, + "aulc_ppm": 483412, + "condition": "GRU32", + "family": "explicit-relational", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6921601891517639, + "gru_parameter_count": 3393, + "mistakes": 787, + "seed": 26005, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 973307, + "aulc_ppm": 892355, + "condition": "PRIME", + "family": "explicit-relational", + "final_accuracy_ppm": 1000000, + "mistakes": 41, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 66, + "prime_receipts_valid": true, + "seed": 26005, + "task": "XOR-1-2-3" + }, + { + "accuracy_ppm": 502604, + "aulc_ppm": 512413, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 492187, + "mistakes": 764, + "seed": 26000, + "task": "LAG-8" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 536805, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 464843, + "mistakes": 760, + "seed": 26000, + "task": "LAG-8" + }, + { + "accuracy_ppm": 530598, + "aulc_ppm": 556292, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 721, + "seed": 26000, + "task": "LAG-8" + }, + { + "accuracy_ppm": 500651, + "aulc_ppm": 490297, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.685104489326477, + "gru_parameter_count": 3393, + "mistakes": 767, + "seed": 26000, + "task": "LAG-8" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 914169, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 63, + "prime_receipts_valid": true, + "seed": 26000, + "task": "LAG-8" + }, + { + "accuracy_ppm": 512369, + "aulc_ppm": 516423, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 749, + "seed": 26001, + "task": "LAG-8" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 499058, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 527343, + "mistakes": 774, + "seed": 26001, + "task": "LAG-8" + }, + { + "accuracy_ppm": 513671, + "aulc_ppm": 524803, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 747, + "seed": 26001, + "task": "LAG-8" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 506542, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 496093, + "gru_last_loss": 0.6921662092208862, + "gru_parameter_count": 3393, + "mistakes": 760, + "seed": 26001, + "task": "LAG-8" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 908095, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 61, + "prime_receipts_valid": true, + "seed": 26001, + "task": "LAG-8" + }, + { + "accuracy_ppm": 504557, + "aulc_ppm": 495039, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 546875, + "mistakes": 761, + "seed": 26002, + "task": "LAG-8" + }, + { + "accuracy_ppm": 483723, + "aulc_ppm": 476497, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 793, + "seed": 26002, + "task": "LAG-8" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 483567, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 515625, + "mistakes": 766, + "seed": 26002, + "task": "LAG-8" + }, + { + "accuracy_ppm": 514322, + "aulc_ppm": 490306, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 523437, + "gru_last_loss": 0.6822715997695923, + "gru_parameter_count": 3393, + "mistakes": 746, + "seed": 26002, + "task": "LAG-8" + }, + { + "accuracy_ppm": 972656, + "aulc_ppm": 898626, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 42, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 68, + "prime_receipts_valid": true, + "seed": 26002, + "task": "LAG-8" + }, + { + "accuracy_ppm": 498046, + "aulc_ppm": 536715, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 464843, + "mistakes": 771, + "seed": 26003, + "task": "LAG-8" + }, + { + "accuracy_ppm": 500651, + "aulc_ppm": 510271, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 476562, + "mistakes": 767, + "seed": 26003, + "task": "LAG-8" + }, + { + "accuracy_ppm": 515625, + "aulc_ppm": 531738, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 744, + "seed": 26003, + "task": "LAG-8" + }, + { + "accuracy_ppm": 487630, + "aulc_ppm": 465023, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 476562, + "gru_last_loss": 0.69325852394104, + "gru_parameter_count": 3393, + "mistakes": 787, + "seed": 26003, + "task": "LAG-8" + }, + { + "accuracy_ppm": 973307, + "aulc_ppm": 909452, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 41, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 85, + "prime_receipts_valid": true, + "seed": 26003, + "task": "LAG-8" + }, + { + "accuracy_ppm": 522786, + "aulc_ppm": 513127, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 558593, + "mistakes": 733, + "seed": 26004, + "task": "LAG-8" + }, + { + "accuracy_ppm": 491536, + "aulc_ppm": 501840, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 468750, + "mistakes": 781, + "seed": 26004, + "task": "LAG-8" + }, + { + "accuracy_ppm": 475260, + "aulc_ppm": 490398, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 468750, + "mistakes": 806, + "seed": 26004, + "task": "LAG-8" + }, + { + "accuracy_ppm": 526041, + "aulc_ppm": 531162, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 531250, + "gru_last_loss": 0.6926778554916382, + "gru_parameter_count": 3393, + "mistakes": 728, + "seed": 26004, + "task": "LAG-8" + }, + { + "accuracy_ppm": 976562, + "aulc_ppm": 907514, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 36, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 54, + "prime_receipts_valid": true, + "seed": 26004, + "task": "LAG-8" + }, + { + "accuracy_ppm": 513020, + "aulc_ppm": 494673, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 527343, + "mistakes": 748, + "seed": 26005, + "task": "LAG-8" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 509904, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 488281, + "mistakes": 775, + "seed": 26005, + "task": "LAG-8" + }, + { + "accuracy_ppm": 486328, + "aulc_ppm": 480387, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 492187, + "mistakes": 789, + "seed": 26005, + "task": "LAG-8" + }, + { + "accuracy_ppm": 530598, + "aulc_ppm": 493376, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 585937, + "gru_last_loss": 0.6280818581581116, + "gru_parameter_count": 3393, + "mistakes": 721, + "seed": 26005, + "task": "LAG-8" + }, + { + "accuracy_ppm": 975911, + "aulc_ppm": 902383, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 37, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 59, + "prime_receipts_valid": true, + "seed": 26005, + "task": "LAG-8" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 530107, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 480468, + "mistakes": 766, + "seed": 26000, + "task": "LAG-16" + }, + { + "accuracy_ppm": 485026, + "aulc_ppm": 492237, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 791, + "seed": 26000, + "task": "LAG-16" + }, + { + "accuracy_ppm": 483072, + "aulc_ppm": 482356, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 794, + "seed": 26000, + "task": "LAG-16" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 530380, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 468750, + "gru_last_loss": 0.6947863101959229, + "gru_parameter_count": 3393, + "mistakes": 756, + "seed": 26000, + "task": "LAG-16" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 515054, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 500000, + "mistakes": 782, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 68, + "prime_receipts_valid": true, + "seed": 26000, + "task": "LAG-16" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 523057, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 488281, + "mistakes": 774, + "seed": 26001, + "task": "LAG-16" + }, + { + "accuracy_ppm": 513020, + "aulc_ppm": 505002, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 748, + "seed": 26001, + "task": "LAG-16" + }, + { + "accuracy_ppm": 517578, + "aulc_ppm": 479871, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 578125, + "mistakes": 741, + "seed": 26001, + "task": "LAG-16" + }, + { + "accuracy_ppm": 514973, + "aulc_ppm": 496808, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 503906, + "gru_last_loss": 0.7048527002334595, + "gru_parameter_count": 3393, + "mistakes": 745, + "seed": 26001, + "task": "LAG-16" + }, + { + "accuracy_ppm": 520182, + "aulc_ppm": 536767, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 737, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 78, + "prime_receipts_valid": true, + "seed": 26001, + "task": "LAG-16" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 537655, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 484375, + "mistakes": 756, + "seed": 26002, + "task": "LAG-16" + }, + { + "accuracy_ppm": 503906, + "aulc_ppm": 513260, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 762, + "seed": 26002, + "task": "LAG-16" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 504878, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 769, + "seed": 26002, + "task": "LAG-16" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 541449, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 453125, + "gru_last_loss": 0.7094453573226929, + "gru_parameter_count": 3393, + "mistakes": 766, + "seed": 26002, + "task": "LAG-16" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 529241, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 769, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 70, + "prime_receipts_valid": true, + "seed": 26002, + "task": "LAG-16" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 509786, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 484375, + "mistakes": 772, + "seed": 26003, + "task": "LAG-16" + }, + { + "accuracy_ppm": 520833, + "aulc_ppm": 493611, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 562500, + "mistakes": 736, + "seed": 26003, + "task": "LAG-16" + }, + { + "accuracy_ppm": 502604, + "aulc_ppm": 494714, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 511718, + "mistakes": 764, + "seed": 26003, + "task": "LAG-16" + }, + { + "accuracy_ppm": 509114, + "aulc_ppm": 526010, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 511718, + "gru_last_loss": 0.6996893286705017, + "gru_parameter_count": 3393, + "mistakes": 754, + "seed": 26003, + "task": "LAG-16" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 501035, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 780, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 73, + "prime_receipts_valid": true, + "seed": 26003, + "task": "LAG-16" + }, + { + "accuracy_ppm": 508463, + "aulc_ppm": 535621, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 539062, + "mistakes": 755, + "seed": 26004, + "task": "LAG-16" + }, + { + "accuracy_ppm": 503906, + "aulc_ppm": 491764, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 585937, + "mistakes": 762, + "seed": 26004, + "task": "LAG-16" + }, + { + "accuracy_ppm": 482421, + "aulc_ppm": 490942, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 507812, + "mistakes": 795, + "seed": 26004, + "task": "LAG-16" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 454252, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 496093, + "gru_last_loss": 0.6943430304527283, + "gru_parameter_count": 3393, + "mistakes": 782, + "seed": 26004, + "task": "LAG-16" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 516504, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 500000, + "mistakes": 775, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 71, + "prime_receipts_valid": true, + "seed": 26004, + "task": "LAG-16" + }, + { + "accuracy_ppm": 492838, + "aulc_ppm": 498234, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 492187, + "mistakes": 779, + "seed": 26005, + "task": "LAG-16" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 484703, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 507812, + "mistakes": 775, + "seed": 26005, + "task": "LAG-16" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 503124, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 488281, + "mistakes": 769, + "seed": 26005, + "task": "LAG-16" + }, + { + "accuracy_ppm": 485026, + "aulc_ppm": 511298, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 464843, + "gru_last_loss": 0.7062355279922485, + "gru_parameter_count": 3393, + "mistakes": 791, + "seed": 26005, + "task": "LAG-16" + }, + { + "accuracy_ppm": 477213, + "aulc_ppm": 475206, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 523437, + "mistakes": 803, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 70, + "prime_receipts_valid": true, + "seed": 26005, + "task": "LAG-16" + }, + { + "accuracy_ppm": 493489, + "aulc_ppm": 490146, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 550781, + "mistakes": 778, + "seed": 26000, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 515644, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 511718, + "mistakes": 772, + "seed": 26000, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 502604, + "aulc_ppm": 518511, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 492187, + "mistakes": 764, + "seed": 26000, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 504195, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 550781, + "gru_last_loss": 0.7009018063545227, + "gru_parameter_count": 3393, + "mistakes": 763, + "seed": 26000, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 977213, + "aulc_ppm": 912362, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 35, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 60, + "prime_receipts_valid": true, + "seed": 26000, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 511067, + "aulc_ppm": 513753, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 515625, + "mistakes": 751, + "seed": 26001, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 527343, + "aulc_ppm": 526543, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 511718, + "mistakes": 726, + "seed": 26001, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 521484, + "aulc_ppm": 515097, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 554687, + "mistakes": 735, + "seed": 26001, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 499134, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 496093, + "gru_last_loss": 0.6901646256446838, + "gru_parameter_count": 3393, + "mistakes": 773, + "seed": 26001, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 974609, + "aulc_ppm": 899277, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 39, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 57, + "prime_receipts_valid": true, + "seed": 26001, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 486979, + "aulc_ppm": 468089, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 788, + "seed": 26002, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 503906, + "aulc_ppm": 496413, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 472656, + "mistakes": 762, + "seed": 26002, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 520182, + "aulc_ppm": 500936, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 542968, + "mistakes": 737, + "seed": 26002, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 494791, + "aulc_ppm": 500559, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6993247866630554, + "gru_parameter_count": 3393, + "mistakes": 776, + "seed": 26002, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 973307, + "aulc_ppm": 886527, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 41, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 48, + "prime_receipts_valid": true, + "seed": 26002, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 505332, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 472656, + "mistakes": 763, + "seed": 26003, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 501953, + "aulc_ppm": 499366, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 484375, + "mistakes": 765, + "seed": 26003, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 514322, + "aulc_ppm": 502620, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 746, + "seed": 26003, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 498639, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 472656, + "gru_last_loss": 0.694564700126648, + "gru_parameter_count": 3393, + "mistakes": 760, + "seed": 26003, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 975260, + "aulc_ppm": 901465, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 38, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 57, + "prime_receipts_valid": true, + "seed": 26003, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 491536, + "aulc_ppm": 508239, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 468750, + "mistakes": 781, + "seed": 26004, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 485438, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 464843, + "mistakes": 780, + "seed": 26004, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 489475, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 488281, + "mistakes": 775, + "seed": 26004, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 509114, + "aulc_ppm": 512845, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 464843, + "gru_last_loss": 0.6953556537628174, + "gru_parameter_count": 3393, + "mistakes": 754, + "seed": 26004, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 976562, + "aulc_ppm": 908627, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 36, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 56, + "prime_receipts_valid": true, + "seed": 26004, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 497607, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 464843, + "mistakes": 772, + "seed": 26005, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 513671, + "aulc_ppm": 503969, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 519531, + "mistakes": 747, + "seed": 26005, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 518229, + "aulc_ppm": 518491, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 740, + "seed": 26005, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 520833, + "aulc_ppm": 532169, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 457031, + "gru_last_loss": 0.6996985673904419, + "gru_parameter_count": 3393, + "mistakes": 736, + "seed": 26005, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 974609, + "aulc_ppm": 893771, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 1000000, + "mistakes": 39, + "prime_active_constructions": 1, + "prime_explicit_recovery": true, + "prime_first_authorization": 57, + "prime_receipts_valid": true, + "seed": 26005, + "task": "XOR-1-8" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 512899, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 503906, + "mistakes": 763, + "seed": 26000, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 516927, + "aulc_ppm": 531221, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 511718, + "mistakes": 742, + "seed": 26000, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 506497, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 484375, + "mistakes": 780, + "seed": 26000, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 518229, + "aulc_ppm": 500620, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 542968, + "gru_last_loss": 0.6993910670280457, + "gru_parameter_count": 3393, + "mistakes": 740, + "seed": 26000, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 508463, + "aulc_ppm": 506832, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 542968, + "mistakes": 755, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 61, + "prime_receipts_valid": true, + "seed": 26000, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 489598, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 480468, + "mistakes": 766, + "seed": 26001, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 502390, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 769, + "seed": 26001, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 517578, + "aulc_ppm": 506826, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 558593, + "mistakes": 741, + "seed": 26001, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 505859, + "aulc_ppm": 514408, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 511718, + "gru_last_loss": 0.6880536079406738, + "gru_parameter_count": 3393, + "mistakes": 759, + "seed": 26001, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 504557, + "aulc_ppm": 517304, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 507812, + "mistakes": 761, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 55, + "prime_receipts_valid": true, + "seed": 26001, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 499732, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 464843, + "mistakes": 758, + "seed": 26002, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 485677, + "aulc_ppm": 463975, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 507812, + "mistakes": 790, + "seed": 26002, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 498046, + "aulc_ppm": 482738, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 771, + "seed": 26002, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 488281, + "aulc_ppm": 503470, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 515625, + "gru_last_loss": 0.6940688490867615, + "gru_parameter_count": 3393, + "mistakes": 786, + "seed": 26002, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 500307, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 457031, + "mistakes": 775, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 62, + "prime_receipts_valid": true, + "seed": 26002, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 512369, + "aulc_ppm": 502275, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 492187, + "mistakes": 749, + "seed": 26003, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 516276, + "aulc_ppm": 516158, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 554687, + "mistakes": 743, + "seed": 26003, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 513986, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 472656, + "mistakes": 782, + "seed": 26003, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 484707, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 550781, + "gru_last_loss": 0.708591103553772, + "gru_parameter_count": 3393, + "mistakes": 766, + "seed": 26003, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 493676, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 546875, + "mistakes": 758, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 54, + "prime_receipts_valid": true, + "seed": 26003, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 503906, + "aulc_ppm": 490201, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 762, + "seed": 26004, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 497395, + "aulc_ppm": 501375, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 449218, + "mistakes": 772, + "seed": 26004, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 502604, + "aulc_ppm": 495858, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 511718, + "mistakes": 764, + "seed": 26004, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 498046, + "aulc_ppm": 498877, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 492187, + "gru_last_loss": 0.6953794956207275, + "gru_parameter_count": 3393, + "mistakes": 771, + "seed": 26004, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 509114, + "aulc_ppm": 499080, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 531250, + "mistakes": 754, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 62, + "prime_receipts_valid": true, + "seed": 26004, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 518229, + "aulc_ppm": 515905, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 488281, + "mistakes": 740, + "seed": 26005, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 520182, + "aulc_ppm": 512499, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 515625, + "mistakes": 737, + "seed": 26005, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 499671, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 484375, + "mistakes": 763, + "seed": 26005, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 517578, + "aulc_ppm": 504487, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6913617253303528, + "gru_parameter_count": 3393, + "mistakes": 741, + "seed": 26005, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 524739, + "aulc_ppm": 526235, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 523437, + "mistakes": 730, + "prime_active_constructions": 5, + "prime_explicit_recovery": true, + "prime_first_authorization": 59, + "prime_receipts_valid": true, + "seed": 26005, + "task": "XOR-1-16" + }, + { + "accuracy_ppm": 690755, + "aulc_ppm": 657551, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 808593, + "mistakes": 475, + "seed": 26000, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 713541, + "aulc_ppm": 653446, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 843750, + "mistakes": 440, + "seed": 26000, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 538411, + "aulc_ppm": 540652, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 523437, + "mistakes": 709, + "seed": 26000, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 640625, + "aulc_ppm": 489120, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 808593, + "gru_last_loss": 0.45838749408721924, + "gru_parameter_count": 3393, + "mistakes": 552, + "seed": 26000, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 689453, + "aulc_ppm": 658859, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 808593, + "mistakes": 477, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 272, + "prime_receipts_valid": true, + "seed": 26000, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 602213, + "aulc_ppm": 600631, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 601562, + "mistakes": 611, + "seed": 26001, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 685546, + "aulc_ppm": 645667, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 734375, + "mistakes": 483, + "seed": 26001, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 514322, + "aulc_ppm": 539549, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 746, + "seed": 26001, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 569661, + "aulc_ppm": 548934, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 582031, + "gru_last_loss": 0.6950668096542358, + "gru_parameter_count": 3393, + "mistakes": 661, + "seed": 26001, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 605468, + "aulc_ppm": 604347, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 582031, + "mistakes": 606, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 442, + "prime_receipts_valid": true, + "seed": 26001, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 628906, + "aulc_ppm": 638083, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 382812, + "mistakes": 570, + "seed": 26002, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 676432, + "aulc_ppm": 616712, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 613281, + "mistakes": 497, + "seed": 26002, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 513020, + "aulc_ppm": 512047, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 472656, + "mistakes": 748, + "seed": 26002, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 635416, + "aulc_ppm": 624826, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 394531, + "gru_last_loss": 0.6658110022544861, + "gru_parameter_count": 3393, + "mistakes": 560, + "seed": 26002, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 628255, + "aulc_ppm": 637379, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 382812, + "mistakes": 571, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 423, + "prime_receipts_valid": true, + "seed": 26002, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 582031, + "aulc_ppm": 571039, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 585937, + "mistakes": 642, + "seed": 26003, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 651692, + "aulc_ppm": 598421, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 675781, + "mistakes": 535, + "seed": 26003, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 488233, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 480468, + "mistakes": 774, + "seed": 26003, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 555338, + "aulc_ppm": 609308, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 417968, + "gru_last_loss": 0.7081676721572876, + "gru_parameter_count": 3393, + "mistakes": 683, + "seed": 26003, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 600911, + "aulc_ppm": 577827, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 605468, + "mistakes": 613, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 686, + "prime_receipts_valid": true, + "seed": 26003, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 627604, + "aulc_ppm": 662580, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 542968, + "mistakes": 572, + "seed": 26004, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 643229, + "aulc_ppm": 610071, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 605468, + "mistakes": 548, + "seed": 26004, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 521484, + "aulc_ppm": 516350, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 496093, + "mistakes": 735, + "seed": 26004, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 632812, + "aulc_ppm": 663936, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 574218, + "gru_last_loss": 0.6851438879966736, + "gru_parameter_count": 3393, + "mistakes": 564, + "seed": 26004, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 625000, + "aulc_ppm": 660882, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 542968, + "mistakes": 576, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 723, + "prime_receipts_valid": true, + "seed": 26004, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 595052, + "aulc_ppm": 637509, + "condition": "REACTIVE", + "family": "scaling", + "final_accuracy_ppm": 550781, + "mistakes": 622, + "seed": 26005, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 696614, + "aulc_ppm": 636206, + "condition": "H8", + "family": "scaling", + "final_accuracy_ppm": 785156, + "mistakes": 466, + "seed": 26005, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 518229, + "aulc_ppm": 539694, + "condition": "H16", + "family": "scaling", + "final_accuracy_ppm": 445312, + "mistakes": 740, + "seed": 26005, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 606119, + "aulc_ppm": 642928, + "condition": "GRU32", + "family": "scaling", + "final_accuracy_ppm": 605468, + "gru_last_loss": 0.558176577091217, + "gru_parameter_count": 3393, + "mistakes": 605, + "seed": 26005, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 632812, + "aulc_ppm": 651787, + "condition": "PRIME", + "family": "scaling", + "final_accuracy_ppm": 632812, + "mistakes": 564, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 778, + "prime_receipts_valid": true, + "seed": 26005, + "task": "MAJORITY-16" + }, + { + "accuracy_ppm": 361328, + "aulc_ppm": 363746, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 359375, + "mistakes": 981, + "seed": 26000, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 507812, + "aulc_ppm": 483010, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 515625, + "mistakes": 756, + "seed": 26000, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 482421, + "aulc_ppm": 466261, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 527343, + "mistakes": 795, + "seed": 26000, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 495733, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 468750, + "gru_last_loss": 0.694440484046936, + "gru_parameter_count": 3393, + "mistakes": 773, + "seed": 26000, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 483108, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 449218, + "mistakes": 760, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 83, + "prime_receipts_valid": true, + "seed": 26000, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 385416, + "aulc_ppm": 399267, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 375000, + "mistakes": 944, + "seed": 26001, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 489583, + "aulc_ppm": 497453, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 468750, + "mistakes": 784, + "seed": 26001, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 509765, + "aulc_ppm": 515560, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 464843, + "mistakes": 753, + "seed": 26001, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 479166, + "aulc_ppm": 484459, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 425781, + "gru_last_loss": 0.6957749128341675, + "gru_parameter_count": 3393, + "mistakes": 800, + "seed": 26001, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 464192, + "aulc_ppm": 458992, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 429687, + "mistakes": 823, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 93, + "prime_receipts_valid": true, + "seed": 26001, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 382812, + "aulc_ppm": 384723, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 406250, + "mistakes": 948, + "seed": 26002, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 501953, + "aulc_ppm": 486122, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 539062, + "mistakes": 765, + "seed": 26002, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 498046, + "aulc_ppm": 482979, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 523437, + "mistakes": 771, + "seed": 26002, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 509813, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 480468, + "gru_last_loss": 0.6981302499771118, + "gru_parameter_count": 3393, + "mistakes": 773, + "seed": 26002, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 481360, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 535156, + "mistakes": 774, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 86, + "prime_receipts_valid": true, + "seed": 26002, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 376953, + "aulc_ppm": 386222, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 410156, + "mistakes": 957, + "seed": 26003, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 514322, + "aulc_ppm": 524714, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 562500, + "mistakes": 746, + "seed": 26003, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 491035, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 488281, + "mistakes": 775, + "seed": 26003, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 490234, + "aulc_ppm": 489591, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 437500, + "gru_last_loss": 0.7017059326171875, + "gru_parameter_count": 3393, + "mistakes": 783, + "seed": 26003, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 496744, + "aulc_ppm": 469111, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 535156, + "mistakes": 773, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 109, + "prime_receipts_valid": true, + "seed": 26003, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 397786, + "aulc_ppm": 387873, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 410156, + "mistakes": 925, + "seed": 26004, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 510416, + "aulc_ppm": 509265, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 500000, + "mistakes": 752, + "seed": 26004, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 509114, + "aulc_ppm": 508053, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 503906, + "mistakes": 754, + "seed": 26004, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 512369, + "aulc_ppm": 515479, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 507812, + "gru_last_loss": 0.6724830865859985, + "gru_parameter_count": 3393, + "mistakes": 749, + "seed": 26004, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 382812, + "aulc_ppm": 370020, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 367187, + "mistakes": 948, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 62, + "prime_receipts_valid": true, + "seed": 26004, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 390625, + "aulc_ppm": 401974, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 351562, + "mistakes": 936, + "seed": 26005, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 513671, + "aulc_ppm": 507550, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 445312, + "mistakes": 747, + "seed": 26005, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 509999, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 449218, + "mistakes": 763, + "seed": 26005, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 513671, + "aulc_ppm": 515036, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 484375, + "gru_last_loss": 0.696945309638977, + "gru_parameter_count": 3393, + "mistakes": 747, + "seed": 26005, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 526692, + "aulc_ppm": 529966, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 468750, + "mistakes": 727, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 76, + "prime_receipts_valid": true, + "seed": 26005, + "task": "RUNNING-PARITY" + }, + { + "accuracy_ppm": 666015, + "aulc_ppm": 662455, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 703125, + "mistakes": 513, + "seed": 26000, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 550781, + "aulc_ppm": 511570, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 593750, + "mistakes": 690, + "seed": 26000, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 479166, + "aulc_ppm": 481628, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 476562, + "mistakes": 800, + "seed": 26000, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 654296, + "aulc_ppm": 603505, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 703125, + "gru_last_loss": 0.6352918744087219, + "gru_parameter_count": 3393, + "mistakes": 531, + "seed": 26000, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 666015, + "aulc_ppm": 662455, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 703125, + "mistakes": 513, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26000, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 638671, + "aulc_ppm": 632762, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "mistakes": 555, + "seed": 26001, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 559895, + "aulc_ppm": 548394, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 550781, + "mistakes": 676, + "seed": 26001, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 486658, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 507812, + "mistakes": 775, + "seed": 26001, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 632161, + "aulc_ppm": 604953, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "gru_last_loss": 0.6794046759605408, + "gru_parameter_count": 3393, + "mistakes": 565, + "seed": 26001, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 638671, + "aulc_ppm": 632762, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "mistakes": 555, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26001, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 669270, + "aulc_ppm": 677056, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 644531, + "mistakes": 508, + "seed": 26002, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 576171, + "aulc_ppm": 556653, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 566406, + "mistakes": 651, + "seed": 26002, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 501302, + "aulc_ppm": 506036, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 488281, + "mistakes": 766, + "seed": 26002, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 662109, + "aulc_ppm": 641188, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 644531, + "gru_last_loss": 0.6191781759262085, + "gru_parameter_count": 3393, + "mistakes": 519, + "seed": 26002, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 669270, + "aulc_ppm": 677056, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 644531, + "mistakes": 508, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26002, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 651692, + "aulc_ppm": 641219, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 679687, + "mistakes": 535, + "seed": 26003, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 565755, + "aulc_ppm": 552324, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 582031, + "mistakes": 667, + "seed": 26003, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 503255, + "aulc_ppm": 514852, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 535156, + "mistakes": 763, + "seed": 26003, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 651692, + "aulc_ppm": 639234, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 679687, + "gru_last_loss": 0.5699496269226074, + "gru_parameter_count": 3393, + "mistakes": 535, + "seed": 26003, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 651692, + "aulc_ppm": 641219, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 679687, + "mistakes": 535, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26003, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 658854, + "aulc_ppm": 666742, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 636718, + "mistakes": 524, + "seed": 26004, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 555989, + "aulc_ppm": 540703, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 585937, + "mistakes": 682, + "seed": 26004, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 514242, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 464843, + "mistakes": 774, + "seed": 26004, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 656250, + "aulc_ppm": 651677, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 636718, + "gru_last_loss": 0.6244702935218811, + "gru_parameter_count": 3393, + "mistakes": 528, + "seed": 26004, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 658854, + "aulc_ppm": 666742, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 636718, + "mistakes": 524, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26004, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 678385, + "aulc_ppm": 671598, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 714843, + "mistakes": 494, + "seed": 26005, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 578776, + "aulc_ppm": 547742, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 656250, + "mistakes": 647, + "seed": 26005, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 505859, + "aulc_ppm": 504067, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 523437, + "mistakes": 759, + "seed": 26005, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 671875, + "aulc_ppm": 645129, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 714843, + "gru_last_loss": 0.7092258334159851, + "gru_parameter_count": 3393, + "mistakes": 504, + "seed": 26005, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 678385, + "aulc_ppm": 671598, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 714843, + "mistakes": 494, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26005, + "task": "MOD3-ONES" + }, + { + "accuracy_ppm": 530598, + "aulc_ppm": 559347, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 492187, + "mistakes": 721, + "seed": 26000, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 506078, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 441406, + "mistakes": 780, + "seed": 26000, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 484375, + "aulc_ppm": 497837, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 410156, + "mistakes": 792, + "seed": 26000, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 526041, + "aulc_ppm": 539733, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 492187, + "gru_last_loss": 0.7219876646995544, + "gru_parameter_count": 3393, + "mistakes": 728, + "seed": 26000, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 530598, + "aulc_ppm": 559347, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 492187, + "mistakes": 721, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26000, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 510416, + "aulc_ppm": 518855, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 523437, + "mistakes": 752, + "seed": 26001, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 508096, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 515625, + "mistakes": 760, + "seed": 26001, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 500651, + "aulc_ppm": 506478, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 492187, + "mistakes": 767, + "seed": 26001, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 495442, + "aulc_ppm": 491614, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 480468, + "gru_last_loss": 0.6918712258338928, + "gru_parameter_count": 3393, + "mistakes": 775, + "seed": 26001, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 510416, + "aulc_ppm": 518855, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 523437, + "mistakes": 752, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26001, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 511067, + "aulc_ppm": 515523, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 519531, + "mistakes": 751, + "seed": 26002, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 489583, + "aulc_ppm": 479924, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 527343, + "mistakes": 784, + "seed": 26002, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 495682, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 484375, + "mistakes": 780, + "seed": 26002, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 504557, + "aulc_ppm": 491815, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 535156, + "gru_last_loss": 0.7026073932647705, + "gru_parameter_count": 3393, + "mistakes": 761, + "seed": 26002, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 511067, + "aulc_ppm": 515523, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 519531, + "mistakes": 751, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26002, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 518229, + "aulc_ppm": 534621, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 464843, + "mistakes": 740, + "seed": 26003, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 522786, + "aulc_ppm": 528043, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 527343, + "mistakes": 733, + "seed": 26003, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 514322, + "aulc_ppm": 510466, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 503906, + "mistakes": 746, + "seed": 26003, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 488932, + "aulc_ppm": 442492, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 464843, + "gru_last_loss": 0.691375195980072, + "gru_parameter_count": 3393, + "mistakes": 785, + "seed": 26003, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 518229, + "aulc_ppm": 534621, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 464843, + "mistakes": 740, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26003, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 522135, + "aulc_ppm": 526624, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 503906, + "mistakes": 734, + "seed": 26004, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 524509, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 531250, + "mistakes": 760, + "seed": 26004, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 492187, + "aulc_ppm": 496576, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 515625, + "mistakes": 780, + "seed": 26004, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 516927, + "aulc_ppm": 491693, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 523437, + "gru_last_loss": 0.6831467747688293, + "gru_parameter_count": 3393, + "mistakes": 742, + "seed": 26004, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 522135, + "aulc_ppm": 526624, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 503906, + "mistakes": 734, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26004, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 492940, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 527343, + "mistakes": 758, + "seed": 26005, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 520182, + "aulc_ppm": 527762, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 503906, + "mistakes": 737, + "seed": 26005, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 485677, + "aulc_ppm": 486625, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 511718, + "mistakes": 790, + "seed": 26005, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 489583, + "aulc_ppm": 495208, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 539062, + "gru_last_loss": 0.6915476322174072, + "gru_parameter_count": 3393, + "mistakes": 784, + "seed": 26005, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 506510, + "aulc_ppm": 492940, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 527343, + "mistakes": 758, + "prime_active_constructions": 0, + "prime_explicit_recovery": null, + "prime_first_authorization": null, + "prime_receipts_valid": true, + "seed": 26005, + "task": "TOGGLE-ON-11" + }, + { + "accuracy_ppm": 664713, + "aulc_ppm": 655327, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "mistakes": 515, + "seed": 26000, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 897135, + "aulc_ppm": 760283, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 992187, + "mistakes": 158, + "seed": 26000, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 500000, + "aulc_ppm": 479937, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 484375, + "mistakes": 768, + "seed": 26000, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 662109, + "aulc_ppm": 645861, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "gru_last_loss": 0.6316242218017578, + "gru_parameter_count": 3393, + "mistakes": 519, + "seed": 26000, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 764973, + "aulc_ppm": 683155, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 945312, + "mistakes": 361, + "prime_active_constructions": 3, + "prime_explicit_recovery": null, + "prime_first_authorization": 495, + "prime_receipts_valid": true, + "seed": 26000, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 670572, + "aulc_ppm": 665000, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 656250, + "mistakes": 506, + "seed": 26001, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 912760, + "aulc_ppm": 809754, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 984375, + "mistakes": 134, + "seed": 26001, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 519531, + "aulc_ppm": 521770, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 535156, + "mistakes": 738, + "seed": 26001, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 672526, + "aulc_ppm": 675738, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 656250, + "gru_last_loss": 0.6401357054710388, + "gru_parameter_count": 3393, + "mistakes": 503, + "seed": 26001, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 766276, + "aulc_ppm": 699305, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 847656, + "mistakes": 359, + "prime_active_constructions": 3, + "prime_explicit_recovery": null, + "prime_first_authorization": 398, + "prime_receipts_valid": true, + "seed": 26001, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 667968, + "aulc_ppm": 669986, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "mistakes": 510, + "seed": 26002, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 912109, + "aulc_ppm": 802685, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 992187, + "mistakes": 135, + "seed": 26002, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 501953, + "aulc_ppm": 516730, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 550781, + "mistakes": 765, + "seed": 26002, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 668619, + "aulc_ppm": 674162, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 664062, + "gru_last_loss": 0.587089478969574, + "gru_parameter_count": 3393, + "mistakes": 509, + "seed": 26002, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 771484, + "aulc_ppm": 705204, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 894531, + "mistakes": 351, + "prime_active_constructions": 3, + "prime_explicit_recovery": null, + "prime_first_authorization": 336, + "prime_receipts_valid": true, + "seed": 26002, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 662760, + "aulc_ppm": 664402, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 660156, + "mistakes": 518, + "seed": 26003, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 913411, + "aulc_ppm": 807520, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 988281, + "mistakes": 133, + "seed": 26003, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 499348, + "aulc_ppm": 505495, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 484375, + "mistakes": 769, + "seed": 26003, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 658203, + "aulc_ppm": 641202, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 660156, + "gru_last_loss": 0.65671706199646, + "gru_parameter_count": 3393, + "mistakes": 525, + "seed": 26003, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 724609, + "aulc_ppm": 682103, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 796875, + "mistakes": 423, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 511, + "prime_receipts_valid": true, + "seed": 26003, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 657552, + "aulc_ppm": 657023, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 640625, + "mistakes": 526, + "seed": 26004, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 913411, + "aulc_ppm": 791745, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 1000000, + "mistakes": 133, + "seed": 26004, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 498046, + "aulc_ppm": 485609, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 511718, + "mistakes": 771, + "seed": 26004, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 658854, + "aulc_ppm": 666352, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 640625, + "gru_last_loss": 0.6737069487571716, + "gru_parameter_count": 3393, + "mistakes": 524, + "seed": 26004, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 773437, + "aulc_ppm": 719666, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 800781, + "mistakes": 348, + "prime_active_constructions": 1, + "prime_explicit_recovery": null, + "prime_first_authorization": 301, + "prime_receipts_valid": true, + "seed": 26004, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 662109, + "aulc_ppm": 677081, + "condition": "REACTIVE", + "family": "recurrent-state", + "final_accuracy_ppm": 648437, + "mistakes": 519, + "seed": 26005, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 918619, + "aulc_ppm": 804593, + "condition": "H8", + "family": "recurrent-state", + "final_accuracy_ppm": 996093, + "mistakes": 125, + "seed": 26005, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 501953, + "aulc_ppm": 517644, + "condition": "H16", + "family": "recurrent-state", + "final_accuracy_ppm": 503906, + "mistakes": 765, + "seed": 26005, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 662109, + "aulc_ppm": 677081, + "condition": "GRU32", + "family": "recurrent-state", + "final_accuracy_ppm": 648437, + "gru_last_loss": 0.6057974696159363, + "gru_parameter_count": 3393, + "mistakes": 519, + "seed": 26005, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 740885, + "aulc_ppm": 700540, + "condition": "PRIME", + "family": "recurrent-state", + "final_accuracy_ppm": 835937, + "mistakes": 398, + "prime_active_constructions": 3, + "prime_explicit_recovery": null, + "prime_first_authorization": 517, + "prime_receipts_valid": true, + "seed": 26005, + "task": "RUN-LENGTH-PARITY" + }, + { + "accuracy_ppm": 622395, + "aulc_ppm": 541461, + "condition": "REACTIVE", + "family": "nonstationary", + "final_accuracy_ppm": 804687, + "mistakes": 580, + "seed": 26000, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 630859, + "aulc_ppm": 683884, + "condition": "H8", + "family": "nonstationary", + "final_accuracy_ppm": 546875, + "mistakes": 567, + "seed": 26000, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 487630, + "aulc_ppm": 491171, + "condition": "H16", + "family": "nonstationary", + "final_accuracy_ppm": 488281, + "mistakes": 787, + "seed": 26000, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 611979, + "aulc_ppm": 493891, + "condition": "GRU32", + "family": "nonstationary", + "final_accuracy_ppm": 804687, + "gru_last_loss": 0.7556309103965759, + "gru_parameter_count": 3393, + "mistakes": 596, + "seed": 26000, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 632812, + "aulc_ppm": 793219, + "condition": "PRIME", + "family": "nonstationary", + "final_accuracy_ppm": 445312, + "mistakes": 564, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 55, + "prime_receipts_valid": true, + "seed": 26000, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 629557, + "aulc_ppm": 554656, + "condition": "REACTIVE", + "family": "nonstationary", + "final_accuracy_ppm": 746093, + "mistakes": 569, + "seed": 26001, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 636718, + "aulc_ppm": 718662, + "condition": "H8", + "family": "nonstationary", + "final_accuracy_ppm": 503906, + "mistakes": 558, + "seed": 26001, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 509765, + "aulc_ppm": 511250, + "condition": "H16", + "family": "nonstationary", + "final_accuracy_ppm": 496093, + "mistakes": 753, + "seed": 26001, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 632812, + "aulc_ppm": 552174, + "condition": "GRU32", + "family": "nonstationary", + "final_accuracy_ppm": 746093, + "gru_last_loss": 0.5871903300285339, + "gru_parameter_count": 3393, + "mistakes": 564, + "seed": 26001, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 632161, + "aulc_ppm": 801399, + "condition": "PRIME", + "family": "nonstationary", + "final_accuracy_ppm": 414062, + "mistakes": 565, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 54, + "prime_receipts_valid": true, + "seed": 26001, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 589843, + "aulc_ppm": 522164, + "condition": "REACTIVE", + "family": "nonstationary", + "final_accuracy_ppm": 656250, + "mistakes": 630, + "seed": 26002, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 629557, + "aulc_ppm": 682012, + "condition": "H8", + "family": "nonstationary", + "final_accuracy_ppm": 582031, + "mistakes": 569, + "seed": 26002, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 496093, + "aulc_ppm": 480678, + "condition": "H16", + "family": "nonstationary", + "final_accuracy_ppm": 468750, + "mistakes": 774, + "seed": 26002, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 572916, + "aulc_ppm": 500310, + "condition": "GRU32", + "family": "nonstationary", + "final_accuracy_ppm": 656250, + "gru_last_loss": 0.6695605516433716, + "gru_parameter_count": 3393, + "mistakes": 656, + "seed": 26002, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 616536, + "aulc_ppm": 782729, + "condition": "PRIME", + "family": "nonstationary", + "final_accuracy_ppm": 375000, + "mistakes": 589, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 57, + "prime_receipts_valid": true, + "seed": 26002, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 591796, + "aulc_ppm": 514671, + "condition": "REACTIVE", + "family": "nonstationary", + "final_accuracy_ppm": 757812, + "mistakes": 627, + "seed": 26003, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 642578, + "aulc_ppm": 721893, + "condition": "H8", + "family": "nonstationary", + "final_accuracy_ppm": 492187, + "mistakes": 549, + "seed": 26003, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 491536, + "aulc_ppm": 502042, + "condition": "H16", + "family": "nonstationary", + "final_accuracy_ppm": 527343, + "mistakes": 781, + "seed": 26003, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 572265, + "aulc_ppm": 497425, + "condition": "GRU32", + "family": "nonstationary", + "final_accuracy_ppm": 757812, + "gru_last_loss": 0.3451504409313202, + "gru_parameter_count": 3393, + "mistakes": 657, + "seed": 26003, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 649088, + "aulc_ppm": 798531, + "condition": "PRIME", + "family": "nonstationary", + "final_accuracy_ppm": 531250, + "mistakes": 539, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 72, + "prime_receipts_valid": true, + "seed": 26003, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 615885, + "aulc_ppm": 558082, + "condition": "REACTIVE", + "family": "nonstationary", + "final_accuracy_ppm": 710937, + "mistakes": 590, + "seed": 26004, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 615234, + "aulc_ppm": 687140, + "condition": "H8", + "family": "nonstationary", + "final_accuracy_ppm": 539062, + "mistakes": 591, + "seed": 26004, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 490885, + "aulc_ppm": 483133, + "condition": "H16", + "family": "nonstationary", + "final_accuracy_ppm": 503906, + "mistakes": 782, + "seed": 26004, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 568359, + "aulc_ppm": 494201, + "condition": "GRU32", + "family": "nonstationary", + "final_accuracy_ppm": 710937, + "gru_last_loss": 0.5065986514091492, + "gru_parameter_count": 3393, + "mistakes": 663, + "seed": 26004, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 636067, + "aulc_ppm": 798337, + "condition": "PRIME", + "family": "nonstationary", + "final_accuracy_ppm": 476562, + "mistakes": 559, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 65, + "prime_receipts_valid": true, + "seed": 26004, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 622395, + "aulc_ppm": 531126, + "condition": "REACTIVE", + "family": "nonstationary", + "final_accuracy_ppm": 792968, + "mistakes": 580, + "seed": 26005, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 635416, + "aulc_ppm": 719670, + "condition": "H8", + "family": "nonstationary", + "final_accuracy_ppm": 585937, + "mistakes": 560, + "seed": 26005, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 505208, + "aulc_ppm": 508733, + "condition": "H16", + "family": "nonstationary", + "final_accuracy_ppm": 507812, + "mistakes": 760, + "seed": 26005, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 598958, + "aulc_ppm": 503605, + "condition": "GRU32", + "family": "nonstationary", + "final_accuracy_ppm": 792968, + "gru_last_loss": 0.51994788646698, + "gru_parameter_count": 3393, + "mistakes": 616, + "seed": 26005, + "task": "XOR-TO-AND" + }, + { + "accuracy_ppm": 637369, + "aulc_ppm": 794766, + "condition": "PRIME", + "family": "nonstationary", + "final_accuracy_ppm": 453125, + "mistakes": 557, + "prime_active_constructions": 2, + "prime_explicit_recovery": null, + "prime_first_authorization": 57, + "prime_receipts_valid": true, + "seed": 26005, + "task": "XOR-TO-AND" + } + ], + "status": "DEVELOPMENT_ONLY", + "task_count": 18, + "task_summaries": [ + { + "GRU32": { + "aulc_ppm": 791248, + "final_accuracy_ppm": 1000000 + }, + "H16": { + "aulc_ppm": 497694, + "final_accuracy_ppm": 507812 + }, + "H8": { + "aulc_ppm": 800654, + "final_accuracy_ppm": 999348 + }, + "PRIME": { + "aulc_ppm": 993571, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 993571, + "final_accuracy_ppm": 1000000 + }, + "family": "explicit-relational", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": null, + "task": "CURRENT" + }, + { + "GRU32": { + "aulc_ppm": 673494, + "final_accuracy_ppm": 1000000 + }, + "H16": { + "aulc_ppm": 506183, + "final_accuracy_ppm": 514322 + }, + "H8": { + "aulc_ppm": 799218, + "final_accuracy_ppm": 1000000 + }, + "PRIME": { + "aulc_ppm": 911347, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 497294, + "final_accuracy_ppm": 503254 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 64, + "task": "LAG-1" + }, + { + "GRU32": { + "aulc_ppm": 551462, + "final_accuracy_ppm": 690755 + }, + "H16": { + "aulc_ppm": 504567, + "final_accuracy_ppm": 542968 + }, + "H8": { + "aulc_ppm": 804390, + "final_accuracy_ppm": 997395 + }, + "PRIME": { + "aulc_ppm": 909010, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 514381, + "final_accuracy_ppm": 514973 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 66, + "task": "LAG-4" + }, + { + "GRU32": { + "aulc_ppm": 504919, + "final_accuracy_ppm": 508463 + }, + "H16": { + "aulc_ppm": 501110, + "final_accuracy_ppm": 550780 + }, + "H8": { + "aulc_ppm": 797780, + "final_accuracy_ppm": 999348 + }, + "PRIME": { + "aulc_ppm": 905037, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 501664, + "final_accuracy_ppm": 492187 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 64, + "task": "XOR-1-4" + }, + { + "GRU32": { + "aulc_ppm": 499959, + "final_accuracy_ppm": 521484 + }, + "H16": { + "aulc_ppm": 497081, + "final_accuracy_ppm": 513020 + }, + "H8": { + "aulc_ppm": 790302, + "final_accuracy_ppm": 999348 + }, + "PRIME": { + "aulc_ppm": 907449, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 504987, + "final_accuracy_ppm": 476562 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 62, + "task": "EQ-1-4" + }, + { + "GRU32": { + "aulc_ppm": 720912, + "final_accuracy_ppm": 758463 + }, + "H16": { + "aulc_ppm": 503651, + "final_accuracy_ppm": 511067 + }, + "H8": { + "aulc_ppm": 795675, + "final_accuracy_ppm": 998046 + }, + "PRIME": { + "aulc_ppm": 926295, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 750520, + "final_accuracy_ppm": 738932 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 131, + "task": "AND-1-4" + }, + { + "GRU32": { + "aulc_ppm": 703018, + "final_accuracy_ppm": 726562 + }, + "H16": { + "aulc_ppm": 509051, + "final_accuracy_ppm": 528645 + }, + "H8": { + "aulc_ppm": 799767, + "final_accuracy_ppm": 996744 + }, + "PRIME": { + "aulc_ppm": 914557, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 734072, + "final_accuracy_ppm": 726562 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 98, + "task": "OR-2-7" + }, + { + "GRU32": { + "aulc_ppm": 511239, + "final_accuracy_ppm": 484374 + }, + "H16": { + "aulc_ppm": 499675, + "final_accuracy_ppm": 517577 + }, + "H8": { + "aulc_ppm": 791602, + "final_accuracy_ppm": 998697 + }, + "PRIME": { + "aulc_ppm": 907093, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 507768, + "final_accuracy_ppm": 494791 + }, + "family": "explicit-relational", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 63, + "task": "XOR-1-2-3" + }, + { + "GRU32": { + "aulc_ppm": 496117, + "final_accuracy_ppm": 520181 + }, + "H16": { + "aulc_ppm": 511197, + "final_accuracy_ppm": 507161 + }, + "H8": { + "aulc_ppm": 505729, + "final_accuracy_ppm": 486978 + }, + "PRIME": { + "aulc_ppm": 906706, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 511398, + "final_accuracy_ppm": 520181 + }, + "family": "scaling", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 65, + "task": "LAG-8" + }, + { + "GRU32": { + "aulc_ppm": 510032, + "final_accuracy_ppm": 483072 + }, + "H16": { + "aulc_ppm": 492647, + "final_accuracy_ppm": 520182 + }, + "H8": { + "aulc_ppm": 496762, + "final_accuracy_ppm": 526692 + }, + "PRIME": { + "aulc_ppm": 512301, + "final_accuracy_ppm": 504557 + }, + "REACTIVE": { + "aulc_ppm": 522410, + "final_accuracy_ppm": 494791 + }, + "family": "scaling", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 71, + "task": "LAG-16" + }, + { + "GRU32": { + "aulc_ppm": 507923, + "final_accuracy_ppm": 491536 + }, + "H16": { + "aulc_ppm": 507521, + "final_accuracy_ppm": 513020 + }, + "H8": { + "aulc_ppm": 504562, + "final_accuracy_ppm": 494140 + }, + "PRIME": { + "aulc_ppm": 900338, + "final_accuracy_ppm": 1000000 + }, + "REACTIVE": { + "aulc_ppm": 497194, + "final_accuracy_ppm": 496093 + }, + "family": "scaling", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 55, + "task": "XOR-1-8" + }, + { + "GRU32": { + "aulc_ppm": 501094, + "final_accuracy_ppm": 520181 + }, + "H16": { + "aulc_ppm": 500929, + "final_accuracy_ppm": 501301 + }, + "H8": { + "aulc_ppm": 504603, + "final_accuracy_ppm": 511718 + }, + "PRIME": { + "aulc_ppm": 507239, + "final_accuracy_ppm": 518228 + }, + "REACTIVE": { + "aulc_ppm": 501768, + "final_accuracy_ppm": 493489 + }, + "family": "scaling", + "prime_explicit_recovery": "6/6", + "prime_mean_first_authorization": 58, + "task": "XOR-1-16" + }, + { + "GRU32": { + "aulc_ppm": 596508, + "final_accuracy_ppm": 563801 + }, + "H16": { + "aulc_ppm": 522754, + "final_accuracy_ppm": 485676 + }, + "H8": { + "aulc_ppm": 626753, + "final_accuracy_ppm": 709635 + }, + "PRIME": { + "aulc_ppm": 631846, + "final_accuracy_ppm": 592447 + }, + "REACTIVE": { + "aulc_ppm": 627898, + "final_accuracy_ppm": 578775 + }, + "family": "scaling", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": 554, + "task": "MAJORITY-16" + }, + { + "GRU32": { + "aulc_ppm": 501685, + "final_accuracy_ppm": 467447 + }, + "H16": { + "aulc_ppm": 495647, + "final_accuracy_ppm": 492838 + }, + "H8": { + "aulc_ppm": 501352, + "final_accuracy_ppm": 505208 + }, + "PRIME": { + "aulc_ppm": 465426, + "final_accuracy_ppm": 464192 + }, + "REACTIVE": { + "aulc_ppm": 387300, + "final_accuracy_ppm": 385416 + }, + "family": "recurrent-state", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": 84, + "task": "RUNNING-PARITY" + }, + { + "GRU32": { + "aulc_ppm": 630947, + "final_accuracy_ppm": 673827 + }, + "H16": { + "aulc_ppm": 501247, + "final_accuracy_ppm": 499348 + }, + "H8": { + "aulc_ppm": 542897, + "final_accuracy_ppm": 589192 + }, + "PRIME": { + "aulc_ppm": 658638, + "final_accuracy_ppm": 673827 + }, + "REACTIVE": { + "aulc_ppm": 658638, + "final_accuracy_ppm": 673827 + }, + "family": "recurrent-state", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": null, + "task": "MOD3-ONES" + }, + { + "GRU32": { + "aulc_ppm": 492092, + "final_accuracy_ppm": 505858 + }, + "H16": { + "aulc_ppm": 498944, + "final_accuracy_ppm": 486327 + }, + "H8": { + "aulc_ppm": 512402, + "final_accuracy_ppm": 507812 + }, + "PRIME": { + "aulc_ppm": 524651, + "final_accuracy_ppm": 505207 + }, + "REACTIVE": { + "aulc_ppm": 524651, + "final_accuracy_ppm": 505207 + }, + "family": "recurrent-state", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": null, + "task": "TOGGLE-ON-11" + }, + { + "GRU32": { + "aulc_ppm": 663399, + "final_accuracy_ppm": 655598 + }, + "H16": { + "aulc_ppm": 504530, + "final_accuracy_ppm": 511718 + }, + "H8": { + "aulc_ppm": 796096, + "final_accuracy_ppm": 992187 + }, + "PRIME": { + "aulc_ppm": 698328, + "final_accuracy_ppm": 853515 + }, + "REACTIVE": { + "aulc_ppm": 664803, + "final_accuracy_ppm": 655598 + }, + "family": "recurrent-state", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": 426, + "task": "RUN-LENGTH-PARITY" + }, + { + "GRU32": { + "aulc_ppm": 506934, + "final_accuracy_ppm": 744791 + }, + "H16": { + "aulc_ppm": 496167, + "final_accuracy_ppm": 498697 + }, + "H8": { + "aulc_ppm": 702210, + "final_accuracy_ppm": 541666 + }, + "PRIME": { + "aulc_ppm": 794830, + "final_accuracy_ppm": 449218 + }, + "REACTIVE": { + "aulc_ppm": 537026, + "final_accuracy_ppm": 744791 + }, + "family": "nonstationary", + "prime_explicit_recovery": null, + "prime_mean_first_authorization": 60, + "task": "XOR-TO-AND" + } + ], + "worlds_per_condition": 108 +} diff --git a/experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.sha256 b/experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.sha256 new file mode 100644 index 0000000..6f36038 --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.sha256 @@ -0,0 +1 @@ +41cf621263457aab79b8403fa98b7c63b9813febe58bc28abc59d890621fdab8 experiments/prime_m26_comparative_cognition/results/DEVELOPMENT_V0_1.json diff --git a/experiments/prime_m26_comparative_cognition/runner.py b/experiments/prime_m26_comparative_cognition/runner.py new file mode 100644 index 0000000..a9c4a05 --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/runner.py @@ -0,0 +1,517 @@ +"""PRIME M26 comparative cognition runner.""" + +from __future__ import annotations + +from dataclasses import dataclass + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.quotient import ( + active_partition_matches, +) +from core.construction.receipts import ( + verify_receipt_chain, +) + +from .gru_agent import ( + GRUOnlinePredictor, +) +from .tasks import ( + ComparativeTask, +) + + +MASK64 = ( + (1 << 64) - 1 +) + +PPM = 1_000_000 + +STEPS = 1536 + +FINAL_WINDOW = 256 + +DEVELOPMENT_SEEDS = tuple( + range( + 26000, + 26006, + ) +) + +EVALUATION_SEEDS = tuple( + range( + 36000, + 36032, + ) +) + +CONDITIONS = ( + "REACTIVE", + "H8", + "H16", + "GRU32", + "PRIME", +) + + +def splitmix64( + value: int, +) -> int: + z = ( + value + + 0x9E3779B97F4A7C15 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 30) + ) + * 0xBF58476D1CE4E5B9 + ) & MASK64 + + z = ( + ( + z + ^ (z >> 27) + ) + * 0x94D049BB133111EB + ) & MASK64 + + return ( + z + ^ (z >> 31) + ) & MASK64 + + +def observation_stream( + seed: int, +): + state = splitmix64( + seed + ^ 0x4D3236434F474E49 + ) + + while True: + state = splitmix64( + state + ) + + yield ( + state >> 63 + ) & 1 + + +class OnlineTableLearner: + def __init__( + self, + seed: int, + ) -> None: + self.seed = seed + + self.counts = {} + + def predict( + self, + state, + event_index, + ) -> int: + counts = self.counts.get( + state, + (0, 0), + ) + + if counts[0] == counts[1]: + return int( + splitmix64( + self.seed + ^ splitmix64( + event_index + ) + ) + & 1 + ) + + return int( + counts[1] + > counts[0] + ) + + def learn( + self, + state, + target, + ) -> None: + counts = list( + self.counts.get( + state, + (0, 0), + ) + ) + + counts[target] += 1 + + self.counts[state] = tuple( + counts + ) + + +@dataclass(frozen=True) +class WorldResult: + payload: dict + + +def state_for_history( + history, + width, +): + return tuple( + history[-width:] + ) + + +def summarize_outcomes( + outcomes, +): + cumulative = 0 + curve = 0 + + for index, value in enumerate( + outcomes + ): + cumulative += value + + curve += ( + PPM + * cumulative + // ( + index + 1 + ) + ) + + final = outcomes[ + -min( + FINAL_WINDOW, + len(outcomes), + ): + ] + + return { + "aulc_ppm": ( + curve + // len(outcomes) + ), + "accuracy_ppm": ( + PPM + * sum(outcomes) + // len(outcomes) + ), + "final_accuracy_ppm": ( + PPM + * sum(final) + // len(final) + ), + "mistakes": ( + len(outcomes) + - sum(outcomes) + ), + } + + +def run_world( + task: ComparativeTask, + seed: int, + condition: str, + *, + permit_evaluation: bool = False, +) -> WorldResult: + if seed in EVALUATION_SEEDS: + if not permit_evaluation: + raise PermissionError( + "M26 held-out evaluation is blocked" + ) + + elif seed not in DEVELOPMENT_SEEDS: + raise PermissionError( + "unregistered M26 seed" + ) + + if condition not in CONDITIONS: + raise ValueError( + condition + ) + + task_salt = sum( + ( + index + 1 + ) + * ord(character) + for index, character + in enumerate( + task.name + ) + ) + + stream = observation_stream( + seed + ^ splitmix64( + task_salt + ) + ) + + history = [] + + outcomes = [] + + table = None + gru = None + prime = None + + first_authorization = None + + if condition in ( + "REACTIVE", + "H8", + "H16", + "PRIME", + ): + table = OnlineTableLearner( + splitmix64( + seed + ^ 0x4D32365441424C45 + ) + ) + + if condition == "GRU32": + gru = GRUOnlinePredictor( + seed=( + splitmix64( + seed + ^ task_salt + ^ 0x4D32364752553332 + ) + & 0x7FFFFFFF + ), + hidden_size=32, + learning_rate=0.01, + chunk_length=32, + ) + + if condition == "PRIME": + prime = ( + CompositionalAdaptiveConstructionEngine( + max_lag=16, + max_candidates=512, + enable_scaffolds=True, + ) + ) + + prime.begin_episode() + + for event_index in range( + STEPS + ): + observation = next( + stream + ) + + history.append( + observation + ) + + target = ( + task.target_function( + tuple(history), + event_index, + STEPS, + ) + ) + + if condition == "REACTIVE": + state = ( + observation, + ) + + prediction = ( + table.predict( + state, + event_index, + ) + ) + + table.learn( + state, + target, + ) + + elif condition == "H8": + state = ( + state_for_history( + history, + 8, + ) + ) + + prediction = ( + table.predict( + state, + event_index, + ) + ) + + table.learn( + state, + target, + ) + + elif condition == "H16": + state = ( + state_for_history( + history, + 16, + ) + ) + + prediction = ( + table.predict( + state, + event_index, + ) + ) + + table.learn( + state, + target, + ) + + elif condition == "GRU32": + prediction = ( + gru.predict( + observation + ) + ) + + gru.learn( + target + ) + + elif condition == "PRIME": + state = ( + prime.observe( + observation + ) + ) + + prediction = ( + table.predict( + state, + event_index, + ) + ) + + table.learn( + state, + target, + ) + + decision = ( + prime.finalize( + target + ) + ) + + if ( + decision.authorized + and first_authorization + is None + ): + first_authorization = ( + event_index + ) + + else: + raise AssertionError( + condition + ) + + outcomes.append( + int( + prediction + == target + ) + ) + + # Flush final incomplete GRU training chunk for diagnostics only. + if ( + gru is not None + and gru.chunk_y + ): + gru._train_chunk() + + summary = summarize_outcomes( + outcomes + ) + + payload = { + "task": task.name, + "family": task.family, + "seed": seed, + "condition": condition, + **summary, + } + + if gru is not None: + payload.update( + { + "gru_parameter_count": ( + gru.parameter_count + ), + "gru_last_loss": ( + gru.last_loss + ), + } + ) + + if prime is not None: + explicit_recovery = None + + if ( + task.explicit_expression + is not None + ): + explicit_recovery = bool( + active_partition_matches( + prime.registry, + task.explicit_expression, + max_lag=16, + ) + ) + + payload.update( + { + "prime_first_authorization": ( + first_authorization + ), + "prime_active_constructions": ( + len( + prime.active_construction_ids + ) + ), + "prime_explicit_recovery": ( + explicit_recovery + ), + "prime_receipts_valid": ( + verify_receipt_chain( + prime.receipt_chain, + expected_count=len( + prime.receipt_chain + ), + ) + ), + } + ) + + return WorldResult( + payload=payload + ) diff --git a/experiments/prime_m26_comparative_cognition/tasks.py b/experiments/prime_m26_comparative_cognition/tasks.py new file mode 100644 index 0000000..3f72af6 --- /dev/null +++ b/experiments/prime_m26_comparative_cognition/tasks.py @@ -0,0 +1,366 @@ +"""Task universe for PRIME M26 comparative cognition.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Callable + +from core.construction.grammar import ( + binary, + evaluate, + lag, +) +from core.construction.scaffold import ( + fold_commutative, +) +from core.construction.types import ( + FeatureExpr, + FeatureOp, +) + + +TargetFunction = Callable[ + [tuple[int, ...], int, int], + int, +] + + +@dataclass(frozen=True) +class ComparativeTask: + name: str + family: str + target_function: TargetFunction + explicit_expression: FeatureExpr | None = None + + +def expression_target( + expression: FeatureExpr, +) -> TargetFunction: + def target( + history, + event_index, + total_steps, + ): + del event_index + del total_steps + + return evaluate( + expression, + history, + ) + + return target + + +def current_target( + history, + event_index, + total_steps, +): + del event_index + del total_steps + + return history[-1] + + +def majority16( + history, + event_index, + total_steps, +): + del event_index + del total_steps + + window = history[-16:] + + return int( + 2 * sum(window) + >= len(window) + ) + + +def running_parity( + history, + event_index, + total_steps, +): + del event_index + del total_steps + + result = 0 + + for value in history: + result ^= value + + return result + + +def mod3_ones( + history, + event_index, + total_steps, +): + del event_index + del total_steps + + return int( + sum(history) % 3 + == 0 + ) + + +def toggle_on_11( + history, + event_index, + total_steps, +): + del event_index + del total_steps + + state = 0 + + for index in range( + 1, + len(history), + ): + if ( + history[index - 1] == 1 + and history[index] == 1 + and ( + index == 1 + or history[index - 2] == 0 + ) + ): + state ^= 1 + + return state + + +def run_length_parity( + history, + event_index, + total_steps, +): + del event_index + del total_steps + + current = history[-1] + + length = 1 + + for index in range( + len(history) - 2, + -1, + -1, + ): + if ( + history[index] + != current + ): + break + + length += 1 + + return length & 1 + + +def switching_target( + history, + event_index, + total_steps, +): + xor_expr = binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + + and_expr = binary( + FeatureOp.AND, + lag(1), + lag(4), + ) + + expression = ( + xor_expr + if event_index + < total_steps // 2 + else and_expr + ) + + return evaluate( + expression, + history, + ) + + +def tasks() -> tuple[ + ComparativeTask, + ..., +]: + rows = [] + + def add_expression( + name, + family, + expression, + ): + rows.append( + ComparativeTask( + name=name, + family=family, + target_function=( + expression_target( + expression + ) + ), + explicit_expression=( + expression + ), + ) + ) + + rows.append( + ComparativeTask( + name="CURRENT", + family="explicit-relational", + target_function=current_target, + ) + ) + + add_expression( + "LAG-1", + "explicit-relational", + lag(1), + ) + + add_expression( + "LAG-4", + "explicit-relational", + lag(4), + ) + + add_expression( + "XOR-1-4", + "explicit-relational", + binary( + FeatureOp.XOR, + lag(1), + lag(4), + ), + ) + + add_expression( + "EQ-1-4", + "explicit-relational", + binary( + FeatureOp.EQ, + lag(1), + lag(4), + ), + ) + + add_expression( + "AND-1-4", + "explicit-relational", + binary( + FeatureOp.AND, + lag(1), + lag(4), + ), + ) + + add_expression( + "OR-2-7", + "explicit-relational", + binary( + FeatureOp.OR, + lag(2), + lag(7), + ), + ) + + add_expression( + "XOR-1-2-3", + "explicit-relational", + fold_commutative( + FeatureOp.XOR, + ( + lag(1), + lag(2), + lag(3), + ), + ), + ) + + add_expression( + "LAG-8", + "scaling", + lag(8), + ) + + add_expression( + "LAG-16", + "scaling", + lag(16), + ) + + add_expression( + "XOR-1-8", + "scaling", + binary( + FeatureOp.XOR, + lag(1), + lag(8), + ), + ) + + add_expression( + "XOR-1-16", + "scaling", + binary( + FeatureOp.XOR, + lag(1), + lag(16), + ), + ) + + rows.append( + ComparativeTask( + name="MAJORITY-16", + family="scaling", + target_function=majority16, + ) + ) + + rows.extend( + ( + ComparativeTask( + name="RUNNING-PARITY", + family="recurrent-state", + target_function=running_parity, + ), + ComparativeTask( + name="MOD3-ONES", + family="recurrent-state", + target_function=mod3_ones, + ), + ComparativeTask( + name="TOGGLE-ON-11", + family="recurrent-state", + target_function=toggle_on_11, + ), + ComparativeTask( + name="RUN-LENGTH-PARITY", + family="recurrent-state", + target_function=run_length_parity, + ), + ComparativeTask( + name="XOR-TO-AND", + family="nonstationary", + target_function=switching_target, + ), + ) + ) + + return tuple(rows) diff --git a/reasoner/ts_reasoner/constraint_fields/__init__.py b/reasoner/ts_reasoner/constraint_fields/__init__.py new file mode 100644 index 0000000..cc158e6 --- /dev/null +++ b/reasoner/ts_reasoner/constraint_fields/__init__.py @@ -0,0 +1,26 @@ +"""Verifier-first constraint-field reasoning substrate.""" + +from .examples import EXAMPLE_CONCEPT_FIELDS, get_example_concept_field +from .model import ( + CONSTRAINT_FIELD_PRIMITIVES, + ConceptField, + FieldItem, + compare_concept_fields, + create_concept_field, + export_receipt, + field_signature, + verify_analogy, +) + +__all__ = [ + "CONSTRAINT_FIELD_PRIMITIVES", + "EXAMPLE_CONCEPT_FIELDS", + "ConceptField", + "FieldItem", + "compare_concept_fields", + "create_concept_field", + "export_receipt", + "field_signature", + "get_example_concept_field", + "verify_analogy", +] diff --git a/reasoner/ts_reasoner/constraint_fields/examples.py b/reasoner/ts_reasoner/constraint_fields/examples.py new file mode 100644 index 0000000..353f1e6 --- /dev/null +++ b/reasoner/ts_reasoner/constraint_fields/examples.py @@ -0,0 +1,266 @@ +"""Canonical example concept fields for deterministic TS-AI field reasoning.""" + +from __future__ import annotations + +from typing import Any + +EXAMPLE_CONCEPT_FIELDS: dict[str, dict[str, Any]] = { + "gravity": { + "concept_id": "gravity", + "name": "Gravity", + "description": "Universal physical attraction between masses through spacetime curvature or equivalent gravitational field models.", + "confidence": 0.95, + "entities": [ + {"label": "mass body", "primitives": ["attractor"], "strength": 0.95, "confidence": 0.95, "evidence": ["Newtonian and relativistic gravitational models"]}, + {"label": "distance relation", "primitives": ["gradient", "decay"], "strength": 0.9, "confidence": 0.95}, + {"label": "orbiting body", "primitives": ["oscillation", "flow"], "strength": 0.75, "confidence": 0.9}, + ], + "forces": [ + {"label": "mass attraction", "primitives": ["attractor", "gradient"], "strength": 1.0, "confidence": 0.95}, + {"label": "distance decay", "primitives": ["decay", "gradient"], "strength": 0.9, "confidence": 0.95}, + ], + "constraints": [ + {"label": "universal law constraint", "primitives": ["symmetry", "constraint_satisfaction"], "strength": 0.9, "confidence": 0.95}, + {"label": "conservation constraints", "primitives": ["symmetry", "constraint_satisfaction"], "strength": 0.8, "confidence": 0.9}, + ], + "flows": [ + {"label": "trajectory curvature", "primitives": ["flow", "gradient"], "strength": 0.85, "confidence": 0.9}, + ], + "thresholds": [ + {"label": "escape velocity threshold", "primitives": ["threshold", "resistance"], "strength": 0.85, "confidence": 0.95}, + {"label": "collapse threshold", "primitives": ["threshold", "collapse", "compression"], "strength": 0.7, "confidence": 0.85}, + ], + "attractors": [ + {"label": "central mass", "primitives": ["attractor", "local_minimum"], "strength": 0.9, "confidence": 0.95}, + ], + "failure_modes": [ + {"label": "orbital instability", "primitives": ["oscillation", "collapse"], "strength": 0.65, "confidence": 0.8}, + ], + "similar_systems": [ + {"label": "electrostatic attraction", "primitives": ["attractor", "gradient"], "strength": 0.55, "confidence": 0.75}, + ], + "breakpoints": [ + {"label": "impersonal universal mechanism", "description": "Gravity does not depend on belief, agency, culture, interpretation, or incentive alignment.", "primitives": ["symmetry", "constraint_satisfaction"], "strength": 0.95, "confidence": 0.95}, + {"label": "mathematical invariance", "description": "The same mass-distance structure applies regardless of social meaning.", "primitives": ["symmetry"], "strength": 0.8, "confidence": 0.9}, + ], + "testable_predictions": [ + {"label": "distance changes orbital force", "description": "Changing distance changes acceleration and orbit shape.", "primitives": ["gradient", "decay"], "strength": 0.9, "confidence": 0.95}, + ], + }, + "social_influence": { + "concept_id": "social_influence", + "name": "Social Influence", + "description": "Status, incentives, attention, and interpretation shape how agents copy, resist, or orbit social centers.", + "confidence": 0.78, + "entities": [ + {"label": "status center", "primitives": ["attractor"], "strength": 0.85, "confidence": 0.8}, + {"label": "social distance", "primitives": ["gradient", "decay"], "strength": 0.7, "confidence": 0.75}, + {"label": "interpreting agent", "primitives": ["feedback", "resistance"], "strength": 0.9, "confidence": 0.8}, + ], + "forces": [ + {"label": "prestige attraction", "primitives": ["attractor", "gradient"], "strength": 0.8, "confidence": 0.8}, + {"label": "attention decay", "primitives": ["decay", "gradient"], "strength": 0.7, "confidence": 0.7}, + {"label": "peer feedback", "primitives": ["feedback", "propagation"], "strength": 0.75, "confidence": 0.75}, + ], + "constraints": [ + {"label": "cultural interpretation constraint", "primitives": ["constraint_satisfaction", "resistance"], "strength": 0.85, "confidence": 0.75}, + {"label": "incentive compatibility", "primitives": ["constraint_satisfaction", "feedback"], "strength": 0.75, "confidence": 0.75}, + ], + "flows": [ + {"label": "norm propagation", "primitives": ["flow", "propagation"], "strength": 0.8, "confidence": 0.75}, + ], + "thresholds": [ + {"label": "adoption threshold", "primitives": ["threshold", "phase_transition"], "strength": 0.75, "confidence": 0.7}, + ], + "attractors": [ + {"label": "high status group", "primitives": ["attractor", "local_minimum"], "strength": 0.8, "confidence": 0.75}, + ], + "failure_modes": [ + {"label": "herding collapse", "primitives": ["collapse", "propagation", "feedback"], "strength": 0.7, "confidence": 0.7}, + ], + "similar_systems": [ + {"label": "gravitational orbit metaphor", "primitives": ["attractor", "gradient", "decay"], "strength": 0.45, "confidence": 0.55}, + ], + "breakpoints": [ + {"label": "agency and interpretation", "description": "People can reinterpret, resist, or strategically exploit the influence field.", "primitives": ["feedback", "resistance"], "strength": 0.95, "confidence": 0.85}, + {"label": "culture and context dependence", "description": "Influence gradients vary by group, norms, incentives, and time.", "primitives": ["constraint_satisfaction"], "strength": 0.85, "confidence": 0.8}, + ], + "testable_predictions": [ + {"label": "status proximity increases adoption probability", "primitives": ["gradient", "decay", "propagation"], "strength": 0.75, "confidence": 0.7}, + ], + }, + "debt": { + "concept_id": "debt", + "name": "Debt", + "description": "An obligation that accumulates cost over time until repayment, restructuring, default, or collapse.", + "confidence": 0.9, + "entities": [ + {"label": "borrower", "primitives": ["constraint_satisfaction", "resistance"], "strength": 0.8, "confidence": 0.9}, + {"label": "creditor", "primitives": ["constraint_satisfaction"], "strength": 0.8, "confidence": 0.9}, + {"label": "principal balance", "primitives": ["accumulation"], "strength": 0.95, "confidence": 0.95}, + ], + "forces": [ + {"label": "interest pressure", "primitives": ["growth", "accumulation", "compression"], "strength": 0.95, "confidence": 0.9}, + {"label": "repayment pressure", "primitives": ["resistance", "flow"], "strength": 0.85, "confidence": 0.9}, + ], + "constraints": [ + {"label": "legal repayment obligation", "primitives": ["constraint_satisfaction", "lock"], "strength": 0.9, "confidence": 0.9}, + {"label": "maintenance cost", "primitives": ["resistance", "flow"], "strength": 0.8, "confidence": 0.85}, + ], + "flows": [ + {"label": "cash flow servicing", "primitives": ["flow", "resistance"], "strength": 0.85, "confidence": 0.85}, + {"label": "compounding accumulation", "primitives": ["growth", "accumulation", "feedback"], "strength": 0.9, "confidence": 0.9}, + ], + "thresholds": [ + {"label": "default threshold", "primitives": ["threshold", "collapse"], "strength": 0.9, "confidence": 0.9}, + ], + "attractors": [ + {"label": "debt trap", "primitives": ["local_minimum", "lock", "attractor"], "strength": 0.85, "confidence": 0.8}, + ], + "failure_modes": [ + {"label": "insolvency collapse", "primitives": ["collapse", "threshold"], "strength": 0.9, "confidence": 0.9}, + {"label": "trust degradation", "primitives": ["decay", "feedback"], "strength": 0.75, "confidence": 0.8}, + ], + "similar_systems": [ + {"label": "technical debt", "primitives": ["accumulation", "growth", "resistance", "collapse"], "strength": 0.85, "confidence": 0.85}, + ], + "breakpoints": [ + {"label": "formal contract boundary", "description": "Financial debt has explicit legal and accounting enforcement that many metaphorical debts lack.", "primitives": ["lock", "constraint_satisfaction"], "strength": 0.55, "confidence": 0.85}, + ], + "testable_predictions": [ + {"label": "unpaid balance increases servicing burden", "primitives": ["growth", "accumulation", "resistance"], "strength": 0.9, "confidence": 0.9}, + ], + }, + "technical_debt": { + "concept_id": "technical_debt", + "name": "Technical Debt", + "description": "Deferred engineering work that accumulates maintenance cost and collapse risk until refactored or repaid.", + "confidence": 0.86, + "entities": [ + {"label": "codebase", "primitives": ["constraint_satisfaction"], "strength": 0.9, "confidence": 0.85}, + {"label": "deferred refactor balance", "primitives": ["accumulation"], "strength": 0.95, "confidence": 0.85}, + {"label": "maintainer", "primitives": ["resistance", "flow"], "strength": 0.75, "confidence": 0.8}, + ], + "forces": [ + {"label": "maintenance pressure", "primitives": ["growth", "accumulation", "compression"], "strength": 0.9, "confidence": 0.85}, + {"label": "refactor repayment effort", "primitives": ["resistance", "flow"], "strength": 0.85, "confidence": 0.85}, + ], + "constraints": [ + {"label": "architecture constraint lock", "primitives": ["constraint_satisfaction", "lock"], "strength": 0.85, "confidence": 0.85}, + {"label": "maintenance cost", "primitives": ["resistance", "flow"], "strength": 0.9, "confidence": 0.85}, + ], + "flows": [ + {"label": "change flow slowdown", "primitives": ["flow", "resistance"], "strength": 0.85, "confidence": 0.85}, + {"label": "defect compounding accumulation", "primitives": ["growth", "accumulation", "feedback"], "strength": 0.85, "confidence": 0.8}, + ], + "thresholds": [ + {"label": "collapse threshold", "primitives": ["threshold", "collapse"], "strength": 0.85, "confidence": 0.8}, + ], + "attractors": [ + {"label": "legacy local minimum", "primitives": ["local_minimum", "lock", "attractor"], "strength": 0.8, "confidence": 0.8}, + ], + "failure_modes": [ + {"label": "delivery collapse", "primitives": ["collapse", "threshold"], "strength": 0.85, "confidence": 0.8}, + {"label": "team trust degradation", "primitives": ["decay", "feedback"], "strength": 0.75, "confidence": 0.75}, + ], + "similar_systems": [ + {"label": "financial debt", "primitives": ["accumulation", "growth", "resistance", "collapse"], "strength": 0.85, "confidence": 0.85}, + ], + "breakpoints": [ + {"label": "metaphorical enforcement boundary", "description": "Technical debt is enforced by engineering friction, not courts or formal interest contracts.", "primitives": ["resistance", "constraint_satisfaction"], "strength": 0.5, "confidence": 0.8}, + ], + "testable_predictions": [ + {"label": "deferred refactors increase change cost", "primitives": ["growth", "accumulation", "resistance"], "strength": 0.85, "confidence": 0.85}, + ], + }, + "learning": { + "concept_id": "learning", + "name": "Learning", + "description": "Adaptive change in internal model or behavior through feedback, practice, and error correction.", + "confidence": 0.82, + "entities": [ + {"label": "learner", "primitives": ["feedback", "constraint_satisfaction"], "strength": 0.85, "confidence": 0.8}, + {"label": "skill representation", "primitives": ["accumulation", "growth"], "strength": 0.75, "confidence": 0.8}, + ], + "forces": [ + {"label": "error feedback", "primitives": ["feedback", "resistance"], "strength": 0.9, "confidence": 0.85}, + {"label": "practice accumulation", "primitives": ["growth", "accumulation"], "strength": 0.8, "confidence": 0.8}, + ], + "constraints": [ + {"label": "attention constraint", "primitives": ["constraint_satisfaction", "flow"], "strength": 0.7, "confidence": 0.75}, + {"label": "prior knowledge lock", "primitives": ["lock", "local_minimum"], "strength": 0.65, "confidence": 0.7}, + ], + "flows": [ + {"label": "information flow", "primitives": ["flow", "propagation"], "strength": 0.8, "confidence": 0.8}, + ], + "thresholds": [ + {"label": "mastery threshold", "primitives": ["threshold", "phase_transition"], "strength": 0.7, "confidence": 0.75}, + ], + "attractors": [ + {"label": "habit attractor", "primitives": ["attractor", "local_minimum"], "strength": 0.7, "confidence": 0.75}, + ], + "failure_modes": [ + {"label": "mislearning lock-in", "primitives": ["lock", "feedback", "local_minimum"], "strength": 0.75, "confidence": 0.75}, + ], + "similar_systems": [ + {"label": "muscle training", "primitives": ["growth", "feedback", "threshold"], "strength": 0.55, "confidence": 0.7}, + ], + "breakpoints": [ + {"label": "semantic interpretation", "description": "Human learning can depend on conscious meaning and strategy, not only repetition and load.", "primitives": ["feedback", "constraint_satisfaction"], "strength": 0.8, "confidence": 0.8}, + ], + "testable_predictions": [ + {"label": "timely feedback accelerates correction", "primitives": ["feedback", "growth"], "strength": 0.8, "confidence": 0.8}, + ], + }, + "operating_system": { + "concept_id": "operating_system", + "name": "Operating System", + "description": "A programmable physical state-transition manager over compute resources, isolation boundaries, scheduling, and IO flows.", + "confidence": 0.88, + "entities": [ + {"label": "process", "primitives": ["flow", "constraint_satisfaction"], "strength": 0.85, "confidence": 0.85}, + {"label": "kernel", "primitives": ["lock", "constraint_satisfaction"], "strength": 0.9, "confidence": 0.9}, + {"label": "hardware resource", "primitives": ["flow", "resistance"], "strength": 0.85, "confidence": 0.85}, + ], + "forces": [ + {"label": "scheduler pressure", "primitives": ["flow", "constraint_satisfaction"], "strength": 0.85, "confidence": 0.85}, + {"label": "resource contention", "primitives": ["compression", "resistance", "interference"], "strength": 0.8, "confidence": 0.85}, + ], + "constraints": [ + {"label": "memory protection lock", "primitives": ["lock", "constraint_satisfaction"], "strength": 0.9, "confidence": 0.9}, + {"label": "permission boundary", "primitives": ["threshold", "lock", "constraint_satisfaction"], "strength": 0.85, "confidence": 0.85}, + ], + "flows": [ + {"label": "io flow", "primitives": ["flow", "propagation"], "strength": 0.8, "confidence": 0.85}, + {"label": "state transition flow", "primitives": ["flow", "phase_transition"], "strength": 0.85, "confidence": 0.85}, + ], + "thresholds": [ + {"label": "deadlock threshold", "primitives": ["threshold", "lock", "collapse"], "strength": 0.75, "confidence": 0.8}, + ], + "attractors": [ + {"label": "stable scheduling equilibrium", "primitives": ["attractor", "constraint_satisfaction"], "strength": 0.65, "confidence": 0.75}, + ], + "failure_modes": [ + {"label": "deadlock collapse", "primitives": ["lock", "collapse"], "strength": 0.8, "confidence": 0.85}, + {"label": "resource starvation", "primitives": ["resistance", "flow", "collapse"], "strength": 0.75, "confidence": 0.8}, + ], + "similar_systems": [ + {"label": "traffic controller", "primitives": ["flow", "threshold", "constraint_satisfaction"], "strength": 0.5, "confidence": 0.7}, + ], + "breakpoints": [ + {"label": "designed discrete semantics", "description": "An operating system enforces explicit programmed transitions rather than continuous natural fields.", "primitives": ["phase_transition", "constraint_satisfaction"], "strength": 0.75, "confidence": 0.85}, + ], + "testable_predictions": [ + {"label": "contention increases latency and starvation risk", "primitives": ["compression", "resistance", "threshold"], "strength": 0.85, "confidence": 0.85}, + ], + }, +} + + +def get_example_concept_field(concept_id: str): + from .model import create_concept_field, normalize_label + + key = normalize_label(concept_id) + if key not in EXAMPLE_CONCEPT_FIELDS: + raise KeyError(f"unknown example concept field: {concept_id}") + return create_concept_field(EXAMPLE_CONCEPT_FIELDS[key]) diff --git a/reasoner/ts_reasoner/constraint_fields/model.py b/reasoner/ts_reasoner/constraint_fields/model.py new file mode 100644 index 0000000..b1ffd60 --- /dev/null +++ b/reasoner/ts_reasoner/constraint_fields/model.py @@ -0,0 +1,740 @@ +"""Deterministic constraint-field data model and verifier operations. + +This module is intentionally small and auditable. It does not call a model, +does not use embeddings, and does not accept analogies without explicit +mechanism overlap plus limits. +""" + +from __future__ import annotations + +import hashlib +import json +import re +from dataclasses import asdict, dataclass, field, replace +from typing import Any + +CONSTRAINT_FIELD_PRIMITIVES: tuple[str, ...] = ( + "gradient", + "threshold", + "feedback", + "oscillation", + "decay", + "growth", + "compression", + "symmetry", + "phase_transition", + "local_minimum", + "attractor", + "resonance", + "interference", + "constraint_satisfaction", + "accumulation", + "flow", + "lock", + "collapse", + "propagation", + "resistance", +) + +FIELD_CATEGORIES: tuple[str, ...] = ( + "entities", + "forces", + "constraints", + "flows", + "thresholds", + "attractors", + "failure_modes", + "similar_systems", + "breakpoints", + "testable_predictions", +) + +CATEGORY_WEIGHTS: dict[str, float] = { + "entities": 0.8, + "forces": 1.2, + "constraints": 1.2, + "flows": 1.0, + "thresholds": 1.1, + "attractors": 1.0, + "failure_modes": 1.1, + "similar_systems": 0.3, + "breakpoints": 0.6, + "testable_predictions": 0.6, +} + +TEXT_PRIMITIVE_HINTS: dict[str, tuple[str, ...]] = { + "gradient": ("gradient", "slope", "field", "potential", "distance"), + "threshold": ("threshold", "limit", "tipping", "critical", "boundary"), + "feedback": ("feedback", "loop", "reinforce", "correction", "response"), + "oscillation": ("oscillation", "cycle", "rhythm", "alternat"), + "decay": ("decay", "decrease", "fade", "attenuat", "distance"), + "growth": ("growth", "increase", "compound", "scale", "learn"), + "compression": ("compression", "pressure", "compress", "constrain"), + "symmetry": ("symmetry", "invariant", "conservation"), + "phase_transition": ("phase", "transition", "tipping", "state change"), + "local_minimum": ("local minimum", "stuck", "trap", "optimum"), + "attractor": ("attractor", "attract", "pull", "orbit", "center"), + "resonance": ("resonance", "amplify", "synchronize", "sync"), + "interference": ("interference", "cancel", "conflict"), + "constraint_satisfaction": ( + "constraint", + "satisfy", + "valid", + "compatible", + "invariant", + ), + "accumulation": ("accumulation", "accumulate", "stock", "debt", "backlog"), + "flow": ("flow", "transfer", "exchange", "throughput", "movement"), + "lock": ("lock", "locked", "binding", "commitment", "deadlock"), + "collapse": ("collapse", "failure", "default", "breakdown", "crash"), + "propagation": ("propagation", "spread", "transmit", "cascade"), + "resistance": ("resistance", "friction", "drag", "opposition", "cost"), +} + + +def _clamp01(value: Any, default: float = 0.5) -> float: + try: + numeric = float(value) + except (TypeError, ValueError): + numeric = default + return max(0.0, min(1.0, numeric)) + + +def normalize_label(value: str) -> str: + normalized = re.sub(r"[^a-z0-9]+", "_", value.strip().lower()) + return normalized.strip("_") + + +def stable_hash(payload: Any) -> str: + raw = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True) + return hashlib.sha256(raw.encode("utf-8")).hexdigest() + + +def _infer_primitives(label: str, description: str, notes: str = "") -> list[str]: + haystack = f"{label} {description} {notes}".lower() + primitives = [ + primitive + for primitive, hints in TEXT_PRIMITIVE_HINTS.items() + if any(hint in haystack for hint in hints) + ] + return sorted(set(primitives)) + + +def _normalize_primitives(values: Any, label: str, description: str, notes: str) -> list[str]: + if values is None: + candidates: list[str] = [] + elif isinstance(values, str): + candidates = re.split(r"[,| ]+", values) + else: + candidates = [str(value) for value in values] + + normalized = { + normalize_label(candidate) + for candidate in candidates + if normalize_label(candidate) in CONSTRAINT_FIELD_PRIMITIVES + } + normalized.update(_infer_primitives(label, description, notes)) + return sorted(normalized) + + +def _string_list(values: Any) -> list[str]: + if values is None: + return [] + if isinstance(values, str): + return [values] + return [str(value) for value in values] + + +@dataclass(frozen=True) +class FieldItem: + id: str + label: str + description: str = "" + polarity: str = "neutral" + strength: float = 0.5 + confidence: float = 0.5 + evidence: list[str] = field(default_factory=list) + notes: str = "" + primitives: list[str] = field(default_factory=list) + + def normalized(self) -> "FieldItem": + label = self.label.strip() + description = self.description.strip() + notes = self.notes.strip() + item_id = self.id.strip() or normalize_label(label) + return replace( + self, + id=normalize_label(item_id), + label=label, + description=description, + polarity=normalize_label(self.polarity or "neutral") or "neutral", + strength=_clamp01(self.strength), + confidence=_clamp01(self.confidence), + evidence=[str(item).strip() for item in self.evidence if str(item).strip()], + notes=notes, + primitives=_normalize_primitives( + self.primitives, + label, + description, + notes, + ), + ) + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +@dataclass(frozen=True) +class ConceptField: + concept_id: str + name: str + description: str = "" + entities: list[FieldItem] = field(default_factory=list) + forces: list[FieldItem] = field(default_factory=list) + constraints: list[FieldItem] = field(default_factory=list) + flows: list[FieldItem] = field(default_factory=list) + thresholds: list[FieldItem] = field(default_factory=list) + attractors: list[FieldItem] = field(default_factory=list) + failure_modes: list[FieldItem] = field(default_factory=list) + similar_systems: list[FieldItem] = field(default_factory=list) + breakpoints: list[FieldItem] = field(default_factory=list) + testable_predictions: list[FieldItem] = field(default_factory=list) + confidence: float = 0.5 + receipts: list[dict[str, Any]] = field(default_factory=list) + status: str = "valid" + validation_errors: list[str] = field(default_factory=list) + + def normalized(self) -> "ConceptField": + normalized_categories = { + category: [item.normalized() for item in getattr(self, category)] + for category in FIELD_CATEGORIES + } + concept_id = normalize_label(self.concept_id or self.name) + field_obj = replace( + self, + concept_id=concept_id, + name=self.name.strip(), + description=self.description.strip(), + confidence=_clamp01(self.confidence), + **normalized_categories, + ) + status, errors, confidence = validate_concept_field(field_obj) + return replace( + field_obj, + status=status, + validation_errors=errors, + confidence=min(field_obj.confidence, confidence), + ) + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +def _coerce_item(value: Any, category: str, index: int) -> FieldItem: + if isinstance(value, FieldItem): + return value + if isinstance(value, str): + label = value.strip() + return FieldItem( + id=f"{category}_{index}", + label=label, + description=label, + confidence=0.35, + evidence=[], + ) + if not isinstance(value, dict): + raise ValueError(f"{category}[{index}] must be a mapping or string") + + label = str(value.get("label") or value.get("name") or value.get("id") or "").strip() + if not label: + raise ValueError(f"{category}[{index}] requires a label") + return FieldItem( + id=str(value.get("id") or f"{category}_{index}"), + label=label, + description=str(value.get("description") or ""), + polarity=str(value.get("polarity") or "neutral"), + strength=_clamp01(value.get("strength"), 0.5), + confidence=_clamp01(value.get("confidence"), 0.5), + evidence=_string_list(value.get("evidence")), + notes=str(value.get("notes") or ""), + primitives=value.get("primitives", []), + ) + + +def _coerce_field_mapping(data: dict[str, Any]) -> ConceptField: + concept_id = str(data.get("concept_id") or data.get("id") or data.get("name") or "") + name = str(data.get("name") or concept_id).strip() + if not concept_id or not name: + raise ValueError("concept field requires concept_id or name") + + categories = { + category: [ + _coerce_item(item, category, index) + for index, item in enumerate(data.get(category, []), start=1) + ] + for category in FIELD_CATEGORIES + } + return ConceptField( + concept_id=concept_id, + name=name, + description=str(data.get("description") or ""), + confidence=_clamp01(data.get("confidence"), 0.5), + receipts=list(data.get("receipts", [])), + **categories, + ).normalized() + + +def _parse_text_field(text: str) -> ConceptField: + stripped = text.strip() + if not stripped: + raise ValueError("concept text is empty") + + try: + from .examples import EXAMPLE_CONCEPT_FIELDS + + key = normalize_label(stripped) + if key in EXAMPLE_CONCEPT_FIELDS: + return _coerce_field_mapping(EXAMPLE_CONCEPT_FIELDS[key]) + except ImportError: + pass + + data: dict[str, Any] = {"name": "", "description": "", "confidence": 0.25} + current_category: str | None = None + for raw_line in stripped.splitlines(): + line = raw_line.strip() + if not line: + continue + key, sep, value = line.partition(":") + normalized_key = normalize_label(key) + if sep and normalized_key in {"concept_id", "name", "description"}: + data[normalized_key] = value.strip() + current_category = None + continue + if sep and normalized_key in FIELD_CATEGORIES: + current_category = normalized_key + data.setdefault(current_category, []) + entries = [entry.strip(" -") for entry in re.split(r";", value) if entry.strip(" -")] + data[current_category].extend(entries) + continue + if current_category: + data.setdefault(current_category, []).append(line.strip(" -")) + elif not data["name"]: + data["name"] = line + else: + data["description"] = f"{data['description']} {line}".strip() + + if not data["name"]: + data["name"] = stripped.splitlines()[0].strip() + data["concept_id"] = data.get("concept_id") or data["name"] + return _coerce_field_mapping(data) + + +def validate_concept_field(field_obj: ConceptField) -> tuple[str, list[str], float]: + errors: list[str] = [] + if not field_obj.concept_id: + errors.append("missing concept_id") + if not field_obj.name: + errors.append("missing name") + + populated_categories = [ + category for category in FIELD_CATEGORIES if getattr(field_obj, category) + ] + mechanism_categories = [ + category + for category in ( + "entities", + "forces", + "constraints", + "flows", + "thresholds", + "attractors", + "failure_modes", + ) + if getattr(field_obj, category) + ] + primitive_count = len( + { + primitive + for category in FIELD_CATEGORIES + for item in getattr(field_obj, category) + for primitive in item.primitives + } + ) + if len(mechanism_categories) < 3: + errors.append("fewer than three mechanism categories are populated") + if primitive_count < 3: + errors.append("fewer than three primitives are grounded") + if not field_obj.testable_predictions: + errors.append("no testable predictions") + + if not populated_categories or "missing concept_id" in errors or "missing name" in errors: + return "invalid", errors, 0.0 + if errors: + return "underspecified", errors, 0.25 + return "valid", [], field_obj.confidence + + +def create_concept_field(input_data: Any) -> ConceptField: + """Create a normalized concept field from structured data or bounded text. + + Unknown prose is parsed conservatively and marked underspecified unless it + contains enough explicit mechanism structure. Built-in example ids such as + ``debt`` and ``technical_debt`` resolve to canonical example fields. + """ + + if isinstance(input_data, ConceptField): + return input_data.normalized() + if isinstance(input_data, dict): + return _coerce_field_mapping(input_data) + if isinstance(input_data, str): + return _parse_text_field(input_data) + raise TypeError("concept field input must be a ConceptField, dict, or string") + + +def _field_features(field_obj: ConceptField) -> dict[str, float]: + features: dict[str, float] = {} + for category in FIELD_CATEGORIES: + category_weight = CATEGORY_WEIGHTS[category] + for item in getattr(field_obj, category): + base = category_weight * max(0.05, item.strength) * max(0.05, item.confidence) + label_feature = f"{category}:label:{normalize_label(item.label)}" + features[label_feature] = features.get(label_feature, 0.0) + base * 0.4 + for primitive in item.primitives: + category_feature = f"{category}:primitive:{primitive}" + global_feature = f"primitive:{primitive}" + features[category_feature] = features.get(category_feature, 0.0) + base * 0.8 + features[global_feature] = features.get(global_feature, 0.0) + base * 0.25 + return {key: round(value, 6) for key, value in sorted(features.items())} + + +def field_signature(concept_field: Any) -> dict[str, Any]: + field_obj = create_concept_field(concept_field) + features = _field_features(field_obj) + primitives_by_category = { + category: sorted( + { + primitive + for item in getattr(field_obj, category) + for primitive in item.primitives + } + ) + for category in FIELD_CATEGORIES + } + labels_by_category = { + category: sorted(normalize_label(item.label) for item in getattr(field_obj, category)) + for category in FIELD_CATEGORIES + } + payload = { + "concept_id": field_obj.concept_id, + "name": field_obj.name, + "status": field_obj.status, + "labels_by_category": labels_by_category, + "primitives_by_category": primitives_by_category, + "feature_weights": features, + } + return {**payload, "signature_hash": stable_hash(payload)} + + +def _weighted_jaccard(a: dict[str, float], b: dict[str, float]) -> tuple[float, dict[str, Any]]: + keys = sorted(set(a) | set(b)) + intersection = sum(min(a.get(key, 0.0), b.get(key, 0.0)) for key in keys) + union = sum(max(a.get(key, 0.0), b.get(key, 0.0)) for key in keys) + score = intersection / union if union else 0.0 + return round(score, 6), { + "intersection_weight": round(intersection, 6), + "union_weight": round(union, 6), + "feature_count_a": len(a), + "feature_count_b": len(b), + } + + +def _item_match_score(a: FieldItem, b: FieldItem) -> tuple[float, list[str]]: + shared_primitives = sorted(set(a.primitives) & set(b.primitives)) + primitive_union = sorted(set(a.primitives) | set(b.primitives)) + primitive_score = len(shared_primitives) / len(primitive_union) if primitive_union else 0.0 + label_score = 1.0 if normalize_label(a.label) == normalize_label(b.label) else 0.0 + polarity_score = 0.1 if a.polarity == b.polarity else -0.1 + score = max(0.0, min(1.0, label_score * 0.45 + primitive_score * 0.55 + polarity_score)) + return round(score, 6), shared_primitives + + +def _match_category(a_items: list[FieldItem], b_items: list[FieldItem]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + candidates: list[tuple[float, int, int, list[str]]] = [] + for a_index, a_item in enumerate(a_items): + for b_index, b_item in enumerate(b_items): + score, shared_primitives = _item_match_score(a_item, b_item) + candidates.append((score, a_index, b_index, shared_primitives)) + + matches: list[dict[str, Any]] = [] + used_a: set[int] = set() + used_b: set[int] = set() + for score, a_index, b_index, shared_primitives in sorted(candidates, reverse=True): + if score < 0.28 or a_index in used_a or b_index in used_b: + continue + a_item = a_items[a_index] + b_item = b_items[b_index] + used_a.add(a_index) + used_b.add(b_index) + matches.append( + { + "source": a_item.label, + "target": b_item.label, + "score": score, + "shared_primitives": shared_primitives, + "mechanism": ( + ", ".join(shared_primitives) + if shared_primitives + else "normalized label match" + ), + } + ) + + rejected: list[dict[str, Any]] = [] + for index, item in enumerate(a_items): + if index not in used_a: + rejected.append({"side": "source", "label": item.label, "reason": "no structural match"}) + for index, item in enumerate(b_items): + if index not in used_b: + rejected.append({"side": "target", "label": item.label, "reason": "no structural match"}) + return matches, rejected + + +def _breakpoint_warnings(a: ConceptField, b: ConceptField) -> list[dict[str, Any]]: + warnings: list[dict[str, Any]] = [] + if not a.breakpoints: + warnings.append({"source": a.concept_id, "warning": "missing explicit breakpoints"}) + if not b.breakpoints: + warnings.append({"source": b.concept_id, "warning": "missing explicit breakpoints"}) + for side, field_obj in (("source", a), ("target", b)): + for item in field_obj.breakpoints: + warnings.append( + { + "side": side, + "label": item.label, + "description": item.description, + "strength": item.strength, + "confidence": item.confidence, + "primitives": item.primitives, + } + ) + return warnings + + +def _breakpoint_penalty(a: ConceptField, b: ConceptField) -> float: + explicit = a.breakpoints + b.breakpoints + if not explicit: + return 0.25 + severity = sum(item.strength * item.confidence for item in explicit) / len(explicit) + missing_penalty = 0.08 if not a.breakpoints or not b.breakpoints else 0.0 + return round(min(0.45, severity * 0.32 + missing_penalty), 6) + + +def compare_concept_fields(a: Any, b: Any) -> dict[str, Any]: + source = create_concept_field(a) + target = create_concept_field(b) + signature_a = field_signature(source) + signature_b = field_signature(target) + similarity, score_details = _weighted_jaccard( + signature_a["feature_weights"], + signature_b["feature_weights"], + ) + status_penalty = 0.0 + if source.status != "valid": + status_penalty += 0.2 + if target.status != "valid": + status_penalty += 0.2 + breakpoint_penalty = _breakpoint_penalty(source, target) + divergence = round(min(1.0, 1.0 - similarity + breakpoint_penalty + status_penalty), 6) + + shared: dict[str, list[dict[str, Any]]] = {} + rejected_matches: dict[str, list[dict[str, Any]]] = {} + for category in ( + "entities", + "forces", + "constraints", + "flows", + "thresholds", + "attractors", + "failure_modes", + ): + matches, rejected = _match_category(getattr(source, category), getattr(target, category)) + shared[f"shared_{category}"] = matches + rejected_matches[category] = rejected + + overlap_mechanisms = sorted( + { + primitive + for category_matches in shared.values() + for match in category_matches + for primitive in match["shared_primitives"] + } + ) + explanation = ( + "No explicit structural overlap passed the verifier threshold." + if not overlap_mechanisms + else "Structural overlap is grounded in primitives: " + + ", ".join(overlap_mechanisms) + + "." + ) + receipt = { + "inputs": {"source": source.concept_id, "target": target.concept_id}, + "normalized_fields": { + "source": source.to_dict(), + "target": target.to_dict(), + }, + "matching_logic": { + "method": "deterministic weighted primitive/label overlap", + "category_weights": CATEGORY_WEIGHTS, + "minimum_item_match_score": 0.28, + "accepted_without_embeddings": True, + }, + "score_calculation": { + **score_details, + "raw_similarity": similarity, + "breakpoint_penalty": breakpoint_penalty, + "status_penalty": status_penalty, + "divergence": divergence, + }, + "rejected_matches": rejected_matches, + "final_decision": { + "similarity_score": similarity, + "divergence_score": divergence, + }, + } + return { + **shared, + "similarity_score": similarity, + "divergence_score": divergence, + "overlap_explanation": explanation, + "breakpoint_warnings": _breakpoint_warnings(source, target), + "receipt": receipt, + } + + +def _where_analogy_works(comparison: dict[str, Any]) -> list[str]: + lines: list[str] = [] + for key, matches in comparison.items(): + if not key.startswith("shared_") or key == "shared_failure_modes": + continue + category = key.removeprefix("shared_") + for match in matches: + lines.append( + f"{category}: {match['source']} maps to {match['target']} via {match['mechanism']}" + ) + return lines + + +def _where_analogy_breaks(comparison: dict[str, Any]) -> list[str]: + warnings = comparison["breakpoint_warnings"] + lines = [] + for warning in warnings: + if "label" in warning: + lines.append(f"{warning.get('side', 'field')}: {warning['label']} - {warning.get('description', '')}") + else: + lines.append(f"{warning['source']}: {warning['warning']}") + return lines + + +def _counterexamples(comparison: dict[str, Any]) -> list[str]: + counterexamples = [] + for warning in comparison["breakpoint_warnings"]: + if "label" in warning: + counterexamples.append( + f"Cases dominated by '{warning['label']}' should not inherit the analogy without extra evidence." + ) + if not counterexamples: + counterexamples.append("No explicit breakpoint was supplied, so the analogy cannot be accepted.") + return counterexamples + + +def verify_analogy(source: Any, target: Any) -> dict[str, Any]: + source_field = create_concept_field(source) + target_field = create_concept_field(target) + comparison = compare_concept_fields(source_field, target_field) + works = _where_analogy_works(comparison) + breaks = _where_analogy_breaks(comparison) + counterexamples = _counterexamples(comparison) + mechanisms = sorted( + { + primitive + for key, matches in comparison.items() + if key.startswith("shared_") + for match in matches + for primitive in match["shared_primitives"] + } + ) + prediction_count = len(source_field.testable_predictions) + len(target_field.testable_predictions) + missing_breakpoints = not source_field.breakpoints or not target_field.breakpoints + field_confidence = (source_field.confidence + target_field.confidence) / 2.0 + penalty = _breakpoint_penalty(source_field, target_field) + confidence = round( + comparison["similarity_score"] + * field_confidence + * max(0.0, 1.0 - penalty) + * min(1.0, max(0.4, len(mechanisms) / 5.0)), + 6, + ) + + if source_field.status == "invalid" or target_field.status == "invalid": + decision = "rejected" + elif source_field.status != "valid" or target_field.status != "valid": + decision = "uncertain" + elif not mechanisms or len(works) < 2: + decision = "rejected" + elif not breaks or prediction_count == 0 or missing_breakpoints: + decision = "uncertain" + elif comparison["similarity_score"] >= 0.5 and confidence >= 0.34: + decision = "accepted" + elif comparison["similarity_score"] >= 0.25: + decision = "uncertain" + else: + decision = "rejected" + + receipt = { + "inputs": { + "source": source_field.concept_id, + "target": target_field.concept_id, + }, + "normalized_fields": { + "source": source_field.to_dict(), + "target": target_field.to_dict(), + }, + "matching_logic": comparison["receipt"]["matching_logic"], + "score_calculation": { + **comparison["receipt"]["score_calculation"], + "analogy_confidence": confidence, + "mechanism_count": len(mechanisms), + "prediction_count": prediction_count, + }, + "rejected_matches": comparison["receipt"]["rejected_matches"], + "final_decision": { + "decision": decision, + "confidence": confidence, + }, + } + return { + "decision": decision, + "overlap_mechanisms": mechanisms, + "where_the_analogy_works": works, + "where_the_analogy_breaks": breaks, + "counterexamples": counterexamples, + "confidence": confidence, + "receipt_trail": receipt, + } + + +def export_receipt(result: Any) -> dict[str, Any]: + if isinstance(result, ConceptField): + return { + "inputs": {"concept": result.concept_id}, + "normalized_fields": {"concept": result.to_dict()}, + "matching_logic": "not applicable", + "score_calculation": "not applicable", + "rejected_matches": [], + "final_decision": {"status": result.status, "confidence": result.confidence}, + } + if isinstance(result, dict) and "receipt" in result: + return result["receipt"] + if isinstance(result, dict) and "receipt_trail" in result: + return result["receipt_trail"] + raise TypeError("result does not contain an exportable receipt") diff --git a/reasoner/ts_reasoner/field_reasoning_cli.py b/reasoner/ts_reasoner/field_reasoning_cli.py new file mode 100644 index 0000000..a4f7ed4 --- /dev/null +++ b/reasoner/ts_reasoner/field_reasoning_cli.py @@ -0,0 +1,42 @@ +"""CLI for deterministic TS-AI constraint-field reasoning.""" + +from __future__ import annotations + +import argparse +import json + +from .constraint_fields import compare_concept_fields, export_receipt, verify_analogy + + +def main() -> int: + parser = argparse.ArgumentParser( + description="Compare and verify canonical constraint-field concept examples." + ) + subparsers = parser.add_subparsers(dest="command", required=True) + + compare_parser = subparsers.add_parser("compare", help="Compare two concept fields.") + compare_parser.add_argument("source") + compare_parser.add_argument("target") + compare_parser.add_argument("--receipt", action="store_true", help="Print only the audit receipt.") + + analogy_parser = subparsers.add_parser( + "verify-analogy", + help="Verify whether a source-to-target analogy is structurally valid.", + ) + analogy_parser.add_argument("source") + analogy_parser.add_argument("target") + analogy_parser.add_argument("--receipt", action="store_true", help="Print only the audit receipt.") + + args = parser.parse_args() + if args.command == "compare": + result = compare_concept_fields(args.source, args.target) + else: + result = verify_analogy(args.source, args.target) + + payload = export_receipt(result) if args.receipt else result + print(json.dumps(payload, indent=2, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/reasoner/ts_reasoner/problem_workflow/__init__.py b/reasoner/ts_reasoner/problem_workflow/__init__.py new file mode 100644 index 0000000..e5b408e --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/__init__.py @@ -0,0 +1,65 @@ +"""Bounded structured problem analysis under PRIME v19 authority.""" + +from .authority import ( + ExistingProblemAnalysis, + PreparedProblemAnalysis, + ProblemAnalysisWorkflow, + WorkflowAuthorityKeys, + WorkflowBuildError, + build_problem_workflow_kernel, +) +from .canonical import ( + FLOAT_HEX_TAG, + WorkflowCanonicalizationError, + canonical_tree_is_valid, + canonicalize_source, + contains_native_float, + workflow_stable_hash, +) +from .model import ( + AdviceProtocol, + ProblemSpec, + ProblemSpecError, + WorkflowOutcome, + WorkflowState, +) +from .validators import ( + CONSTRAINT_FIELD_OBLIGATION, + PROBLEM_NODE_KIND, + PROVENANCE_OBLIGATION, + REPRESENTATION_ECONOMICS_OBLIGATION, + WORKFLOW_BOUNDARY_OBLIGATION, + constraint_field_integrity_v1, + provenance_binding_v1, + representation_economics_v1, + workflow_boundary_v1, +) + +__all__ = [ + "AdviceProtocol", + "CONSTRAINT_FIELD_OBLIGATION", + "ExistingProblemAnalysis", + "FLOAT_HEX_TAG", + "PROBLEM_NODE_KIND", + "PROVENANCE_OBLIGATION", + "PreparedProblemAnalysis", + "ProblemAnalysisWorkflow", + "ProblemSpec", + "ProblemSpecError", + "REPRESENTATION_ECONOMICS_OBLIGATION", + "WORKFLOW_BOUNDARY_OBLIGATION", + "WorkflowAuthorityKeys", + "WorkflowBuildError", + "WorkflowCanonicalizationError", + "WorkflowOutcome", + "WorkflowState", + "build_problem_workflow_kernel", + "canonical_tree_is_valid", + "canonicalize_source", + "constraint_field_integrity_v1", + "contains_native_float", + "provenance_binding_v1", + "representation_economics_v1", + "workflow_boundary_v1", + "workflow_stable_hash", +] diff --git a/reasoner/ts_reasoner/problem_workflow/advice.py b/reasoner/ts_reasoner/problem_workflow/advice.py new file mode 100644 index 0000000..6f0d612 --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/advice.py @@ -0,0 +1,283 @@ +"""Proposal-only sealed-v18 advice normalization.""" + +from __future__ import annotations + +from collections.abc import Mapping +from typing import Any + +from .canonical import ( + canonical_tree_is_valid, + canonicalize_source, + workflow_stable_hash, +) +from .model import AdviceProtocol + + +_V18_ARCHIVE_SHA256 = "e8fed342857776a90ec75f1e86bec216374a08be0d9c9eb25d83958088498005" +_V18_MANIFEST_SHA256 = ( + "aa0b131b9b961805937d9c2686d721511e3f74612907daa3cc9ef512a95774cd" +) +_V18_SEALED_SHA256 = "268ca140d5ff26f4c1da4177d422d59c93d7caa184af4d869911cea966da4ae8" +_V18_FREEZE_SHA256 = "7d4531ab3664c0bb20270e5927a6b53f47a70603b45431facfe9ec9aba0b1e3d" +_V18_PARENT_FIELD_SHA256 = ( + "d3a72d0fd5c11e9a50e19e45aff1535e4e9064de6200cb6200408a7626bcb2ea" +) +_V18_MODEL_SHA256 = "c6e6daf0b26ea873c7561020f36bb05f26c3adcc6e3106dcab10d17524604845" +_V18_NUMPY_ARCHIVE_SHA256 = ( + "8cd72ef4d3ab7f152bb477f7d0a00d3989e3cfc577f10db1ed23acc277228889" +) +_V18_TENSOR_SHA256 = "b6eaad261abbb644c4f1113153d6b9657875fe37d89168cba1f76ff3a07bc99f" + + +def _mapping_from_result(value: Any) -> dict[str, Any]: + if isinstance(value, Mapping): + return dict(value) + method = getattr(value, "to_dict", None) + if not callable(method): + raise ValueError("advice result does not expose a mapping") + mapped = method() + if not isinstance(mapped, Mapping): + raise ValueError("advice to_dict result is not a mapping") + return dict(mapped) + + +def _sha256(value: Any) -> bool: + return ( + isinstance(value, str) + and len(value) == 64 + and all(character in "0123456789abcdef" for character in value) + ) + + +def _real_int(value: Any) -> bool: + return isinstance(value, int) and not isinstance(value, bool) + + +def expected_v18_worker_request_hash(text: str, top_k: int) -> str: + return workflow_stable_hash( + { + "schema": "prime-v19-v18-worker-request-v1", + "archive_sha256": _V18_ARCHIVE_SHA256, + "operation": "structural_proposals", + "payload": {"text": text, "top_k": top_k}, + } + ) + + +def _archive_receipt_is_valid(value: Any) -> bool: + return ( + isinstance(value, dict) + and set(value) + == { + "schema", + "status", + "archive_name", + "archive_sha256", + "archive_bytes", + "archive_root", + "manifest_sha256", + "manifest_files", + "zip_entries", + "expanded_bytes", + "sealed_release_sha256", + "scientific_freeze_sha256", + "public_version", + "semantic_authority", + } + and value["schema"] == "prime-v19-v18-archive-receipt-v1" + and value["status"] == "VERIFIED_EXACT_SEALED_PARENT" + and value["archive_name"] == "prime-v18-v1.0.0.zip" + and value["archive_sha256"] == _V18_ARCHIVE_SHA256 + and _real_int(value["archive_bytes"]) + and value["archive_bytes"] == 17_394_063 + and value["archive_root"] == "prime-v18-v1.0.0" + and value["manifest_sha256"] == _V18_MANIFEST_SHA256 + and _real_int(value["manifest_files"]) + and value["manifest_files"] == 148 + and _real_int(value["zip_entries"]) + and value["zip_entries"] == 149 + and _real_int(value["expanded_bytes"]) + and value["expanded_bytes"] == 34_158_295 + and value["sealed_release_sha256"] == _V18_SEALED_SHA256 + and value["scientific_freeze_sha256"] == _V18_FREEZE_SHA256 + and value["public_version"] == "1.0.0" + and value["semantic_authority"] == "NONE" + ) + + +def _mount_receipt_is_valid(value: Any) -> bool: + return ( + isinstance(value, dict) + and set(value) + == {"schema", "status", "archive", "cache_hit", "semantic_authority"} + and value["schema"] == "prime-v19-v18-mount-receipt-v1" + and value["status"] == "MOUNTED_EXACT_READ_ONLY" + and isinstance(value["cache_hit"], bool) + and value["semantic_authority"] == "NONE" + and _archive_receipt_is_valid(value["archive"]) + ) + + +def advice_record_is_valid(record: Any) -> bool: + if not isinstance(record, dict) or set(record) != { + "schema", + "mode", + "semantic_authority", + "semantic_promotions", + "top_k", + "failure_code", + "description", + "proposal_batch", + }: + return False + if ( + record["schema"] != "boggers-sealed-v18-advice-v1" + or record["semantic_authority"] != "NONE" + or not _real_int(record["semantic_promotions"]) + or record["semantic_promotions"] != 0 + or not _real_int(record["top_k"]) + or not 1 <= record["top_k"] <= 32 + or not canonical_tree_is_valid(record) + ): + return False + mode = record["mode"] + if mode == "ABLATED": + return ( + record["failure_code"] is None + and record["description"] is None + and record["proposal_batch"] is None + ) + if mode == "UNAVAILABLE": + return ( + record["failure_code"] == "ADVICE_UNAVAILABLE" + and record["description"] is None + and record["proposal_batch"] is None + ) + if mode != "PRESENT" or record["failure_code"] is not None: + return False + description = record["description"] + batch = record["proposal_batch"] + if not _mount_receipt_is_valid(description) or not isinstance(batch, dict): + return False + expected_batch_keys = { + "schema", + "status", + "semantic_authority", + "semantic_promotions", + "request_hash", + "result_hash", + "source", + "runtime", + "observed_features", + "proposals", + } + if set(batch) != expected_batch_keys: + return False + body = {key: value for key, value in batch.items() if key != "result_hash"} + if ( + batch.get("schema") != "prime-v19-v18-structural-proposals-v1" + or batch.get("status") != "PROVISIONAL_NON_AUTHORITATIVE" + or batch.get("semantic_authority") != "NONE" + or not _real_int(batch.get("semantic_promotions")) + or batch.get("semantic_promotions") != 0 + or not _sha256(batch.get("request_hash")) + or not _sha256(batch.get("result_hash")) + or batch["result_hash"] != workflow_stable_hash(body) + ): + return False + source = batch["source"] + runtime = batch["runtime"] + observed = batch["observed_features"] + if ( + not isinstance(source, dict) + or set(source) + != { + "archive_sha256", + "manifest_sha256", + "model_sha256", + "numpy_archive_sha256", + "parent_field_archive_sha256", + "tensor_sha256", + } + or source["archive_sha256"] != _V18_ARCHIVE_SHA256 + or source["manifest_sha256"] != _V18_MANIFEST_SHA256 + or source["model_sha256"] != _V18_MODEL_SHA256 + or source["numpy_archive_sha256"] != _V18_NUMPY_ARCHIVE_SHA256 + or source["parent_field_archive_sha256"] != _V18_PARENT_FIELD_SHA256 + or source["tensor_sha256"] != _V18_TENSOR_SHA256 + or not isinstance(runtime, dict) + or set(runtime) != {"numpy_version", "python_version"} + or not all( + isinstance(runtime[key], str) and bool(runtime[key]) + for key in ("numpy_version", "python_version") + ) + or not isinstance(observed, list) + or any(not isinstance(feature, str) for feature in observed) + or observed != sorted(set(observed)) + ): + return False + proposals = batch.get("proposals") + if not isinstance(proposals, list) or len(proposals) != record["top_k"]: + return False + seen: set[str] = set() + for rank, proposal in enumerate(proposals, start=1): + if not isinstance(proposal, dict) or set(proposal) != { + "feature", + "rank", + "status", + }: + return False + if ( + not isinstance(proposal["feature"], str) + or proposal["feature"] in seen + or not _real_int(proposal["rank"]) + or proposal["rank"] != rank + or proposal["status"] != "PROVISIONAL_NON_AUTHORITATIVE" + ): + return False + seen.add(proposal["feature"]) + return True + + +def _empty_record(mode: str, failure_code: str | None, top_k: int) -> dict[str, Any]: + return { + "schema": "boggers-sealed-v18-advice-v1", + "mode": mode, + "semantic_authority": "NONE", + "semantic_promotions": 0, + "top_k": top_k, + "failure_code": failure_code, + "description": None, + "proposal_batch": None, + } + + +def collect_advice( + advice: AdviceProtocol | None, text: str, *, top_k: int +) -> dict[str, Any]: + if not _real_int(top_k) or not 1 <= top_k <= 32: + raise ValueError("advice top_k must be an integer from 1 through 32") + if advice is None: + return _empty_record("ABLATED", None, top_k) + try: + description = canonicalize_source(_mapping_from_result(advice.describe())) + batch = canonicalize_source( + _mapping_from_result(advice.propose_structural_features(text, top_k=top_k)) + ) + record = { + "schema": "boggers-sealed-v18-advice-v1", + "mode": "PRESENT", + "semantic_authority": "NONE", + "semantic_promotions": 0, + "top_k": top_k, + "failure_code": None, + "description": description, + "proposal_batch": batch, + } + if not advice_record_is_valid(record): + raise ValueError("sealed-v18 advice crossed the proposal-only boundary") + if batch["request_hash"] != expected_v18_worker_request_hash(text, top_k): + raise ValueError("sealed-v18 advice is bound to a different worker request") + return record + except Exception: + return _empty_record("UNAVAILABLE", "ADVICE_UNAVAILABLE", top_k) diff --git a/reasoner/ts_reasoner/problem_workflow/authority.py b/reasoner/ts_reasoner/problem_workflow/authority.py new file mode 100644 index 0000000..6739ea6 --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/authority.py @@ -0,0 +1,535 @@ +"""PRIME-owned admission path for bounded TS problem analyses.""" + +from __future__ import annotations + +import json +from dataclasses import dataclass +from typing import Any + +from prime_v19 import ( + AuthorityKernel, + AuthorityPolicy, + AuthorityRequest, + Decision, + EvidenceEnvelope, + GraphNode, + GraphPatchProposal, + PatchOperation, + ProposerSpec, + ReplayError, + Scope, + VerifierSpec, + canonical_bytes, +) + +from .advice import collect_advice +from .canonical import workflow_stable_hash +from .model import ( + AdviceProtocol, + ProblemSpec, + ProblemSpecError, + WorkflowOutcome, + WorkflowState, +) +from .projection import focus_from_field, project_constraint_field +from .validators import ( + CONSTRAINT_FIELD_OBLIGATION, + PROBLEM_NODE_KIND, + PROVENANCE_OBLIGATION, + REPRESENTATION_ECONOMICS_OBLIGATION, + WORKFLOW_BOUNDARY_OBLIGATION, + constraint_field_integrity_v1, + expected_mutation_intent, + expected_node_payload, + expected_proposal_metadata, + expected_provenance, + provenance_binding_v1, + representation_economics_v1, + workflow_boundary_v1, +) + + +WORKFLOW_PROPOSER_ID = "boggers.ts.problem-analysis-proposer" +_EVIDENCE_OBLIGATIONS = ( + WORKFLOW_BOUNDARY_OBLIGATION, + CONSTRAINT_FIELD_OBLIGATION, + PROVENANCE_OBLIGATION, +) + + +class WorkflowBuildError(RuntimeError): + """The bounded request could not be constructed safely.""" + + +class ExistingProblemAnalysis(WorkflowBuildError): + """The content-addressed problem analysis already exists.""" + + +@dataclass(frozen=True, slots=True) +class WorkflowAuthorityKeys: + """Caller-owned boot keys; no key material is provided by this package.""" + + authority_key_id: str + authority_signing_key: bytes + proposer_key_id: str + proposer_signing_key: bytes + workflow_verifier_key_id: str + workflow_verifier_signing_key: bytes + field_verifier_key_id: str + field_verifier_signing_key: bytes + provenance_verifier_key_id: str + provenance_verifier_signing_key: bytes + economics_verifier_key_id: str + economics_verifier_signing_key: bytes + + +@dataclass(frozen=True, slots=True) +class PreparedProblemAnalysis: + spec: ProblemSpec + problem_spec_hash: str + node_id: str + _node_payload_json: str + request: AuthorityRequest + trace: tuple[WorkflowState, ...] + + @property + def node_payload(self) -> dict[str, Any]: + value = json.loads(self._node_payload_json) + if not isinstance(value, dict): + raise WorkflowBuildError("stored problem node payload is invalid") + return value + + +def _verifier_spec( + *, + obligation_id: str, + verifier_id: str, + verifier_key_id: str, + signing_key: bytes, + validator: Any, + scopes: tuple[Scope, ...], + alpha_cost: int, + resource_cost: int, +) -> VerifierSpec: + return VerifierSpec.create( + obligation_id=obligation_id, + verifier_id=verifier_id, + verifier_version="19.1", + verifier_key_id=verifier_key_id, + accepted_scopes=scopes, + alpha_cost=alpha_cost, + resource_cost=resource_cost, + validator=validator, + signing_key=signing_key, + verifier_config={"obligation_id": obligation_id}, + ) + + +def build_problem_workflow_kernel( + *, + graph_lineage_id: str, + keys: WorkflowAuthorityKeys, + initial_alpha: int = 100_000, + initial_resources: int = 100_000, + checkpoint: bytes | str | None = None, +) -> AuthorityKernel: + """Build an explicitly scoped kernel from caller-supplied identities/keys.""" + + semantic_scope = (Scope.DETERMINISTIC_SEMANTIC_COMMIT,) + verifier_specs = ( + _verifier_spec( + obligation_id=WORKFLOW_BOUNDARY_OBLIGATION, + verifier_id="boggers.ts.workflow-boundary-verifier", + verifier_key_id=keys.workflow_verifier_key_id, + signing_key=keys.workflow_verifier_signing_key, + validator=workflow_boundary_v1, + scopes=semantic_scope, + alpha_cost=1, + resource_cost=1, + ), + _verifier_spec( + obligation_id=CONSTRAINT_FIELD_OBLIGATION, + verifier_id="boggers.ts.constraint-field-verifier", + verifier_key_id=keys.field_verifier_key_id, + signing_key=keys.field_verifier_signing_key, + validator=constraint_field_integrity_v1, + scopes=semantic_scope, + alpha_cost=1, + resource_cost=2, + ), + _verifier_spec( + obligation_id=PROVENANCE_OBLIGATION, + verifier_id="boggers.ts.provenance-binding-verifier", + verifier_key_id=keys.provenance_verifier_key_id, + signing_key=keys.provenance_verifier_signing_key, + validator=provenance_binding_v1, + scopes=semantic_scope, + alpha_cost=1, + resource_cost=1, + ), + _verifier_spec( + obligation_id=REPRESENTATION_ECONOMICS_OBLIGATION, + verifier_id="boggers.ts.representation-economics-denial-verifier", + verifier_key_id=keys.economics_verifier_key_id, + signing_key=keys.economics_verifier_signing_key, + validator=representation_economics_v1, + scopes=(Scope.REPRESENTATION_TRANSITION,), + alpha_cost=1, + resource_cost=1, + ), + ) + policy = AuthorityPolicy.create( + version="boggers-ts-problem-workflow-policy-v19.1", + mandatory_obligations=(WORKFLOW_BOUNDARY_OBLIGATION,), + scope_obligations={ + Scope.DETERMINISTIC_SEMANTIC_COMMIT: (), + Scope.REPRESENTATION_TRANSITION: (REPRESENTATION_ECONOMICS_OBLIGATION,), + }, + authority_class_obligations={ + "semantic": _EVIDENCE_OBLIGATIONS, + "representation": (REPRESENTATION_ECONOMICS_OBLIGATION,), + }, + node_kind_authority_classes={PROBLEM_NODE_KIND: "semantic"}, + edge_kind_authority_classes={}, + node_payload_key_authority_classes={ + "bytecode": "representation", + "code": "representation", + "executable": "representation", + "representation": "representation", + "representation_transition": "representation", + }, + edge_payload_key_authority_classes={}, + representation_authority_class="representation", + representation_economics_obligation=REPRESENTATION_ECONOMICS_OBLIGATION, + minimum_representation_gain_bits=1, + max_operations=1, + initial_alpha=initial_alpha, + initial_resources=initial_resources, + ) + proposer = ProposerSpec.create( + proposer_id=WORKFLOW_PROPOSER_ID, + proposer_key_id=keys.proposer_key_id, + accepted_scopes=semantic_scope, + signing_key=keys.proposer_signing_key, + ) + bootstrap = { + "proposer_specs": (proposer,), + "verifier_specs": verifier_specs, + "policy": policy, + "authority_key_id": keys.authority_key_id, + "authority_signing_key": keys.authority_signing_key, + } + if checkpoint is not None: + try: + restored = AuthorityKernel.restore_checkpoint(checkpoint, **bootstrap) + except ReplayError as exc: + raise WorkflowBuildError("checkpoint restore audit failed") from exc + if restored.context.graph_lineage_id != graph_lineage_id: + raise WorkflowBuildError( + "restored checkpoint graph lineage differs from the requested lineage" + ) + empty_auditor = AuthorityKernel( + graph_lineage_id=graph_lineage_id, + **bootstrap, + ) + try: + replay = empty_auditor.audit_replay(restored.ledger) + except ReplayError as exc: + raise WorkflowBuildError( + "checkpoint cannot be replayed from the required empty genesis" + ) from exc + restored_context = restored.context + if ( + replay.snapshot != restored.snapshot + or replay.ledger_tip != restored_context.parent_authority_hash + or replay.next_sequence != restored_context.next_sequence + or replay.alpha_remaining != restored_context.alpha_remaining + or replay.resources_remaining != restored_context.resources_remaining + ): + raise WorkflowBuildError( + "checkpoint state differs from an exact empty-genesis audit replay" + ) + return restored + return AuthorityKernel( + graph_lineage_id=graph_lineage_id, + **bootstrap, + ) + + +class ProblemAnalysisWorkflow: + """One structured ProblemSpec -> one PRIME authority request.""" + + def __init__( + self, + kernel: AuthorityKernel, + *, + proposer_key_id: str, + proposer_signing_key: bytes, + proposer_id: str = WORKFLOW_PROPOSER_ID, + ) -> None: + if kernel is None: + raise ValueError("kernel cannot be None") + if not proposer_id or not proposer_key_id: + raise ValueError("proposer identities cannot be empty") + if ( + not isinstance(proposer_signing_key, bytes) + or len(proposer_signing_key) < 32 + or len(set(proposer_signing_key)) < 8 + ): + raise ValueError("proposer signing key must contain 32 nontrivial bytes") + self._kernel = kernel + self._proposer_id = proposer_id + self._proposer_key_id = proposer_key_id + self._proposer_signing_key = bytes(proposer_signing_key) + + @property + def kernel(self) -> AuthorityKernel: + return self._kernel + + def prepare_request( + self, + problem: ProblemSpec | dict[str, Any], + *, + advice: AdviceProtocol | None = None, + advice_top_k: int = 5, + ) -> PreparedProblemAnalysis: + trace = [WorkflowState.READY] + spec = ProblemSpec.from_value(problem) + spec_payload = spec.to_dict() + problem_spec_hash = workflow_stable_hash(spec_payload) + trace.append(WorkflowState.BOUND) + + field = project_constraint_field(spec_payload) + constraint_field_hash = workflow_stable_hash(field) + trace.append(WorkflowState.FIELD_READY) + + focus = focus_from_field(field) + focus_hash = workflow_stable_hash(focus) + trace.append(WorkflowState.FOCUSED) + + advice_record = collect_advice( + advice, + spec.question, + top_k=advice_top_k, + ) + advice_hash = workflow_stable_hash(advice_record) + trace.append(WorkflowState.PROPOSED) + + context = self._kernel.context + snapshot = self._kernel.snapshot + node_id = f"ts.problem_analysis:{problem_spec_hash}" + if snapshot.node(node_id) is not None: + raise ExistingProblemAnalysis(node_id) + parent_binding = { + "graph_lineage_id": context.graph_lineage_id, + "parent_root": context.current_root, + "parent_authority_hash": context.parent_authority_hash, + "expected_sequence": context.next_sequence, + } + trace.append(WorkflowState.ROUTED) + + evidence: dict[str, Any] = { + "schema": "boggers-ts-problem-evidence-v1", + "obligation_id": "", + "proposal_hash": "", + "problem_spec": spec_payload, + "problem_spec_hash": problem_spec_hash, + "constraint_field": field, + "constraint_field_hash": constraint_field_hash, + "focus": focus, + "focus_hash": focus_hash, + "advice": advice_record, + "advice_hash": advice_hash, + "provenance": {}, + "provenance_hash": "", + "parent_binding": parent_binding, + "node_id": node_id, + "node_kind": PROBLEM_NODE_KIND, + "node_payload": {}, + "node_payload_hash": "", + "mutation_intent": {}, + "mutation_intent_hash": "", + } + provenance = expected_provenance(evidence) + evidence["provenance"] = provenance + evidence["provenance_hash"] = workflow_stable_hash(provenance) + node_payload = expected_node_payload(evidence) + evidence["node_payload"] = node_payload + evidence["node_payload_hash"] = workflow_stable_hash(node_payload) + mutation_intent = expected_mutation_intent(evidence) + evidence["mutation_intent"] = mutation_intent + evidence["mutation_intent_hash"] = workflow_stable_hash(mutation_intent) + + node = GraphNode.create(node_id, PROBLEM_NODE_KIND, node_payload) + proposal = GraphPatchProposal.create( + graph_lineage_id=context.graph_lineage_id, + scope=Scope.DETERMINISTIC_SEMANTIC_COMMIT, + proposer_id=self._proposer_id, + proposer_key_id=self._proposer_key_id, + proposer_signing_key=self._proposer_signing_key, + parent_root=context.current_root, + parent_authority_hash=context.parent_authority_hash, + expected_sequence=context.next_sequence, + mutation_intent_hash=evidence["mutation_intent_hash"], + provenance_hash=evidence["provenance_hash"], + affected_nodes=(node_id,), + operations=(PatchOperation.upsert_node(node),), + metadata=expected_proposal_metadata(evidence), + ) + evidence["proposal_hash"] = proposal.proposal_hash + request = AuthorityRequest.create( + proposal, + ( + EvidenceEnvelope.create( + obligation, + {**evidence, "obligation_id": obligation}, + ) + for obligation in _EVIDENCE_OBLIGATIONS + ), + ) + trace.append(WorkflowState.REQUEST_READY) + return PreparedProblemAnalysis( + spec=spec, + problem_spec_hash=problem_spec_hash, + node_id=node_id, + _node_payload_json=canonical_bytes(node_payload).decode("utf-8"), + request=request, + trace=tuple(trace), + ) + + def analyze( + self, + problem: ProblemSpec | dict[str, Any], + *, + advice: AdviceProtocol | None = None, + advice_top_k: int = 5, + ) -> WorkflowOutcome: + initial_root = self._kernel.snapshot.root + try: + prepared = self.prepare_request( + problem, + advice=advice, + advice_top_k=advice_top_k, + ) + except ProblemSpecError as exc: + return WorkflowOutcome( + state=WorkflowState.ABSTAINED, + trace=(WorkflowState.READY, WorkflowState.ABSTAINED), + reason_codes=(f"invalid_problem_spec:{type(exc).__name__}",), + request_created=False, + problem_spec_hash="", + node_id="", + previous_root=initial_root, + new_root=self._kernel.snapshot.root, + receipt=None, + receipt_verified=False, + live_state_verified=self._kernel.verify_live_state(), + ) + except ExistingProblemAnalysis as exc: + return WorkflowOutcome( + state=WorkflowState.ABSTAINED, + trace=( + WorkflowState.READY, + WorkflowState.BOUND, + WorkflowState.ABSTAINED, + ), + reason_codes=("analysis_already_exists",), + request_created=False, + problem_spec_hash="", + node_id=str(exc), + previous_root=initial_root, + new_root=self._kernel.snapshot.root, + receipt=None, + receipt_verified=False, + live_state_verified=self._kernel.verify_live_state(), + ) + except Exception as exc: + return WorkflowOutcome( + state=WorkflowState.FAIL_CLOSED, + trace=(WorkflowState.READY, WorkflowState.FAIL_CLOSED), + reason_codes=(f"request_build_failed:{type(exc).__name__}",), + request_created=False, + problem_spec_hash="", + node_id="", + previous_root=initial_root, + new_root=self._kernel.snapshot.root, + receipt=None, + receipt_verified=False, + live_state_verified=self._kernel.verify_live_state(), + ) + + trace = (*prepared.trace, WorkflowState.SUBMITTED) + try: + receipt = self._kernel.authorize_and_commit(prepared.request) + except Exception as exc: + return WorkflowOutcome( + state=WorkflowState.FAIL_CLOSED, + trace=(*trace, WorkflowState.FAIL_CLOSED), + reason_codes=(f"authority_call_failed:{type(exc).__name__}",), + request_created=True, + problem_spec_hash=prepared.problem_spec_hash, + node_id=prepared.node_id, + previous_root=initial_root, + new_root=self._kernel.snapshot.root, + receipt=None, + receipt_verified=False, + live_state_verified=self._kernel.verify_live_state(), + ) + + receipt_verified = self._kernel.verify_receipt(receipt) + live_state_verified = self._kernel.verify_live_state() + binding_verified = ( + receipt.request_hash == prepared.request.request_hash + and receipt.proposal.proposal_hash + == prepared.request.proposal.proposal_hash + ) + snapshot = self._kernel.snapshot + reason_codes = tuple(str(reason) for reason in receipt.reason_codes) + if not receipt_verified or not live_state_verified or not binding_verified: + return WorkflowOutcome( + state=WorkflowState.FAIL_CLOSED, + trace=(*trace, WorkflowState.FAIL_CLOSED), + reason_codes=(*reason_codes, "post_authority_verification_failed"), + request_created=True, + problem_spec_hash=prepared.problem_spec_hash, + node_id=prepared.node_id, + previous_root=receipt.previous_root, + new_root=receipt.new_root, + receipt=receipt, + receipt_verified=receipt_verified, + live_state_verified=live_state_verified, + ) + + if receipt.decision is Decision.AUTHORIZE: + node = snapshot.node(prepared.node_id) + exact_node = ( + node is not None + and node.kind == PROBLEM_NODE_KIND + and node.payload == prepared.node_payload + and receipt.ledgered + ) + state = WorkflowState.COMMITTED if exact_node else WorkflowState.FAIL_CLOSED + if not exact_node: + reason_codes = (*reason_codes, "authorized_state_binding_failed") + else: + no_effect = receipt.previous_root == receipt.new_root + if not no_effect: + state = WorkflowState.FAIL_CLOSED + reason_codes = (*reason_codes, "denial_changed_canonical_root") + elif receipt.decision is Decision.REJECT: + state = WorkflowState.REJECTED + else: + state = WorkflowState.ABSTAINED + return WorkflowOutcome( + state=state, + trace=(*trace, state), + reason_codes=reason_codes, + request_created=True, + problem_spec_hash=prepared.problem_spec_hash, + node_id=prepared.node_id, + previous_root=receipt.previous_root, + new_root=receipt.new_root, + receipt=receipt, + receipt_verified=receipt_verified, + live_state_verified=live_state_verified, + ) diff --git a/reasoner/ts_reasoner/problem_workflow/canonical.py b/reasoner/ts_reasoner/problem_workflow/canonical.py new file mode 100644 index 0000000..d414361 --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/canonical.py @@ -0,0 +1,182 @@ +"""Fail-closed canonicalization for the bounded problem workflow. + +PRIME deliberately rejects native floats. Constraint-field code still uses +Python floats internally, so this boundary converts each finite value to its +exact hexadecimal representation before any value reaches PRIME. +""" + +from __future__ import annotations + +import math +import unicodedata +from collections.abc import Mapping, Sequence +from enum import Enum +from hashlib import sha256 +from typing import Any + + +FLOAT_HEX_TAG = "$ts_float_hex" +_RESERVED_SOURCE_KEYS = frozenset({FLOAT_HEX_TAG}) + + +class WorkflowCanonicalizationError(ValueError): + """A source value cannot be represented without ambiguity.""" + + +def _nfc_text(value: str) -> str: + if value != unicodedata.normalize("NFC", value): + raise WorkflowCanonicalizationError("strings must already be NFC-normalized") + if "\x00" in value: + raise WorkflowCanonicalizationError("NUL bytes are forbidden") + return value + + +def canonicalize_source(value: Any) -> Any: + """Return a detached PRIME-safe value. + + Reserved numeric-tag keys are rejected at the source boundary. They can + only be emitted by this function while converting an actual finite float. + """ + + if isinstance(value, Enum): + return canonicalize_source(value.value) + if value is None or isinstance(value, bool) or isinstance(value, int): + return value + if isinstance(value, str): + return _nfc_text(value) + if isinstance(value, float): + if not math.isfinite(value): + raise WorkflowCanonicalizationError("non-finite floats are forbidden") + return {FLOAT_HEX_TAG: value.hex()} + if isinstance(value, Mapping): + result: dict[str, Any] = {} + for key, item in value.items(): + if not isinstance(key, str): + raise WorkflowCanonicalizationError("object keys must be strings") + canonical_key = _nfc_text(key) + if canonical_key in _RESERVED_SOURCE_KEYS: + raise WorkflowCanonicalizationError( + f"reserved canonical key is forbidden in source data: {canonical_key}" + ) + if canonical_key in result: + raise WorkflowCanonicalizationError("duplicate canonical object key") + result[canonical_key] = canonicalize_source(item) + return result + if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)): + return [canonicalize_source(item) for item in value] + raise WorkflowCanonicalizationError( + f"unsupported source value: {type(value).__name__}" + ) + + +def canonical_tree_is_valid(value: Any) -> bool: + """Pure recursive verifier for an already converted canonical tree.""" + + if value is None or isinstance(value, bool) or isinstance(value, int): + return True + if isinstance(value, str): + return value == unicodedata.normalize("NFC", value) and "\x00" not in value + if isinstance(value, float): + return False + if isinstance(value, list): + return all(canonical_tree_is_valid(item) for item in value) + if not isinstance(value, dict): + return False + if any(not isinstance(key, str) for key in value): + return False + if any(key != unicodedata.normalize("NFC", key) or "\x00" in key for key in value): + return False + if FLOAT_HEX_TAG in value: + if set(value) != {FLOAT_HEX_TAG}: + return False + encoded = value[FLOAT_HEX_TAG] + if not isinstance(encoded, str): + return False + try: + decoded = float.fromhex(encoded) + except ValueError: + return False + return math.isfinite(decoded) and decoded.hex() == encoded + return all(canonical_tree_is_valid(item) for item in value.values()) + + +def contains_native_float(value: Any) -> bool: + """Return whether a nested value still contains any native float.""" + + if isinstance(value, float): + return True + if isinstance(value, dict): + return any(contains_native_float(item) for item in value.values()) + if isinstance(value, (list, tuple)): + return any(contains_native_float(item) for item in value) + return False + + +def restore_source_floats(value: Any) -> Any: + """Decode only well-formed workflow float tags into detached native values.""" + + if isinstance(value, list): + return [restore_source_floats(item) for item in value] + if not isinstance(value, dict): + return value + if set(value) == {FLOAT_HEX_TAG} and canonical_tree_is_valid(value): + return float.fromhex(value[FLOAT_HEX_TAG]) + return {key: restore_source_floats(item) for key, item in value.items()} + + +def _json_string(value: str) -> str: + pieces = ['"'] + escapes = { + '"': '\\"', + "\\": "\\\\", + "\b": "\\b", + "\f": "\\f", + "\n": "\\n", + "\r": "\\r", + "\t": "\\t", + } + for character in value: + escaped = escapes.get(character) + if escaped is not None: + pieces.append(escaped) + elif ord(character) < 0x20: + pieces.append(f"\\u{ord(character):04x}") + else: + pieces.append(character) + pieces.append('"') + return "".join(pieces) + + +def canonical_tree_text(value: Any) -> str: + """Encode a verified tree with PRIME's exact canonical JSON rules.""" + + if value is None: + return "null" + if value is True: + return "true" + if value is False: + return "false" + if isinstance(value, int): + return str(value) + if isinstance(value, str): + return _json_string(value) + if isinstance(value, list): + return "[" + ",".join(canonical_tree_text(item) for item in value) + "]" + if isinstance(value, dict): + return ( + "{" + + ",".join( + _json_string(key) + ":" + canonical_tree_text(value[key]) + for key in sorted(value) + ) + + "}" + ) + raise WorkflowCanonicalizationError("value is not a canonical workflow tree") + + +def workflow_stable_hash(value: Any) -> str: + """Hash a canonical tree without a dynamic JSON encoder dependency.""" + + if not canonical_tree_is_valid(value): + raise WorkflowCanonicalizationError("cannot hash an invalid canonical tree") + return sha256(canonical_tree_text(value).encode("utf-8")).hexdigest() diff --git a/reasoner/ts_reasoner/problem_workflow/model.py b/reasoner/ts_reasoner/problem_workflow/model.py new file mode 100644 index 0000000..efe6ce7 --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/model.py @@ -0,0 +1,248 @@ +"""Immutable public contracts for the bounded TS problem workflow.""" + +from __future__ import annotations + +import json +import re +import unicodedata +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from enum import Enum +from typing import Any, Protocol + +from prime_v19 import canonical_bytes + +from .canonical import ( + canonical_tree_is_valid, + canonicalize_source, + restore_source_floats, +) + + +PROBLEM_SPEC_SCHEMA = "boggers-ts-problem-spec-v1" +_PROBLEM_ID = re.compile(r"[a-z0-9][a-z0-9_]{0,127}") +_MAX_TEXT_BYTES = 4 * 1024 +_MAX_ITEMS = 32 +_MAX_SPEC_BYTES = 32 * 1024 + + +class ProblemSpecError(ValueError): + """A problem specification is invalid or exceeds its bound.""" + + +class WorkflowState(str, Enum): + READY = "READY" + BOUND = "BOUND" + FIELD_READY = "FIELD_READY" + FOCUSED = "FOCUSED" + PROPOSED = "PROPOSED" + ROUTED = "ROUTED" + REQUEST_READY = "REQUEST_READY" + SUBMITTED = "SUBMITTED" + COMMITTED = "COMMITTED" + REJECTED = "REJECTED" + ABSTAINED = "ABSTAINED" + FAIL_CLOSED = "FAIL_CLOSED" + + +def _bounded_text(value: Any, label: str, *, allow_empty: bool = False) -> str: + if not isinstance(value, str): + raise ProblemSpecError(f"{label} must be text") + if value != unicodedata.normalize("NFC", value) or "\x00" in value: + raise ProblemSpecError(f"{label} must be NUL-free NFC text") + normalized = value.strip() + if not normalized and not allow_empty: + raise ProblemSpecError(f"{label} cannot be empty") + if len(normalized.encode("utf-8")) > _MAX_TEXT_BYTES: + raise ProblemSpecError(f"{label} exceeds {_MAX_TEXT_BYTES} UTF-8 bytes") + return normalized + + +def _bounded_items(value: Any, label: str, *, required: bool) -> tuple[str, ...]: + if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence): + raise ProblemSpecError(f"{label} must be a sequence of strings") + if len(value) > _MAX_ITEMS or (required and not value): + qualifier = "one through" if required else "zero through" + raise ProblemSpecError(f"{label} must contain {qualifier} {_MAX_ITEMS} items") + result = tuple( + _bounded_text(item, f"{label}[{index}]") for index, item in enumerate(value) + ) + if len(set(result)) != len(result): + raise ProblemSpecError(f"{label} must not contain duplicates") + return result + + +@dataclass(frozen=True, slots=True) +class ProblemSpec: + """One bounded, structured problem statement. + + Mutable source mappings are serialized immediately. Properties decode a + fresh detached object, so later caller mutation cannot change a proposal. + """ + + problem_id: str + question: str + context: tuple[str, ...] + constraints: tuple[str, ...] + desired_outcomes: tuple[str, ...] + failure_modes: tuple[str, ...] + testable_predictions: tuple[str, ...] + scope: str + provenance_json: str + schema: str = PROBLEM_SPEC_SCHEMA + + @classmethod + def create( + cls, + *, + problem_id: str, + question: str, + constraints: Sequence[str], + desired_outcomes: Sequence[str], + failure_modes: Sequence[str], + testable_predictions: Sequence[str], + scope: str, + provenance: Mapping[str, Any], + context: Sequence[str] = (), + ) -> "ProblemSpec": + problem_id = _bounded_text(problem_id, "problem_id") + if _PROBLEM_ID.fullmatch(problem_id) is None: + raise ProblemSpecError("problem_id is not a portable identifier") + if not isinstance(provenance, Mapping): + raise ProblemSpecError("provenance must be a mapping") + try: + detached_provenance = canonicalize_source(provenance) + provenance_json = canonical_bytes(detached_provenance).decode("utf-8") + except (TypeError, ValueError) as exc: + raise ProblemSpecError(f"invalid provenance: {exc}") from exc + candidate = cls( + problem_id=problem_id, + question=_bounded_text(question, "question"), + context=_bounded_items(context, "context", required=False), + constraints=_bounded_items(constraints, "constraints", required=True), + desired_outcomes=_bounded_items( + desired_outcomes, "desired_outcomes", required=True + ), + failure_modes=_bounded_items(failure_modes, "failure_modes", required=True), + testable_predictions=_bounded_items( + testable_predictions, "testable_predictions", required=True + ), + scope=_bounded_text(scope, "scope"), + provenance_json=provenance_json, + ) + if len(canonical_bytes(candidate.to_dict())) > _MAX_SPEC_BYTES: + raise ProblemSpecError( + f"canonical problem specification exceeds {_MAX_SPEC_BYTES} bytes" + ) + return candidate + + @classmethod + def from_value(cls, value: "ProblemSpec | Mapping[str, Any]") -> "ProblemSpec": + if isinstance(value, cls): + if value.schema != PROBLEM_SPEC_SCHEMA: + raise ProblemSpecError("unknown problem specification schema") + return cls.create( + problem_id=value.problem_id, + question=value.question, + context=value.context, + constraints=value.constraints, + desired_outcomes=value.desired_outcomes, + failure_modes=value.failure_modes, + testable_predictions=value.testable_predictions, + scope=value.scope, + provenance=restore_source_floats(value.provenance), + ) + if not isinstance(value, Mapping): + raise ProblemSpecError("problem specification must be a mapping") + source_keys = { + "problem_id", + "question", + "context", + "constraints", + "desired_outcomes", + "failure_modes", + "testable_predictions", + "scope", + "provenance", + } + keys = set(value) + if keys == source_keys | {"schema"}: + if value["schema"] != PROBLEM_SPEC_SCHEMA: + raise ProblemSpecError("unknown problem specification schema") + serialized = dict(value) + if not canonical_tree_is_valid(serialized): + raise ProblemSpecError( + "serialized problem specification is not canonical" + ) + source = {key: value[key] for key in source_keys} + source["provenance"] = restore_source_floats(source["provenance"]) + elif keys == source_keys: + source = dict(value) + else: + raise ProblemSpecError("problem specification has unknown or missing keys") + return cls.create(**source) + + @property + def provenance(self) -> dict[str, Any]: + value = json.loads(self.provenance_json) + if not isinstance(value, dict): + raise ProblemSpecError("stored provenance is not an object") + return value + + def to_dict(self) -> dict[str, Any]: + return { + "schema": self.schema, + "problem_id": self.problem_id, + "question": self.question, + "context": list(self.context), + "constraints": list(self.constraints), + "desired_outcomes": list(self.desired_outcomes), + "failure_modes": list(self.failure_modes), + "testable_predictions": list(self.testable_predictions), + "scope": self.scope, + "provenance": self.provenance, + } + + +class AdviceProtocol(Protocol): + """Tiny proposal-only surface implemented by a mounted sealed-v18 client.""" + + def describe(self) -> Any: ... + + def propose_structural_features(self, text: str, *, top_k: int = 5) -> Any: ... + + +@dataclass(frozen=True, slots=True) +class WorkflowOutcome: + state: WorkflowState + trace: tuple[WorkflowState, ...] + reason_codes: tuple[str, ...] + request_created: bool + problem_spec_hash: str + node_id: str + previous_root: str + new_root: str + receipt: Any | None + receipt_verified: bool + live_state_verified: bool + + @property + def committed(self) -> bool: + return self.state is WorkflowState.COMMITTED + + def to_dict(self) -> dict[str, Any]: + return { + "schema": "boggers-ts-problem-workflow-outcome-v1", + "state": self.state.value, + "trace": [state.value for state in self.trace], + "reason_codes": list(self.reason_codes), + "request_created": self.request_created, + "problem_spec_hash": self.problem_spec_hash, + "node_id": self.node_id, + "previous_root": self.previous_root, + "new_root": self.new_root, + "receipt": self.receipt.to_dict() if self.receipt is not None else None, + "receipt_verified": self.receipt_verified, + "live_state_verified": self.live_state_verified, + "committed": self.committed, + } diff --git a/reasoner/ts_reasoner/problem_workflow/projection.py b/reasoner/ts_reasoner/problem_workflow/projection.py new file mode 100644 index 0000000..886169e --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/projection.py @@ -0,0 +1,240 @@ +"""Deterministic constraint-field projection for one structured problem.""" + +from __future__ import annotations + +from typing import Any + +from .canonical import canonicalize_source + + +_CATEGORIES = ( + "entities", + "forces", + "constraints", + "flows", + "thresholds", + "attractors", + "failure_modes", + "similar_systems", + "breakpoints", + "testable_predictions", +) +_HALF_HEX = "0x1.0000000000000p-1" + + +def _item( + item_id: str, + label: str, + description: str, + evidence: list[str], + primitives: list[str], +) -> dict[str, Any]: + return { + "id": item_id, + "label": label, + "description": description, + "polarity": "neutral", + "strength": {"$ts_float_hex": _HALF_HEX}, + "confidence": {"$ts_float_hex": _HALF_HEX}, + "evidence": list(evidence), + "notes": "", + "primitives": sorted(set(primitives)), + } + + +def _projection_rows(spec: dict[str, Any]) -> dict[str, list[dict[str, Any]]]: + entities = [ + _item( + "problem_scope", + "problem_scope", + "bounded problem substrate", + [spec["question"]], + ["constraint_satisfaction"], + ) + ] + entities.extend( + _item( + f"context_{index:03d}", + f"declared_context_{index:03d}", + "declared contextual condition", + [value], + ["constraint_satisfaction"], + ) + for index, value in enumerate(spec["context"], start=1) + ) + forces = [ + _item( + f"desired_outcome_{index:03d}", + f"desired_outcome_{index:03d}", + "declared desired outcome", + [value], + ["attractor", "gradient"], + ) + for index, value in enumerate(spec["desired_outcomes"], start=1) + ] + constraints = [ + _item( + f"declared_constraint_{index:03d}", + f"declared_rule_{index:03d}", + "declared rule", + [value], + ["constraint_satisfaction", "resistance"], + ) + for index, value in enumerate(spec["constraints"], start=1) + ] + flows = [ + _item( + "analysis_wave", + "analysis_wave", + "bounded analysis propagation", + [spec["question"]], + ["flow", "propagation"], + ) + ] + thresholds = [ + _item( + f"acceptance_threshold_{index:03d}", + f"acceptance_threshold_{index:03d}", + "declared acceptance threshold", + [value], + ["constraint_satisfaction", "threshold"], + ) + for index, value in enumerate(spec["testable_predictions"], start=1) + ] + attractors = [ + _item( + f"desired_attractor_{index:03d}", + f"desired_attractor_{index:03d}", + "declared target state", + [value], + ["attractor"], + ) + for index, value in enumerate(spec["desired_outcomes"], start=1) + ] + failure_modes = [ + _item( + f"declared_failure_mode_{index:03d}", + f"declared_failure_mode_{index:03d}", + "declared failure mode", + [value], + ["collapse", "local_minimum"], + ) + for index, value in enumerate(spec["failure_modes"], start=1) + ] + breakpoints = [ + _item( + "scope_breakpoint", + "scope_breakpoint", + "declared boundary of applicability", + [spec["scope"]], + ["resistance", "threshold"], + ) + ] + predictions = [ + _item( + f"testable_prediction_{index:03d}", + f"testable_prediction_{index:03d}", + "declared falsifiable acceptance check", + [value], + ["constraint_satisfaction", "threshold"], + ) + for index, value in enumerate(spec["testable_predictions"], start=1) + ] + return { + "entities": entities, + "forces": forces, + "constraints": constraints, + "flows": flows, + "thresholds": thresholds, + "attractors": attractors, + "failure_modes": failure_modes, + "similar_systems": [], + "breakpoints": breakpoints, + "testable_predictions": predictions, + } + + +def _projection_input(spec: dict[str, Any]) -> dict[str, Any]: + rows = _projection_rows(spec) + native_rows: dict[str, list[dict[str, Any]]] = {} + for category in _CATEGORIES: + native_rows[category] = [] + for row in rows[category]: + native_row = dict(row) + native_row["strength"] = float.fromhex(_HALF_HEX) + native_row["confidence"] = float.fromhex(_HALF_HEX) + native_rows[category].append(native_row) + return { + "concept_id": f"problem_{spec['problem_id']}", + "name": "Bounded TS problem analysis", + "description": "Deterministic projection of a structured problem specification.", + "confidence": float.fromhex(_HALF_HEX), + "receipts": [], + **native_rows, + } + + +def expected_constraint_field(spec: dict[str, Any]) -> dict[str, Any]: + """Pure expected field used by independent PRIME validators.""" + + return { + "concept_id": f"problem_{spec['problem_id']}", + "name": "Bounded TS problem analysis", + "description": "Deterministic projection of a structured problem specification.", + **_projection_rows(spec), + "confidence": {"$ts_float_hex": _HALF_HEX}, + "receipts": [], + "status": "valid", + "validation_errors": [], + } + + +def project_constraint_field(spec: dict[str, Any]) -> dict[str, Any]: + """Project through the existing constraint-field implementation. + + The existing user-owned module remains untouched. The result is detached + and converted at this boundary before it can enter PRIME. + """ + + from ..constraint_fields import create_concept_field + + projected = canonicalize_source( + create_concept_field(_projection_input(spec)).to_dict() + ) + expected = expected_constraint_field(spec) + if projected != expected: + raise ValueError( + "constraint-field implementation diverged from the sealed projection" + ) + return projected + + +def focus_from_field(field: dict[str, Any]) -> dict[str, Any]: + """Derive an exact active frontier without model scores or native floats.""" + + category_loads = {category: len(field[category]) for category in _CATEGORIES} + active_frontier = sorted( + { + primitive + for category in _CATEGORIES + for item in field[category] + for primitive in item["primitives"] + } + ) + tension_markers = sorted( + [item["id"] for item in field["constraints"]] + + [item["id"] for item in field["failure_modes"]] + + [item["id"] for item in field["breakpoints"]] + ) + return { + "schema": "boggers-ts-problem-focus-v1", + "status": "DETERMINISTIC_CONSTRAINT_FIELD_FOCUS", + "active_frontier": active_frontier, + "category_loads": category_loads, + "substrate": { + "field_item_count": sum(category_loads.values()), + "tension_marker_count": len(tension_markers), + "tension_markers": tension_markers, + }, + "wave_trajectory": ["propagate", "relax", "break", "evolve"], + } diff --git a/reasoner/ts_reasoner/problem_workflow/validators.py b/reasoner/ts_reasoner/problem_workflow/validators.py new file mode 100644 index 0000000..0d71bfa --- /dev/null +++ b/reasoner/ts_reasoner/problem_workflow/validators.py @@ -0,0 +1,442 @@ +"""Independent, top-level PRIME verifier callbacks for problem analysis. + +These functions perform no I/O, dynamic import, reflection, or mutation. They +are intentionally ordinary top-level functions so PRIME can fingerprint their +code and every referenced helper at boot. +""" + +from __future__ import annotations + +import unicodedata +from typing import Any + +from prime_v19 import VerifierFinding + +from .advice import ( + advice_record_is_valid, + expected_v18_worker_request_hash, +) +from .canonical import canonical_tree_is_valid, workflow_stable_hash +from .projection import expected_constraint_field, focus_from_field + + +WORKFLOW_BOUNDARY_OBLIGATION = "workflow_boundary_v1" +CONSTRAINT_FIELD_OBLIGATION = "constraint_field_integrity_v1" +PROVENANCE_OBLIGATION = "provenance_binding_v1" +REPRESENTATION_ECONOMICS_OBLIGATION = "representation_economics_v1" +PROBLEM_NODE_KIND = "ts.problem_analysis" +_EVIDENCE_KEYS = frozenset( + { + "schema", + "obligation_id", + "proposal_hash", + "problem_spec", + "problem_spec_hash", + "constraint_field", + "constraint_field_hash", + "focus", + "focus_hash", + "advice", + "advice_hash", + "provenance", + "provenance_hash", + "parent_binding", + "node_id", + "node_kind", + "node_payload", + "node_payload_hash", + "mutation_intent", + "mutation_intent_hash", + } +) +_FORBIDDEN_NODE_KEYS = frozenset( + { + "bytecode", + "code", + "command", + "delete", + "edges", + "executable", + "operations", + "overwrite", + "representation", + "representation_transition", + } +) + + +def _fail(reason: str) -> VerifierFinding: + return VerifierFinding.fail(reason) + + +def _is_sha256(value: Any) -> bool: + return ( + isinstance(value, str) + and len(value) == 64 + and all(character in "0123456789abcdef" for character in value) + ) + + +def _valid_text(value: Any, *, maximum: int = 4096) -> bool: + return ( + isinstance(value, str) + and bool(value) + and value == value.strip() + and "\x00" not in value + and value == unicodedata.normalize("NFC", value) + and len(value.encode("utf-8")) <= maximum + ) + + +def _valid_text_list(value: Any, *, required: bool) -> bool: + return ( + isinstance(value, list) + and len(value) <= 32 + and (bool(value) or not required) + and all(_valid_text(item) for item in value) + and len(set(value)) == len(value) + ) + + +def _valid_problem_id(value: Any) -> bool: + allowed = "abcdefghijklmnopqrstuvwxyz0123456789_" + return ( + isinstance(value, str) + and 1 <= len(value) <= 128 + and value[0] in "abcdefghijklmnopqrstuvwxyz0123456789" + and all(character in allowed for character in value) + ) + + +def problem_spec_is_valid(spec: Any) -> bool: + if not isinstance(spec, dict) or set(spec) != { + "schema", + "problem_id", + "question", + "context", + "constraints", + "desired_outcomes", + "failure_modes", + "testable_predictions", + "scope", + "provenance", + }: + return False + return ( + spec["schema"] == "boggers-ts-problem-spec-v1" + and _valid_problem_id(spec["problem_id"]) + and _valid_text(spec["question"]) + and _valid_text_list(spec["context"], required=False) + and _valid_text_list(spec["constraints"], required=True) + and _valid_text_list(spec["desired_outcomes"], required=True) + and _valid_text_list(spec["failure_modes"], required=True) + and _valid_text_list(spec["testable_predictions"], required=True) + and _valid_text(spec["scope"]) + and isinstance(spec["provenance"], dict) + and canonical_tree_is_valid(spec["provenance"]) + ) + + +def parent_binding_is_valid(binding: Any) -> bool: + return ( + isinstance(binding, dict) + and set(binding) + == { + "graph_lineage_id", + "parent_root", + "parent_authority_hash", + "expected_sequence", + } + and _valid_text(binding["graph_lineage_id"], maximum=256) + and _is_sha256(binding["parent_root"]) + and _is_sha256(binding["parent_authority_hash"]) + and isinstance(binding["expected_sequence"], int) + and not isinstance(binding["expected_sequence"], bool) + and binding["expected_sequence"] > 0 + ) + + +def expected_provenance(evidence: dict[str, Any]) -> dict[str, Any]: + return { + "schema": "boggers-ts-problem-provenance-v1", + "producer": "BoggersTheAI.reasoner.ts_reasoner.problem_workflow", + "workflow_version": "19.1", + "projection": "existing_constraint_fields_structured_projection_v1", + "semantic_claim": "DETERMINISTIC_ANALYSIS_NOT_WORLD_TRUTH", + "problem_spec_hash": evidence["problem_spec_hash"], + "constraint_field_hash": evidence["constraint_field_hash"], + "focus_hash": evidence["focus_hash"], + "advice_hash": evidence["advice_hash"], + "advice_top_k": evidence["advice"]["top_k"], + "advice_mount_receipt_hash": workflow_stable_hash( + evidence["advice"]["description"] + ), + "parent_binding": evidence["parent_binding"], + } + + +def expected_canonical_provenance(evidence: dict[str, Any]) -> dict[str, Any]: + """Stable semantic provenance; excludes transaction/advice observations.""" + + return { + "schema": "boggers-ts-problem-canonical-provenance-v1", + "producer": "BoggersTheAI.reasoner.ts_reasoner.problem_workflow", + "workflow_version": "19.1", + "projection": "existing_constraint_fields_structured_projection_v1", + "semantic_claim": "DETERMINISTIC_ANALYSIS_NOT_WORLD_TRUTH", + "problem_spec_hash": evidence["problem_spec_hash"], + "constraint_field_hash": evidence["constraint_field_hash"], + "focus_hash": evidence["focus_hash"], + } + + +def expected_node_payload(evidence: dict[str, Any]) -> dict[str, Any]: + return { + "schema": "boggers-ts-problem-analysis-v1", + "semantics": "DETERMINISTIC_ANALYSIS_NOT_WORLD_TRUTH", + "analysis": { + "problem_spec": evidence["problem_spec"], + "constraint_field": evidence["constraint_field"], + "focus": evidence["focus"], + "canonical_provenance": expected_canonical_provenance(evidence), + "advice_boundary": { + "schema": "boggers-ts-problem-advice-boundary-v1", + "semantic_authority": "NONE", + "canonical_influence": False, + "semantic_use": "RECEIPT_EVIDENCE_ONLY", + }, + }, + "bindings": { + "problem_spec_hash": evidence["problem_spec_hash"], + "constraint_field_hash": evidence["constraint_field_hash"], + "focus_hash": evidence["focus_hash"], + }, + "authority_boundary": { + "schema": "boggers-ts-problem-authority-boundary-v1", + "canonical_change": "ADD_ONLY_SINGLE_NODE", + "node_kind": PROBLEM_NODE_KIND, + "canonical_writer": "PRIME_V19_AUTHORITY_KERNEL", + "semantic_authority": "DETERMINISTIC_ANALYSIS_ONLY", + "world_truth_claimed": False, + "representation_change": "FORBIDDEN", + "execution": "FORBIDDEN", + }, + } + + +def expected_mutation_intent(evidence: dict[str, Any]) -> dict[str, Any]: + return { + "schema": "boggers-ts-problem-mutation-intent-v1", + "operation": "ADD_ONLY_SINGLE_NODE", + "node_id": evidence["node_id"], + "node_kind": evidence["node_kind"], + "node_payload_hash": evidence["node_payload_hash"], + "parent_binding": evidence["parent_binding"], + } + + +def evidence_bundle_hash(evidence: dict[str, Any]) -> str: + """Commit the shared evidence view while excluding per-envelope/cyclic fields.""" + + shared = { + key: value + for key, value in evidence.items() + if key not in {"obligation_id", "proposal_hash"} + } + return workflow_stable_hash(shared) + + +def expected_proposal_metadata(evidence: dict[str, Any]) -> dict[str, Any]: + return { + "schema": "boggers-ts-problem-proposal-metadata-v1", + "problem_spec_hash": evidence["problem_spec_hash"], + "constraint_field_hash": evidence["constraint_field_hash"], + "focus_hash": evidence["focus_hash"], + "advice_hash": evidence["advice_hash"], + "node_payload_hash": evidence["node_payload_hash"], + "evidence_bundle_hash": evidence_bundle_hash(evidence), + "mutation": "ADD_ONLY_SINGLE_NODE", + "semantic_claim": "DETERMINISTIC_ANALYSIS_NOT_WORLD_TRUTH", + } + + +def _common_evidence_valid(context: Any, evidence: Any, config: Any) -> bool: + if not isinstance(evidence, dict) or set(evidence) != _EVIDENCE_KEYS: + return False + if not isinstance(config, dict) or set(config) != {"obligation_id"}: + return False + proposal = context.proposal + binding = evidence["parent_binding"] + return ( + evidence["schema"] == "boggers-ts-problem-evidence-v1" + and evidence["obligation_id"] == config["obligation_id"] + and evidence["proposal_hash"] == proposal.proposal_hash + and evidence["node_kind"] == PROBLEM_NODE_KIND + and evidence["node_id"] + == f"ts.problem_analysis:{evidence['problem_spec_hash']}" + and _valid_text(evidence["node_id"], maximum=256) + and all( + _is_sha256(evidence[key]) + for key in ( + "problem_spec_hash", + "constraint_field_hash", + "focus_hash", + "advice_hash", + "provenance_hash", + "node_payload_hash", + "mutation_intent_hash", + ) + ) + and parent_binding_is_valid(binding) + and binding["graph_lineage_id"] == proposal.graph_lineage_id + and binding["parent_root"] == proposal.parent_root + and binding["parent_authority_hash"] == proposal.parent_authority_hash + and binding["expected_sequence"] == proposal.expected_sequence + and proposal.expected_sequence == context.logical_sequence + and proposal.metadata == expected_proposal_metadata(evidence) + and canonical_tree_is_valid(evidence) + ) + + +def _contains_forbidden_node_key(value: Any) -> bool: + if isinstance(value, list): + return any(_contains_forbidden_node_key(item) for item in value) + if not isinstance(value, dict): + return False + if any(key in _FORBIDDEN_NODE_KEYS for key in value): + return True + return any(_contains_forbidden_node_key(item) for item in value.values()) + + +def workflow_boundary_v1(context: Any, evidence: Any, config: Any) -> VerifierFinding: + """Admit exactly one new non-executable semantic-analysis node.""" + + if not _common_evidence_valid(context, evidence, config): + return _fail("workflow evidence envelope is invalid") + if config["obligation_id"] != WORKFLOW_BOUNDARY_OBLIGATION: + return _fail("workflow obligation configuration mismatch") + proposal = context.proposal + if proposal.scope.value != "deterministic_semantic_commit": + return _fail("problem analysis requires deterministic semantic scope") + if len(proposal.operations) != 1 or len(proposal.affected_nodes) != 1: + return _fail("problem analysis must contain exactly one operation") + operation = proposal.operations[0] + if operation.op != "upsert_node": + return _fail("problem analysis must use one node upsert") + body = operation.body + if set(body) != {"node_id", "kind", "payload"}: + return _fail("problem node operation has an unknown shape") + if ( + body["node_id"] != evidence["node_id"] + or body["kind"] != PROBLEM_NODE_KIND + or proposal.affected_nodes != (evidence["node_id"],) + ): + return _fail("problem node identity binding failed") + if context.snapshot.node(evidence["node_id"]) is not None: + return _fail("problem analysis is add-only and the node already exists") + if _contains_forbidden_node_key(body["payload"]): + return _fail("problem node contains a forbidden authority surface") + if body["payload"] != evidence["node_payload"]: + return _fail("proposal node payload differs from evidence") + if evidence["node_payload"] != expected_node_payload(evidence): + return _fail("problem node payload is not the bounded canonical shape") + if workflow_stable_hash(evidence["node_payload"]) != evidence["node_payload_hash"]: + return _fail("problem node payload hash mismatch") + if evidence["mutation_intent"] != expected_mutation_intent(evidence): + return _fail("mutation intent is not add-only and exact") + if ( + workflow_stable_hash(evidence["mutation_intent"]) + != evidence["mutation_intent_hash"] + ): + return _fail("mutation intent hash mismatch") + if proposal.mutation_intent_hash != evidence["mutation_intent_hash"]: + return _fail("proposal mutation binding mismatch") + if proposal.metadata != expected_proposal_metadata(evidence): + return _fail("proposal metadata binding mismatch") + return VerifierFinding.pass_("single add-only problem-analysis node verified") + + +def constraint_field_integrity_v1( + context: Any, evidence: Any, config: Any +) -> VerifierFinding: + """Recompute the exact field projection and active frontier.""" + + if not _common_evidence_valid(context, evidence, config): + return _fail("constraint-field evidence envelope is invalid") + if config["obligation_id"] != CONSTRAINT_FIELD_OBLIGATION: + return _fail("constraint-field obligation configuration mismatch") + spec = evidence["problem_spec"] + if not problem_spec_is_valid(spec): + return _fail("problem specification failed bounded validation") + if workflow_stable_hash(spec) != evidence["problem_spec_hash"]: + return _fail("problem specification hash mismatch") + expected_field = expected_constraint_field(spec) + if evidence["constraint_field"] != expected_field: + return _fail("constraint field differs from deterministic projection") + if workflow_stable_hash(expected_field) != evidence["constraint_field_hash"]: + return _fail("constraint field hash mismatch") + expected_focus = focus_from_field(expected_field) + if evidence["focus"] != expected_focus: + return _fail("active constraint frontier was not recomputed exactly") + if workflow_stable_hash(expected_focus) != evidence["focus_hash"]: + return _fail("constraint focus hash mismatch") + analysis = evidence["node_payload"]["analysis"] + if ( + analysis["problem_spec"] != spec + or analysis["constraint_field"] != expected_field + or analysis["focus"] != expected_focus + ): + return _fail("node analysis does not bind the recomputed field") + return VerifierFinding.pass_("deterministic constraint-field projection verified") + + +def provenance_binding_v1(context: Any, evidence: Any, config: Any) -> VerifierFinding: + """Bind source, sealed-v18 proposal evidence, parent, and exact payload.""" + + if not _common_evidence_valid(context, evidence, config): + return _fail("provenance evidence envelope is invalid") + if config["obligation_id"] != PROVENANCE_OBLIGATION: + return _fail("provenance obligation configuration mismatch") + if not advice_record_is_valid(evidence["advice"]): + return _fail("sealed-v18 advice violated its proposal-only contract") + advice = evidence["advice"] + if advice["mode"] == "PRESENT": + if advice["proposal_batch"]["request_hash"] != expected_v18_worker_request_hash( + evidence["problem_spec"]["question"], advice["top_k"] + ): + return _fail("sealed-v18 worker request is not problem/top-k bound") + if workflow_stable_hash(advice) != evidence["advice_hash"]: + return _fail("sealed-v18 advice hash mismatch") + provenance = expected_provenance(evidence) + if evidence["provenance"] != provenance: + return _fail("workflow provenance was not recomputed exactly") + if workflow_stable_hash(provenance) != evidence["provenance_hash"]: + return _fail("workflow provenance hash mismatch") + if context.proposal.provenance_hash != evidence["provenance_hash"]: + return _fail("proposal provenance binding mismatch") + analysis = evidence["node_payload"]["analysis"] + if analysis["canonical_provenance"] != expected_canonical_provenance(evidence): + return _fail("node canonical provenance mismatch") + if analysis["advice_boundary"] != { + "schema": "boggers-ts-problem-advice-boundary-v1", + "semantic_authority": "NONE", + "canonical_influence": False, + "semantic_use": "RECEIPT_EVIDENCE_ONLY", + }: + return _fail("node advice boundary permits canonical influence") + return VerifierFinding.pass_("problem provenance and proposal-only advice verified") + + +def representation_economics_v1( + context: Any, evidence: Any, config: Any +) -> VerifierFinding: + """Registered fail-closed economics verifier; this workflow has no such path.""" + + del context, evidence + if not isinstance(config, dict) or config != { + "obligation_id": REPRESENTATION_ECONOMICS_OBLIGATION + }: + return _fail("representation economics configuration mismatch") + return VerifierFinding.fail( + "problem-analysis workflow forbids representation transitions" + ) diff --git a/tests/test_constraint_fields.py b/tests/test_constraint_fields.py new file mode 100644 index 0000000..3b7929e --- /dev/null +++ b/tests/test_constraint_fields.py @@ -0,0 +1,94 @@ +from __future__ import annotations + +import unittest +from dataclasses import replace + +from reasoner.ts_reasoner.constraint_fields import ( + compare_concept_fields, + create_concept_field, + export_receipt, + field_signature, + get_example_concept_field, + verify_analogy, +) + + +class ConstraintFieldTests(unittest.TestCase): + def test_concept_fields_can_be_created_and_validated(self) -> None: + field = create_concept_field("gravity") + + self.assertEqual(field.concept_id, "gravity") + self.assertEqual(field.status, "valid") + self.assertGreaterEqual(len(field.entities), 3) + self.assertIn("attractor", field.forces[0].primitives) + + def test_field_signatures_are_deterministic(self) -> None: + field = create_concept_field("debt") + + first = field_signature(field) + second = field_signature(create_concept_field(field.to_dict())) + + self.assertEqual(first, second) + self.assertEqual(first["signature_hash"], second["signature_hash"]) + + def test_similar_concepts_score_higher_than_unrelated_concepts(self) -> None: + debt_technical = compare_concept_fields("debt", "technical_debt") + debt_gravity = compare_concept_fields("debt", "gravity") + + self.assertGreater( + debt_technical["similarity_score"], + debt_gravity["similarity_score"], + ) + self.assertGreaterEqual(debt_technical["similarity_score"], 0.5) + self.assertIn("accumulation", debt_technical["overlap_explanation"]) + + def test_breakpoints_reduce_analogy_confidence(self) -> None: + comparison = compare_concept_fields("gravity", "social_influence") + analogy = verify_analogy("gravity", "social_influence") + + self.assertIn(analogy["decision"], {"uncertain", "rejected"}) + self.assertLess(analogy["confidence"], comparison["similarity_score"]) + self.assertTrue(analogy["where_the_analogy_breaks"]) + self.assertTrue(analogy["counterexamples"]) + + def test_receipts_are_auditable(self) -> None: + result = verify_analogy("debt", "technical_debt") + receipt = export_receipt(result) + + for key in ( + "inputs", + "normalized_fields", + "matching_logic", + "score_calculation", + "rejected_matches", + "final_decision", + ): + self.assertIn(key, receipt) + self.assertEqual(receipt["final_decision"]["decision"], "accepted") + self.assertGreater(receipt["score_calculation"]["mechanism_count"], 0) + + def test_invalid_or_underspecified_fields_do_not_gain_confidence(self) -> None: + vague = create_concept_field("vibes") + + self.assertIn(vague.status, {"underspecified", "invalid"}) + self.assertLessEqual(vague.confidence, 0.25) + + result = verify_analogy(vague, get_example_concept_field("learning")) + self.assertIn(result["decision"], {"uncertain", "rejected"}) + self.assertLessEqual(result["confidence"], 0.25) + + def test_missing_breakpoints_prevent_unbounded_acceptance(self) -> None: + debt = get_example_concept_field("debt") + technical_debt = get_example_concept_field("technical_debt") + no_limits = replace(technical_debt, breakpoints=[]).normalized() + + result = verify_analogy(debt, no_limits) + + self.assertIn(result["decision"], {"uncertain", "rejected"}) + self.assertTrue( + any("missing explicit breakpoints" in item for item in result["where_the_analogy_breaks"]) + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_counterfactual_verifier_semantics.py b/tests/test_counterfactual_verifier_semantics.py new file mode 100644 index 0000000..56ea9b7 --- /dev/null +++ b/tests/test_counterfactual_verifier_semantics.py @@ -0,0 +1,138 @@ +from core.cortex.counterfactual_verifier import ( + PAIR_CHANNELS, + build_counterfactual_pair, +) + +from core.cortex.verifier_prompt import ( + format_verifier_prompt, +) + + +def test_counterfactual_pairs_are_canonical(): + for offset, channel in enumerate( + PAIR_CHANNELS + ): + pair = build_counterfactual_pair( + channel, + 910000 + offset, + split="test", + ) + + assert len(pair) == 2 + + accept, reject = pair + + assert ( + accept["verifier_label"] + == "ACCEPT" + ) + + assert ( + reject["verifier_label"] + == "REJECT" + ) + + assert ( + accept["verifier_result"][ + "outcome" + ] + == "pass" + ) + + assert ( + reject["verifier_result"][ + "outcome" + ] + == "fail" + ) + + assert ( + accept["pair_id"] + == reject["pair_id"] + ) + + assert ( + accept["pair_hash"] + == reject["pair_hash"] + ) + + assert ( + accept["verifier_type"] + == reject["verifier_type"] + == channel + ) + + assert ( + accept["authority"] + == "NONE" + ) + + assert ( + reject["authority"] + == "NONE" + ) + + +def test_counterfactual_prompts_differ_only_by_available_fact(): + for offset, channel in enumerate( + PAIR_CHANNELS + ): + pair = build_counterfactual_pair( + channel, + 920000 + offset, + split="test", + ) + + accept_prompt = ( + format_verifier_prompt( + pair[0] + ) + ) + + reject_prompt = ( + format_verifier_prompt( + pair[1] + ) + ) + + assert ( + accept_prompt + != reject_prompt + ) + + assert ( + pair[0]["obligation"] + == pair[1]["obligation"] + or channel == "arithmetic" + ) + + +def test_pair_counterfactual_metadata_changes(): + for offset, channel in enumerate( + PAIR_CHANNELS + ): + accept, reject = ( + build_counterfactual_pair( + channel, + 930000 + offset, + split="test", + ) + ) + + assert ( + accept[ + "counterfactual_field" + ] + == reject[ + "counterfactual_field" + ] + ) + + assert ( + accept[ + "counterfactual_value" + ] + != reject[ + "counterfactual_value" + ] + ) diff --git a/tests/test_native_cortex.py b/tests/test_native_cortex.py new file mode 100644 index 0000000..e1f33b9 --- /dev/null +++ b/tests/test_native_cortex.py @@ -0,0 +1,235 @@ +"""Mega PRIME Native Cortex tests.""" + +import unittest + +import torch + +from core.cortex import ( + ByteTokenizer, + CortexConfig, + NativeCortex, + TernaryLinear, +) + + +class TokenizerTests( + unittest.TestCase +): + def test_utf8_roundtrip( + self, + ): + tokenizer = ( + ByteTokenizer() + ) + + source = ( + "PRIME learns ⚡ relations." + ) + + tokens = tokenizer.encode( + source + ) + + self.assertEqual( + tokenizer.decode( + tokens + ), + source, + ) + + +class TernaryTests( + unittest.TestCase +): + def test_effective_weight_has_at_most_three_scaled_values_per_row( + self, + ): + layer = TernaryLinear( + 16, + 8, + ) + + weight = ( + layer.effective_weight() + .detach() + ) + + for row in weight: + self.assertLessEqual( + torch.unique( + row + ).numel(), + 3, + ) + + +class CortexTests( + unittest.TestCase +): + def setUp( + self, + ): + torch.manual_seed( + 123 + ) + + self.config = ( + CortexConfig( + d_model=48, + layers=2, + memory_heads=4, + experts=3, + expert_hidden=96, + ) + ) + + self.model = ( + NativeCortex( + self.config + ) + ) + + def test_forward_shape( + self, + ): + x = torch.randint( + 0, + self.config.vocab_size, + ( + 2, + 12, + ), + ) + + result = self.model( + x + ) + + self.assertEqual( + result.logits.shape, + ( + 2, + 12, + self.config.vocab_size, + ), + ) + + self.assertEqual( + result.verifier_logits.shape, + ( + 2, + 12, + self.config.verifier_classes, + ), + ) + + def test_recurrent_state_changes( + self, + ): + token = torch.tensor( + [ + 65 + ] + ) + + ( + _, + _, + states_a, + _, + _, + ) = self.model.step( + token + ) + + ( + _, + _, + states_b, + _, + _, + ) = self.model.step( + token, + states_a, + ) + + difference = sum( + ( + b + - a + ).abs().sum().item() + for a, b + in zip( + states_a, + states_b, + ) + ) + + self.assertGreater( + difference, + 0.0, + ) + + def test_native_observability( + self, + ): + token = torch.tensor( + [ + 65 + ] + ) + + ( + _, + _, + _, + _, + telemetry, + ) = self.model.step( + token, + telemetry=True, + ) + + self.assertEqual( + len(telemetry), + self.config.layers, + ) + + for row in telemetry: + self.assertGreaterEqual( + row.write_mean, + 0.0, + ) + + self.assertGreaterEqual( + row.erase_mean, + 0.0, + ) + + self.assertGreaterEqual( + row.selected_expert, + 0, + ) + + def test_cortex_exposes_no_authority_method( + self, + ): + forbidden = { + "authorize", + "commit", + "canonicalize", + } + + self.assertTrue( + forbidden.isdisjoint( + set( + dir( + self.model + ) + ) + ) + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_native_cortex_v1.py b/tests/test_native_cortex_v1.py new file mode 100644 index 0000000..906c6c7 --- /dev/null +++ b/tests/test_native_cortex_v1.py @@ -0,0 +1,259 @@ +"""Mega PRIME Native Cortex V1 tests.""" + +import unittest + +import torch + +from core.cortex import ( + CortexV1Config, + NativeCortexV1, +) + + +class NativeCortexV1Tests( + unittest.TestCase +): + def setUp( + self, + ): + torch.manual_seed( + 20260823 + ) + + self.config = CortexV1Config( + vocab_size=512, + d_model=96, + layers=4, + memory_heads=6, + attention_heads=6, + attention_every=2, + attention_window=8, + experts=4, + expert_hidden=128, + output_rank=32, + ) + + self.model = NativeCortexV1( + self.config + ) + + def test_forward_shapes( + self, + ): + tokens = torch.randint( + 0, + self.config.vocab_size, + ( + 2, + 12, + ), + ) + + result = self.model( + tokens + ) + + self.assertEqual( + result.logits.shape, + ( + 2, + 12, + self.config.vocab_size, + ), + ) + + self.assertEqual( + result.hidden.shape, + ( + 2, + 12, + self.config.d_model, + ), + ) + + def test_recurrence_changes_output( + self, + ): + tokens = torch.randint( + 0, + self.config.vocab_size, + ( + 1, + 12, + ), + ) + + self.model.eval() + + with torch.no_grad(): + normal = self.model( + tokens + ).logits + + reset = self.model( + tokens, + reset_recurrence=True, + ).logits + + difference = ( + normal + - reset + ).abs().sum().item() + + self.assertGreater( + difference, + 0.0, + ) + + def test_local_attention_changes_output( + self, + ): + tokens = torch.randint( + 0, + self.config.vocab_size, + ( + 1, + 12, + ), + ) + + self.model.eval() + + with torch.no_grad(): + normal = self.model( + tokens + ).logits + + disabled = self.model( + tokens, + disable_attention=True, + ).logits + + difference = ( + normal + - disabled + ).abs().sum().item() + + self.assertGreater( + difference, + 0.0, + ) + + def test_attention_cache_is_bounded( + self, + ): + states = None + + self.model.eval() + + with torch.no_grad(): + for _ in range(20): + token = torch.randint( + 0, + self.config.vocab_size, + (1,), + ) + + ( + _, + _, + _, + states, + _, + _, + _, + _, + ) = self.model.step( + token, + states, + ) + + for block, state in zip( + self.model.blocks, + states, + ): + if block.use_attention: + self.assertLessEqual( + state.attention_keys.shape[2], + self.config.attention_window, + ) + + def test_diagnostics_exist( + self, + ): + tokens = torch.randint( + 0, + self.config.vocab_size, + ( + 1, + 8, + ), + ) + + self.model.eval() + + with torch.no_grad(): + result = self.model( + tokens, + collect_diagnostics=True, + ) + + self.assertEqual( + len( + result.diagnostics + ), + self.config.layers, + ) + + def test_no_authority_interface( + self, + ): + forbidden = { + "authorize", + "canonicalize", + "commit", + } + + self.assertTrue( + forbidden.isdisjoint( + set( + dir( + self.model + ) + ) + ) + ) + + +class FullArchitectureTests( + unittest.TestCase +): + def test_full_model_is_mega_scale( + self, + ): + model = NativeCortexV1( + CortexV1Config() + ) + + parameters = ( + model.parameter_count() + ) + + print( + "Native Cortex V1 parameters:", + f"{parameters:,}", + ) + + self.assertGreater( + parameters, + 5_000_000, + ) + + self.assertLess( + parameters, + 10_000_000, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_arena.py b/tests/test_prime_m20_arena.py new file mode 100644 index 0000000..d7968c2 --- /dev/null +++ b/tests/test_prime_m20_arena.py @@ -0,0 +1,215 @@ +"""Structural tests for PRIME M20 Universal Arena.""" + +import unittest + +from core.construction.grammar import ( + evaluate, +) +from core.construction.scaffold import ( + generate_scaffold_candidates, +) + +from experiments.prime_m20_universal_arena.runner import ( + run_world, +) +from experiments.prime_m20_universal_arena.tasks import ( + TASK_BY_NAME, +) + + +class ScaffoldTests( + unittest.TestCase +): + def test_three_way_xor_exists(self): + target = TASK_BY_NAME[ + "XOR-1-2-3" + ].expression + + self.assertIsNotNone( + target + ) + + candidates = ( + generate_scaffold_candidates( + max_lag=8, + max_candidates=256, + ) + ) + + hashes = { + spec.expression.expression_hash + for spec in candidates + } + + self.assertIn( + target.expression_hash, + hashes, + ) + + def test_three_way_semantics(self): + task = TASK_BY_NAME[ + "XOR-1-2-3" + ] + + history = ( + 1, + 0, + 1, + 1, + ) + + self.assertEqual( + task.target( + history + ), + ( + history[-2] + ^ history[-3] + ^ history[-4] + ), + ) + + +class GuardTests( + unittest.TestCase +): + def test_heldout_blocked(self): + with self.assertRaises( + RuntimeError + ): + run_world( + task=( + TASK_BY_NAME[ + "LAG-4" + ] + ), + stream_seed=6000, + condition=( + "M20-CONSTRUCTION" + ), + ) + + def test_unknown_seed_blocked(self): + with self.assertRaises( + RuntimeError + ): + run_world( + task=( + TASK_BY_NAME[ + "LAG-4" + ] + ), + stream_seed=999, + condition=( + "M20-CONSTRUCTION" + ), + ) + + +class DevelopmentSmokeTests( + unittest.TestCase +): + def test_current_does_not_construct(self): + result = run_world( + task=( + TASK_BY_NAME[ + "CURRENT" + ] + ), + stream_seed=600, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + self.assertEqual( + result[ + "authorized_construction_count" + ], + 0, + ) + + self.assertTrue( + result[ + "exact_target_construction_active" + ] + ) + + self.assertTrue( + result[ + "receipt_chain_valid" + ] + ) + + def test_lag4_constructs_target(self): + result = run_world( + task=( + TASK_BY_NAME[ + "LAG-4" + ] + ), + stream_seed=601, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + self.assertTrue( + result[ + "exact_target_construction_active" + ] + ) + + self.assertTrue( + result[ + "receipt_chain_valid" + ] + ) + + def test_xor_pair_constructs_target(self): + result = run_world( + task=( + TASK_BY_NAME[ + "XOR-1-4" + ] + ), + stream_seed=602, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + self.assertTrue( + result[ + "exact_target_construction_active" + ] + ) + + def test_xor3_scaffold_constructs_target(self): + result = run_world( + task=( + TASK_BY_NAME[ + "XOR-1-2-3" + ] + ), + stream_seed=603, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + self.assertTrue( + result[ + "exact_target_construction_active" + ] + ) + + self.assertTrue( + result[ + "receipt_chain_valid" + ] + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_arena_v0_2.py b/tests/test_prime_m20_arena_v0_2.py new file mode 100644 index 0000000..aac35b2 --- /dev/null +++ b/tests/test_prime_m20_arena_v0_2.py @@ -0,0 +1,137 @@ +"""Corrected Arena v0.2 invariants.""" + +import unittest + +from core.construction.grammar import ( + binary, + lag, +) +from core.construction.quotient import ( + RELATION_COMPLEMENT, + semantic_relation, +) +from core.construction.types import ( + FeatureOp, +) + +from experiments.prime_m20_universal_arena.runner_v0_2 import ( + run_world, +) +from experiments.prime_m20_universal_arena.tasks import ( + TASK_BY_NAME, +) + + +class PairingTests( + unittest.TestCase +): + def test_heldout_still_blocked(self): + with self.assertRaises( + RuntimeError + ): + run_world( + task=( + TASK_BY_NAME[ + "LAG-4" + ] + ), + stream_seed=6000, + condition=( + "M20-CONSTRUCTION" + ), + ) + + +class QuotientTests( + unittest.TestCase +): + def test_xor_eq_relation_frozen(self): + xor_expr = binary( + FeatureOp.XOR, + lag(2), + lag(7), + ) + + eq_expr = binary( + FeatureOp.EQ, + lag(2), + lag(7), + ) + + self.assertEqual( + semantic_relation( + xor_expr, + eq_expr, + ), + RELATION_COMPLEMENT, + ) + + def test_xor27_partition_recovery(self): + result = run_world( + task=( + TASK_BY_NAME[ + "XOR-2-7" + ] + ), + stream_seed=600, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + self.assertTrue( + result[ + "predictive_partition_recovered" + ] + ) + + def test_eq14_partition_recovery(self): + result = run_world( + task=( + TASK_BY_NAME[ + "EQ-1-4" + ] + ), + stream_seed=601, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + self.assertTrue( + result[ + "predictive_partition_recovered" + ] + ) + + +class ImbalanceTests( + unittest.TestCase +): + def test_and_task_reports_constant_baseline(self): + result = run_world( + task=( + TASK_BY_NAME[ + "AND-1-2-4" + ] + ), + stream_seed=602, + condition="REACTIVE", + ).payload + + self.assertIsNotNone( + result[ + "balanced_accuracy_ppm" + ] + ) + + self.assertGreater( + result[ + "best_constant_accuracy_ppm" + ], + 500000, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_arena_v0_3.py b/tests/test_prime_m20_arena_v0_3.py new file mode 100644 index 0000000..d86cb33 --- /dev/null +++ b/tests/test_prime_m20_arena_v0_3.py @@ -0,0 +1,135 @@ +"""Arena v0.3 global-alpha invariants.""" + +import unittest + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) + +from experiments.prime_m20_universal_arena.runner_v0_3 import ( + run_world, +) +from experiments.prime_m20_universal_arena.tasks import ( + TASK_BY_NAME, +) + + +class GlobalAlphaArenaTests( + unittest.TestCase +): + def test_initial_arena_field_uses_epoch_spending( + self, + ): + engine = ( + CompositionalAdaptiveConstructionEngine( + max_lag=8, + max_candidates=256, + enable_scaffolds=True, + ) + ) + + snapshot = ( + engine.candidate_field_snapshot() + ) + + self.assertEqual( + snapshot.epoch, + 0, + ) + + self.assertEqual( + snapshot.alpha_denominator, + 128, + ) + + self.assertEqual( + snapshot.threshold, + ( + 128 + * snapshot.candidate_count + ), + ) + + def test_runner_identifies_v03( + self, + ): + result = run_world( + task=( + TASK_BY_NAME[ + "CURRENT" + ] + ), + stream_seed=600, + condition="REACTIVE", + ).payload + + self.assertEqual( + result[ + "arena_version" + ], + "v0.3", + ) + + self.assertTrue( + result[ + "global_alpha_spending" + ] + ) + + def test_m20_reports_alpha_state( + self, + ): + result = run_world( + task=( + TASK_BY_NAME[ + "LAG-4" + ] + ), + stream_seed=601, + condition=( + "M20-CONSTRUCTION" + ), + ).payload + + field = result[ + "candidate_field" + ] + + self.assertIsNotNone( + field + ) + + self.assertGreaterEqual( + field[ + "alpha_denominator" + ], + 128, + ) + + self.assertTrue( + result[ + "receipt_chain_valid" + ] + ) + + def test_heldout_remains_blocked( + self, + ): + with self.assertRaises( + RuntimeError + ): + run_world( + task=( + TASK_BY_NAME[ + "XOR-1-2-3" + ] + ), + stream_seed=6000, + condition=( + "M20-CONSTRUCTION" + ), + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_composition.py b/tests/test_prime_m20_composition.py new file mode 100644 index 0000000..d0c9a4f --- /dev/null +++ b/tests/test_prime_m20_composition.py @@ -0,0 +1,550 @@ +"""Higher-order PRIME M20 composition tests.""" + +from copy import deepcopy +import tempfile +import unittest +from pathlib import Path + +from core.construction.composition import ( + generate_composed_candidates, +) +from core.construction.grammar import ( + binary, + dependencies, + evaluate, + lag, + ref, +) +from core.construction.graph_projection import ( + project_registry, +) +from core.construction.library import ( + load_library, + save_library, + snapshot_registry, + validate_library, +) +from core.construction.registry import ( + ConstructionRegistry, +) +from core.construction.state import ( + ConstructionStateBuilder, +) +from core.construction.types import ( + AuthorityAction, + ConstructionSpec, + FeatureOp, + VerifierAuthorization, +) + + +def authorize( + registry, + spec, + token, +): + registry.propose( + spec + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash=( + token * 64 + )[:64], + reason="TEST", + ) + ) + + +class ReferenceTests( + unittest.TestCase +): + def test_ref_evaluation(self): + expr = binary( + FeatureOp.XOR, + ref("cx:a"), + ref("cx:b"), + ) + + self.assertEqual( + evaluate( + expr, + (), + { + "cx:a": 1, + "cx:b": 0, + }, + ), + 1, + ) + + def test_ref_dependencies(self): + expr = binary( + FeatureOp.EQ, + ref("cx:a"), + lag(4), + ) + + self.assertEqual( + dependencies( + expr + ), + frozenset( + { + "cx:a", + } + ), + ) + + +class CompositionTests( + unittest.TestCase +): + def test_composition_requires_authority(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(1) + ) + + registry.propose( + spec + ) + + self.assertEqual( + generate_composed_candidates( + registry + ), + (), + ) + + def test_authorized_construction_becomes_atom(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(1) + ) + + authorize( + registry, + spec, + "a", + ) + + candidates = ( + generate_composed_candidates( + registry + ) + ) + + self.assertTrue( + candidates + ) + + self.assertTrue( + any( + spec.construction_id + in dependencies( + candidate.expression + ) + for candidate + in candidates + ) + ) + + def test_unknown_reference_cannot_be_proposed(self): + registry = ( + ConstructionRegistry() + ) + + invalid = ConstructionSpec( + expression=ref( + "cx:not-authorized" + ), + proposal_source="test", + ) + + with self.assertRaises( + ValueError + ): + registry.propose( + invalid + ) + + +class LifecycleTests( + unittest.TestCase +): + def test_active_dependency_cannot_be_retired(self): + registry = ( + ConstructionRegistry() + ) + + parent = ConstructionSpec( + expression=lag(1) + ) + + authorize( + registry, + parent, + "b", + ) + + child = ConstructionSpec( + expression=binary( + FeatureOp.XOR, + ref( + parent.construction_id + ), + lag(4), + ), + proposal_source=( + "verified_composition" + ), + ) + + authorize( + registry, + child, + "c", + ) + + with self.assertRaises( + ValueError + ): + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.RETIRE + ), + construction_id=( + parent.construction_id + ), + verdict=True, + evidence_hash="d" * 64, + reason="TEST", + ) + ) + + +class StateTests( + unittest.TestCase +): + def test_composed_state_uses_authorized_output(self): + registry = ( + ConstructionRegistry() + ) + + parent = ConstructionSpec( + expression=lag(1) + ) + + authorize( + registry, + parent, + "e", + ) + + child = ConstructionSpec( + expression=binary( + FeatureOp.XOR, + ref( + parent.construction_id + ), + lag(1), + ), + proposal_source=( + "verified_composition" + ), + ) + + authorize( + registry, + child, + "f", + ) + + builder = ( + ConstructionStateBuilder( + registry + ) + ) + + builder.observe(1) + + state = builder.observe( + 0 + ) + + self.assertEqual( + len(state), + 3, + ) + + values = ( + builder.current_values + ) + + self.assertIn( + parent.construction_id, + values, + ) + + self.assertIn( + child.construction_id, + values, + ) + + def test_child_has_own_prospective_raw_history(self): + registry = ( + ConstructionRegistry() + ) + + parent = ConstructionSpec( + expression=lag(1) + ) + + authorize( + registry, + parent, + "g", + ) + + builder = ( + ConstructionStateBuilder( + registry + ) + ) + + for bit in ( + 1, + 1, + 0, + 1, + 0, + ): + builder.observe( + bit + ) + + child = ConstructionSpec( + expression=binary( + FeatureOp.XOR, + ref( + parent.construction_id + ), + lag(4), + ), + proposal_source=( + "verified_composition" + ), + ) + + authorize( + registry, + child, + "h", + ) + + state = builder.observe( + 0 + ) + + values = ( + builder.current_values + ) + + # Child's LAG(4) component cannot see + # the five observations from before + # child authorization. + expected = ( + values[ + parent.construction_id + ] + ^ 0 + ) + + self.assertEqual( + values[ + child.construction_id + ], + expected, + ) + + self.assertEqual( + len(state), + 3, + ) + + +class LibraryTests( + unittest.TestCase +): + def test_library_roundtrip_and_tamper(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(2) + ) + + authorize( + registry, + spec, + "i", + ) + + with tempfile.TemporaryDirectory() as tmp: + path = Path( + tmp + ) / "library.json" + + digest = save_library( + registry, + path, + ) + + payload = load_library( + path + ) + + self.assertEqual( + payload[ + "library_hash" + ], + digest, + ) + + self.assertTrue( + validate_library( + payload + ) + ) + + damaged = deepcopy( + payload + ) + + damaged[ + "records" + ][0][ + "status" + ] = "retired" + + self.assertFalse( + validate_library( + damaged + ) + ) + + +class ProjectionTests( + unittest.TestCase +): + def test_projection_never_authorizes_commit(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + authorize( + registry, + spec, + "j", + ) + + projection = ( + project_registry( + registry + ) + ) + + self.assertFalse( + projection[ + "state_commit_authorized" + ] + ) + + self.assertEqual( + projection[ + "requested_operation" + ], + "PROPOSE_GRAPH_DELTA", + ) + + def test_dependency_edges_are_projected(self): + registry = ( + ConstructionRegistry() + ) + + parent = ConstructionSpec( + expression=lag(1) + ) + + authorize( + registry, + parent, + "k", + ) + + child = ConstructionSpec( + expression=binary( + FeatureOp.EQ, + ref( + parent.construction_id + ), + lag(3), + ), + proposal_source=( + "verified_composition" + ), + ) + + authorize( + registry, + child, + "l", + ) + + projection = ( + project_registry( + registry + ) + ) + + self.assertIn( + { + "src": ( + child.construction_id + ), + "dst": ( + parent.construction_id + ), + "relation": ( + "depends_on" + ), + }, + projection[ + "edges" + ], + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_construction.py b/tests/test_prime_m20_construction.py new file mode 100644 index 0000000..0d1ec28 --- /dev/null +++ b/tests/test_prime_m20_construction.py @@ -0,0 +1,575 @@ +"""PRIME M20 adaptive construction invariant suite.""" + +from copy import deepcopy +import unittest + +try: + from core.construction.engine import ( + AdaptiveConstructionEngine, + VerifierGate, + ) + from core.construction.evidence import ( + CandidateEvidence, + BinaryMajorityPredictor, + EvidenceEpoch, + ) + from core.construction.grammar import ( + binary, + description_length, + evaluate, + generate_bounded_candidates, + lag, + ) + from core.construction.receipts import ( + verify_receipt_chain, + ) + from core.construction.registry import ( + ConstructionRegistry, + ) + from core.construction.state import ( + ConstructionStateBuilder, + ) + from core.construction.types import ( + AuthorityAction, + ConstructionSpec, + EvidenceSnapshot, + FeatureOp, + VerifierAuthorization, + ) +except ImportError: + from BoggersTheAI.core.construction.engine import ( + AdaptiveConstructionEngine, + VerifierGate, + ) + from BoggersTheAI.core.construction.evidence import ( + CandidateEvidence, + BinaryMajorityPredictor, + EvidenceEpoch, + ) + from BoggersTheAI.core.construction.grammar import ( + binary, + description_length, + evaluate, + generate_bounded_candidates, + lag, + ) + from BoggersTheAI.core.construction.receipts import ( + verify_receipt_chain, + ) + from BoggersTheAI.core.construction.registry import ( + ConstructionRegistry, + ) + from BoggersTheAI.core.construction.state import ( + ConstructionStateBuilder, + ) + from BoggersTheAI.core.construction.types import ( + AuthorityAction, + ConstructionSpec, + EvidenceSnapshot, + FeatureOp, + VerifierAuthorization, + ) + + +class GrammarTests(unittest.TestCase): + def test_lag(self): + expr = lag(4) + + history = [ + 1, + 0, + 1, + 1, + 0, + ] + + self.assertEqual( + evaluate( + expr, + history, + ), + 1, + ) + + def test_xor(self): + expr = binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + + history = [ + 1, + 0, + 1, + 1, + 0, + ] + + self.assertEqual( + evaluate( + expr, + history, + ), + 0, + ) + + def test_eq(self): + expr = binary( + FeatureOp.EQ, + lag(1), + lag(4), + ) + + history = [ + 1, + 0, + 1, + 1, + 0, + ] + + self.assertEqual( + evaluate( + expr, + history, + ), + 1, + ) + + def test_commutative_normalization(self): + a = binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + + b = binary( + FeatureOp.XOR, + lag(4), + lag(1), + ) + + self.assertEqual( + a.expression_hash, + b.expression_hash, + ) + + def test_bounded_generator(self): + candidates = ( + generate_bounded_candidates() + ) + + self.assertLessEqual( + len(candidates), + 128, + ) + + ids = [ + item.construction_id + for item in candidates + ] + + self.assertEqual( + len(ids), + len(set(ids)), + ) + + def test_complexity_order(self): + self.assertLess( + description_length( + lag(4) + ), + description_length( + binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + ), + ) + + +class EvidenceTests(unittest.TestCase): + def test_single_stream_anytime_boundary(self): + spec = ConstructionSpec( + expression=lag(4) + ) + + tracker = CandidateEvidence( + spec=spec, + predictor=( + BinaryMajorityPredictor() + ), + ) + + # One active stream => threshold 64. + tracker.wins = 10 + + self.assertFalse( + tracker.statistical_pass( + 64 + ) + ) + + tracker.wins = 11 + + self.assertTrue( + tracker.statistical_pass( + 64 + ) + ) + + self.assertTrue( + tracker.structural_pass() + ) + + def test_multiplicity_threshold(self): + candidates = tuple( + generate_bounded_candidates( + max_lag=2, + max_candidates=8, + ) + ) + + epoch = EvidenceEpoch( + candidates + ) + + self.assertEqual( + epoch.threshold, + 64 * len(candidates), + ) + + +class AuthorityTests(unittest.TestCase): + def test_registry_proposal_is_not_authority(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + registry.propose( + spec + ) + + self.assertEqual( + registry.active_ids(), + (), + ) + + def test_failed_verdict_cannot_authorize(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + registry.propose( + spec + ) + + bad = VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=False, + evidence_hash="x" * 64, + reason="FAILED", + ) + + with self.assertRaises( + PermissionError + ): + registry.apply( + bad + ) + + def test_gate_rejects_unsupported_evidence(self): + gate = VerifierGate() + + evidence = EvidenceSnapshot( + construction_id="cx:test", + wins=1, + losses=0, + threshold=64, + evidence_lhs=3, + evidence_rhs=128, + statistical_pass=False, + structural_cost=4, + structural_pass=False, + supported=False, + obstruction_event_index=10, + authorization_event_index=10, + ) + + with self.assertRaises( + PermissionError + ): + gate.authorize( + evidence + ) + + +class MemoryBoundaryTests(unittest.TestCase): + def test_authorization_does_not_backfill_private_history(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + registry.propose( + spec + ) + + auth = VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash="a" * 64, + reason="TEST_AUTH", + ) + + registry.apply( + auth + ) + + builder = ( + ConstructionStateBuilder( + registry + ) + ) + + # Pretend verifier privately saw: + # + # 1 0 1 1 1 + # + # None of it is supplied to builder. + + state = builder.observe( + 0 + ) + + # Newly authorized LAG(4) is zero-padded + # because policy has only prospectively seen + # the current observation. + self.assertEqual( + state, + (0, 0), + ) + + def test_retirement_removes_policy_feature(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(1) + ) + + registry.propose( + spec + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash="b" * 64, + reason="TEST", + ) + ) + + builder = ( + ConstructionStateBuilder( + registry + ) + ) + + self.assertEqual( + len( + builder.observe(1) + ), + 2, + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.RETIRE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash="c" * 64, + reason="TEST_RETIRE", + ) + ) + + self.assertEqual( + builder.observe(0), + (0,), + ) + + +class ReceiptTests(unittest.TestCase): + def test_receipt_tamper_detected(self): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(2) + ) + + registry.propose( + spec + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash="d" * 64, + reason="TEST", + ) + ) + + records = ( + registry.receipts.records + ) + + self.assertTrue( + verify_receipt_chain( + records, + expected_count=( + registry.receipts.count + ), + expected_tip=( + registry.receipts.tip + ), + ) + ) + + damaged = deepcopy( + records + ) + + damaged[0][ + "payload" + ][ + "reason" + ] = "TAMPER" + + self.assertFalse( + verify_receipt_chain( + damaged, + expected_count=1, + expected_tip=( + registry.receipts.tip + ), + ) + ) + + +class EngineTests(unittest.TestCase): + def test_engine_can_discover_lag4(self): + spec = ConstructionSpec( + expression=lag(4) + ) + + engine = ( + AdaptiveConstructionEngine( + candidates=(spec,) + ) + ) + + engine.begin_episode() + + history = [] + + x = 0x12345678 + + authorized = False + + for _ in range(2000): + x = ( + 1103515245 * x + + 12345 + ) & 0x7FFFFFFF + + observation = ( + x >> 29 + ) & 1 + + history.append( + observation + ) + + target = ( + history[-5] + if len(history) >= 5 + else 0 + ) + + engine.observe( + observation + ) + + decision = ( + engine.finalize( + target + ) + ) + + if decision.authorized: + authorized = True + break + + self.assertTrue( + authorized + ) + + self.assertEqual( + engine.active_construction_ids, + ( + spec.construction_id, + ), + ) + + self.assertTrue( + verify_receipt_chain( + engine.receipt_chain, + expected_count=1, + ) + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_evaluation_v0_3.py b/tests/test_prime_m20_evaluation_v0_3.py new file mode 100644 index 0000000..a0f9153 --- /dev/null +++ b/tests/test_prime_m20_evaluation_v0_3.py @@ -0,0 +1,111 @@ +"""Frozen evaluation-apparatus tests without held-out execution.""" + +import unittest + +from experiments.prime_m20_universal_arena.run_evaluation_v0_3 import ( + BOOTSTRAP_REPLICATES, + LOWER_INDEX, + UPPER_INDEX, + cluster_bootstrap, +) +from experiments.prime_m20_universal_arena.runner_v0_3 import ( + EVALUATION_SEEDS, +) +from experiments.prime_m20_universal_arena.tasks import ( + TASKS, +) + + +class ClusterBootstrapTests( + unittest.TestCase +): + def test_contract_constants( + self, + ): + self.assertEqual( + BOOTSTRAP_REPLICATES, + 16384, + ) + + self.assertEqual( + LOWER_INDEX, + 409, + ) + + self.assertEqual( + UPPER_INDEX, + 15974, + ) + + self.assertEqual( + len(EVALUATION_SEEDS), + 32, + ) + + self.assertEqual( + len(TASKS), + 12, + ) + + def test_constant_positive_effect( + self, + ): + rows = [ + { + "seed": seed, + "task": task.name, + "delta": 100, + } + for seed + in EVALUATION_SEEDS + for task + in TASKS + ] + + result = ( + cluster_bootstrap( + rows + ) + ) + + self.assertEqual( + result[ + "lower_ppm" + ], + 100, + ) + + self.assertEqual( + result[ + "upper_ppm" + ], + 100, + ) + + def test_cluster_structure_required( + self, + ): + rows = [ + { + "seed": seed, + "task": task.name, + "delta": 1, + } + for seed + in EVALUATION_SEEDS + for task + in TASKS + ] + + rows.pop() + + with self.assertRaises( + RuntimeError + ): + cluster_bootstrap( + rows + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_global_alpha.py b/tests/test_prime_m20_global_alpha.py new file mode 100644 index 0000000..852af5b --- /dev/null +++ b/tests/test_prime_m20_global_alpha.py @@ -0,0 +1,183 @@ +"""Global sequential alpha-spending tests for PRIME M20.""" + +from fractions import Fraction +import unittest + +from core.construction.compositional_engine import ( + CompositionalAdaptiveConstructionEngine, +) +from core.construction.evidence import ( + EvidenceEpoch, + RUN_LEVEL_ALPHA_DENOMINATOR, + global_epoch_alpha_denominator, +) +from core.construction.grammar import ( + generate_bounded_candidates, +) + + +class AlphaScheduleTests( + unittest.TestCase +): + def setUp(self): + self.candidates = tuple( + generate_bounded_candidates( + max_lag=2, + max_candidates=8, + ) + ) + + def test_legacy_single_epoch_semantics_preserved( + self, + ): + epoch = EvidenceEpoch( + self.candidates + ) + + self.assertEqual( + epoch.alpha_denominator, + 64, + ) + + self.assertEqual( + epoch.threshold, + 64 * len( + self.candidates + ), + ) + + def test_adaptive_epoch_zero_reserves_future_budget( + self, + ): + epoch = EvidenceEpoch( + self.candidates, + epoch_index=0, + ) + + self.assertEqual( + epoch.alpha_denominator, + 128, + ) + + self.assertEqual( + epoch.threshold, + 128 * len( + self.candidates + ), + ) + + def test_dyadic_schedule( + self, + ): + expected = ( + 128, + 256, + 512, + 1024, + 2048, + ) + + observed = tuple( + global_epoch_alpha_denominator( + epoch + ) + for epoch + in range( + len(expected) + ) + ) + + self.assertEqual( + observed, + expected, + ) + + def test_negative_epoch_rejected( + self, + ): + with self.assertRaises( + ValueError + ): + global_epoch_alpha_denominator( + -1 + ) + + def test_infinite_schedule_sums_to_run_budget( + self, + ): + # Explicitly verify a finite prefix plus its exact + # geometric tail equals 1/64. + prefix_length = 20 + + prefix = sum( + ( + Fraction( + 1, + global_epoch_alpha_denominator( + epoch + ), + ) + for epoch + in range( + prefix_length + ) + ), + Fraction(0, 1), + ) + + tail = Fraction( + 1, + ( + RUN_LEVEL_ALPHA_DENOMINATOR + * (1 << prefix_length) + ), + ) + + self.assertEqual( + prefix + tail, + Fraction( + 1, + RUN_LEVEL_ALPHA_DENOMINATOR, + ), + ) + + +class CompositionalEngineTests( + unittest.TestCase +): + def test_engine_epoch_zero_uses_global_schedule( + self, + ): + engine = ( + CompositionalAdaptiveConstructionEngine( + max_lag=2, + max_candidates=8, + enable_scaffolds=False, + ) + ) + + snapshot = ( + engine.candidate_field_snapshot() + ) + + self.assertEqual( + snapshot.epoch, + 0, + ) + + self.assertEqual( + snapshot.alpha_denominator, + 128, + ) + + self.assertEqual( + snapshot.threshold, + ( + 128 + * snapshot.candidate_count + ), + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m20_quotient.py b/tests/test_prime_m20_quotient.py new file mode 100644 index 0000000..d50cff4 --- /dev/null +++ b/tests/test_prime_m20_quotient.py @@ -0,0 +1,230 @@ +"""Predictive quotient tests for PRIME M20.""" + +import unittest + +from core.construction.compression import ( + propose_partition_compression, +) +from core.construction.grammar import ( + binary, + lag, + ref, +) +from core.construction.quotient import ( + RELATION_COMPLEMENT, + RELATION_DIFFERENT, + RELATION_EXACT, + active_partition_matches, + predictive_partition_signature, + semantic_relation, +) +from core.construction.registry import ( + ConstructionRegistry, +) +from core.construction.types import ( + AuthorityAction, + ConstructionSpec, + FeatureOp, + VerifierAuthorization, +) + + +def authorize( + registry, + spec, + token, +): + registry.propose( + spec + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash=( + token * 64 + )[:64], + reason="TEST", + ) + ) + + +class QuotientTests( + unittest.TestCase +): + def test_xor_eq_are_complement_equivalent(self): + xor_expr = binary( + FeatureOp.XOR, + lag(2), + lag(7), + ) + + eq_expr = binary( + FeatureOp.EQ, + lag(2), + lag(7), + ) + + self.assertEqual( + semantic_relation( + xor_expr, + eq_expr, + ), + RELATION_COMPLEMENT, + ) + + self.assertEqual( + predictive_partition_signature( + xor_expr + ), + predictive_partition_signature( + eq_expr + ), + ) + + def test_and_or_are_not_equivalent(self): + and_expr = binary( + FeatureOp.AND, + lag(1), + lag(4), + ) + + or_expr = binary( + FeatureOp.OR, + lag(1), + lag(4), + ) + + self.assertEqual( + semantic_relation( + and_expr, + or_expr, + ), + RELATION_DIFFERENT, + ) + + def test_identical_is_exact(self): + a = binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + + b = binary( + FeatureOp.XOR, + lag(4), + lag(1), + ) + + self.assertEqual( + semantic_relation( + a, + b, + ), + RELATION_EXACT, + ) + + def test_ref_expansion_preserves_semantics(self): + registry = ( + ConstructionRegistry() + ) + + parent = ConstructionSpec( + expression=lag(4) + ) + + authorize( + registry, + parent, + "a", + ) + + child = ConstructionSpec( + expression=ref( + parent.construction_id + ), + proposal_source="test", + ) + + authorize( + registry, + child, + "b", + ) + + matches = ( + active_partition_matches( + registry, + lag(4), + ) + ) + + self.assertEqual( + len(matches), + 2, + ) + + def test_compression_is_proposal_only(self): + registry = ( + ConstructionRegistry() + ) + + xor_spec = ConstructionSpec( + expression=binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + ) + + eq_spec = ConstructionSpec( + expression=binary( + FeatureOp.EQ, + lag(1), + lag(4), + ) + ) + + authorize( + registry, + xor_spec, + "c", + ) + + authorize( + registry, + eq_spec, + "d", + ) + + proposals = ( + propose_partition_compression( + registry + ) + ) + + self.assertEqual( + len(proposals), + 1, + ) + + self.assertFalse( + proposals[0].state_commit_authorized + ) + + self.assertEqual( + len( + registry.active_ids() + ), + 2, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m21_cognition.py b/tests/test_prime_m21_cognition.py new file mode 100644 index 0000000..a2f9da6 --- /dev/null +++ b/tests/test_prime_m21_cognition.py @@ -0,0 +1,640 @@ +"""PRIME M21 persistent adaptive cognition tests.""" + +import tempfile +import unittest + +from core.cognition import ( + ActiveStudySelector, + DistributedProposalField, + EpisodicMemory, + MegaPrimeCognition, + SchemaMiner, + StudyAction, + TransferEngine, + VerifiedConstructionMemory, + VerifiedPlanner, + VerifiedWorldModel, +) +from core.construction.grammar import ( + binary, + lag, +) +from core.construction.registry import ( + ConstructionRegistry, +) +from core.construction.types import ( + AuthorityAction, + ConstructionSpec, + FeatureOp, + VerifierAuthorization, +) + + +def authorize_construction( + registry, + spec, + token="a", +): + registry.propose( + spec + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash=( + token * 64 + )[:64], + reason="TEST", + ) + ) + + +class SemanticMemoryTests( + unittest.TestCase +): + def test_verified_construction_survives_world_boundary( + self, + ): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + authorize_construction( + registry, + spec, + ) + + memory = ( + VerifiedConstructionMemory() + ) + + touched = ( + memory.ingest_registry( + registry, + context_id="world-a", + ) + ) + + self.assertEqual( + len(touched), + 1, + ) + + self.assertEqual( + len(memory.entries), + 1, + ) + + def test_memory_roundtrip( + self, + ): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + authorize_construction( + registry, + spec, + ) + + memory = ( + VerifiedConstructionMemory() + ) + + memory.ingest_registry( + registry, + context_id="world-a", + ) + + with tempfile.TemporaryDirectory() as tmp: + path = ( + tmp + + "/semantic.json" + ) + + memory.save( + path + ) + + loaded = ( + VerifiedConstructionMemory.load( + path + ) + ) + + self.assertEqual( + len( + loaded.entries + ), + 1, + ) + + self.assertEqual( + set( + loaded.entries + ), + set( + memory.entries + ), + ) + + +class TransferTests( + unittest.TestCase +): + def test_transfer_is_not_authority( + self, + ): + source = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + authorize_construction( + source, + spec, + ) + + memory = ( + VerifiedConstructionMemory() + ) + + memory.ingest_registry( + source, + context_id="old-world", + ) + + field = ( + DistributedProposalField() + ) + + transfer = ( + TransferEngine( + memory, + field, + ) + ) + + target = ( + ConstructionRegistry() + ) + + proposals = ( + transfer.recall( + context_tokens=( + "partial-observation", + ) + ) + ) + + transfer.stage( + target, + proposals, + ) + + self.assertTrue( + proposals + ) + + self.assertEqual( + target.active_ids(), + (), + ) + + self.assertFalse( + proposals[0].state_commit_authorized + ) + + def test_field_learns_transfer_preference( + self, + ): + field = ( + DistributedProposalField() + ) + + good = ConstructionSpec( + expression=lag(1) + ) + + bad = ConstructionSpec( + expression=lag(7) + ) + + context = ( + "short-memory", + ) + + field.update( + good, + context, + accepted=True, + gain_ppm=200000, + ) + + field.update( + bad, + context, + accepted=False, + gain_ppm=-100000, + ) + + self.assertGreater( + field.score( + good, + context, + ), + field.score( + bad, + context, + ), + ) + + +class EpisodeTests( + unittest.TestCase +): + def test_episode_chain( + self, + ): + memory = ( + EpisodicMemory() + ) + + memory.append( + context_id="a", + context_tokens=("x",), + verified_construction_ids=( + "cx:a", + ), + reward_ppm=100, + ) + + memory.append( + context_id="b", + context_tokens=("y",), + verified_construction_ids=( + "cx:b", + ), + reward_ppm=200, + ) + + self.assertTrue( + memory.verify_chain() + ) + + self.assertNotEqual( + memory.records[0].episode_hash, + memory.records[1].episode_hash, + ) + + +class StudyTests( + unittest.TestCase +): + def test_selector_prefers_disagreement( + self, + ): + selector = ( + ActiveStudySelector() + ) + + weak = StudyAction( + action_id="wait", + candidate_predictions={ + "h1": 1, + "h2": 1, + "h3": 1, + }, + ) + + strong = StudyAction( + action_id="probe", + candidate_predictions={ + "h1": 0, + "h2": 1, + "h3": 0, + }, + ) + + ranked = selector.rank( + ( + weak, + strong, + ) + ) + + self.assertEqual( + ranked[0].action_id, + "probe", + ) + + self.assertFalse( + ranked[ + 0 + ].state_commit_authorized + ) + + +class WorldModelTests( + unittest.TestCase +): + def test_transition_proposal_not_authority( + self, + ): + cognition = ( + MegaPrimeCognition() + ) + + for _ in range(16): + cognition.observe_transition( + (0,), + "right", + (1,), + ) + + candidate = ( + cognition.world_model.propose_rule( + (0,), + "right", + ) + ) + + self.assertIsNotNone( + candidate + ) + + self.assertIsNone( + cognition.world_model.step_verified( + (0,), + "right", + ) + ) + + def test_verified_transition_can_plan( + self, + ): + cognition = ( + MegaPrimeCognition() + ) + + for _ in range(16): + cognition.observe_transition( + (0,), + "right", + (1,), + ) + + cognition.observe_transition( + (1,), + "right", + (2,), + ) + + first = ( + cognition.verify_transition( + (0,), + "right", + ) + ) + + second = ( + cognition.verify_transition( + (1,), + "right", + ) + ) + + self.assertTrue( + first[1].verdict + ) + + self.assertTrue( + second[1].verdict + ) + + plan = cognition.plan( + (0,), + (2,), + ) + + self.assertIsNotNone( + plan + ) + + self.assertEqual( + plan.actions, + ( + "right", + "right", + ), + ) + + self.assertTrue( + plan.canonical_support + ) + + +class SchemaTests( + unittest.TestCase +): + def test_shifted_relation_schema_proposal( + self, + ): + memory = ( + VerifiedConstructionMemory() + ) + + for index, expr in enumerate( + ( + binary( + FeatureOp.XOR, + lag(1), + lag(4), + ), + binary( + FeatureOp.XOR, + lag(2), + lag(5), + ), + ) + ): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=expr + ) + + authorize_construction( + registry, + spec, + token=chr( + ord("a") + + index + ), + ) + + memory.ingest_registry( + registry, + context_id=( + "world-" + + str(index) + ), + ) + + proposals = ( + SchemaMiner().mine( + memory, + minimum_examples=2, + ) + ) + + self.assertTrue( + proposals + ) + + self.assertEqual( + proposals[ + 0 + ].normalized_offsets, + ( + 0, + 3, + ), + ) + + self.assertFalse( + proposals[ + 0 + ].state_commit_authorized + ) + + +class IntegratedCognitionTests( + unittest.TestCase +): + def test_verified_learning_transfers_but_requires_new_authority( + self, + ): + cognition = ( + MegaPrimeCognition() + ) + + old_world = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=lag(4) + ) + + authorize_construction( + old_world, + spec, + ) + + cognition.close_world( + old_world, + context_id="world-a", + context_tokens=( + "memory", + "binary", + ), + reward_ppm=900000, + ) + + new_world = ( + ConstructionRegistry() + ) + + proposals = ( + cognition.open_world( + new_world, + context_tokens=( + "memory", + "binary", + ), + ) + ) + + self.assertTrue( + proposals + ) + + # Transfer recall has changed search, + # but has NOT changed canonical state. + self.assertEqual( + new_world.active_ids(), + (), + ) + + transferred = ( + proposals[0] + ) + + authorize_construction( + new_world, + transferred.spec, + token="z", + ) + + self.assertEqual( + len( + new_world.active_ids() + ), + 1, + ) + + cognition.record_transfer_result( + transferred, + context_tokens=( + "memory", + "binary", + ), + accepted=True, + gain_ppm=150000, + ) + + self.assertGreater( + cognition.meta_memory.priority( + "cross-world-transfer" + ), + 0, + ) + + snapshot = ( + cognition.snapshot() + ) + + self.assertEqual( + snapshot.semantic_memory_classes, + 1, + ) + + self.assertEqual( + snapshot.episodes, + 1, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m22_developmental_world.py b/tests/test_prime_m22_developmental_world.py new file mode 100644 index 0000000..fd42e85 --- /dev/null +++ b/tests/test_prime_m22_developmental_world.py @@ -0,0 +1,324 @@ +"""PRIME M22 developmental laboratory tests.""" + +import unittest + +from core.cognition import ( + MegaPrimeCognition, +) +from core.construction.grammar import ( + binary, + lag, +) +from core.construction.registry import ( + ConstructionRegistry, +) +from core.construction.types import ( + AuthorityAction, + ConstructionSpec, + FeatureOp, + VerifierAuthorization, +) + +from experiments.prime_m22_developmental_world.candidate_source import ( + DevelopmentalCandidateSource, +) +from experiments.prime_m22_developmental_world.primed_engine import ( + PrimedConstructionEngine, +) +from experiments.prime_m22_developmental_world.runner import ( + run_chapter, +) +from experiments.prime_m22_developmental_world.world import ( + ChapterSpec, + curriculum, +) + + +def authorize( + registry, + spec, + token, +): + registry.propose( + spec + ) + + registry.apply( + VerifierAuthorization( + action=( + AuthorityAction.AUTHORIZE + ), + construction_id=( + spec.construction_id + ), + verdict=True, + evidence_hash=( + token * 64 + )[:64], + reason="M22_TEST", + ) + ) + + +class CurriculumTests( + unittest.TestCase +): + def test_curriculum_is_persistent_sequence( + self, + ): + chapters = curriculum() + + self.assertGreaterEqual( + len(chapters), + 20, + ) + + self.assertEqual( + len( + { + chapter.chapter_id + for chapter + in chapters + } + ), + len(chapters), + ) + + roles = { + chapter.developmental_role + for chapter + in chapters + } + + self.assertIn( + "repeat", + roles, + ) + + self.assertIn( + "schema-transfer", + roles, + ) + + self.assertIn( + "negative-transfer", + roles, + ) + + +class PrimingTests( + unittest.TestCase +): + def test_priority_candidates_do_not_authorize( + self, + ): + spec = ConstructionSpec( + expression=lag(4) + ) + + engine = ( + PrimedConstructionEngine( + priority_specs=( + spec, + ) + ) + ) + + self.assertEqual( + engine.active_construction_ids, + (), + ) + + self.assertTrue( + engine.primed + ) + + def test_prior_knowledge_compresses_candidate_field( + self, + ): + cold = ( + PrimedConstructionEngine() + ) + + primed = ( + PrimedConstructionEngine( + priority_specs=( + ConstructionSpec( + expression=lag(4) + ), + ) + ) + ) + + self.assertEqual( + cold.candidate_field_snapshot().candidate_count, + 256, + ) + + self.assertEqual( + primed.candidate_field_snapshot().candidate_count, + 64, + ) + + +class SchemaTransferTests( + unittest.TestCase +): + def test_shift_schema_generates_unseen_relation( + self, + ): + brain = ( + MegaPrimeCognition() + ) + + for index, expr in enumerate( + ( + binary( + FeatureOp.XOR, + lag(1), + lag(4), + ), + binary( + FeatureOp.XOR, + lag(2), + lag(5), + ), + ) + ): + registry = ( + ConstructionRegistry() + ) + + spec = ConstructionSpec( + expression=expr + ) + + authorize( + registry, + spec, + chr( + ord("a") + + index + ), + ) + + brain.close_world( + registry, + context_id=( + "schema-world-" + + str(index) + ), + context_tokens=( + "prime-m22-developmental-lab", + "binary-partial-observation", + "persistent-curriculum", + ), + reward_ppm=900000, + ) + + candidates = ( + DevelopmentalCandidateSource( + brain + ).propose( + context_tokens=( + "prime-m22-developmental-lab", + "binary-partial-observation", + "persistent-curriculum", + ) + ) + ) + + target = ConstructionSpec( + expression=binary( + FeatureOp.XOR, + lag(3), + lag(6), + ) + ) + + self.assertIn( + target.construction_id, + { + row.spec.construction_id + for row in candidates + }, + ) + + +class DevelopmentTests( + unittest.TestCase +): + def test_repeat_world_uses_persistent_memory( + self, + ): + brain = ( + MegaPrimeCognition() + ) + + first = ChapterSpec( + chapter_id="first", + seed=33101, + expression=lag(1), + developmental_role="novel", + steps=512, + ) + + repeat = ChapterSpec( + chapter_id="repeat", + seed=33102, + expression=lag(1), + developmental_role="repeat", + steps=512, + ) + + first_result = ( + run_chapter( + first, + cognition=brain, + persistent=True, + ).payload + ) + + self.assertTrue( + first_result[ + "recovered" + ] + ) + + second_result = ( + run_chapter( + repeat, + cognition=brain, + persistent=True, + ).payload + ) + + self.assertTrue( + second_result[ + "primed" + ] + ) + + self.assertGreater( + second_result[ + "priority_candidate_count" + ], + 0, + ) + + self.assertLessEqual( + second_result[ + "initial_candidate_count" + ], + 64, + ) + + self.assertTrue( + second_result[ + "recovered" + ] + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m22_hypothesis_ecology.py b/tests/test_prime_m22_hypothesis_ecology.py new file mode 100644 index 0000000..63b63c9 --- /dev/null +++ b/tests/test_prime_m22_hypothesis_ecology.py @@ -0,0 +1,255 @@ +"""PRIME M22 weighted hypothesis ecology tests.""" + +from fractions import Fraction +import unittest + +from core.cognition.hypothesis_ecology import ( + WeightedEvidenceEpoch, + allocate_hypothesis_mass, +) +from core.construction.evidence import ( + global_epoch_alpha_denominator, +) +from core.construction.grammar import ( + binary, + generate_bounded_candidates, + lag, +) +from core.construction.types import ( + ConstructionSpec, + FeatureOp, +) + +from experiments.prime_m22_developmental_world.ecological_engine import ( + EcologicalConstructionEngine, +) + + +class AllocationTests( + unittest.TestCase +): + def setUp(self): + self.candidates = tuple( + generate_bounded_candidates( + max_lag=4, + max_candidates=32, + ) + ) + + def test_equal_mass_reproduces_uniform_threshold( + self, + ): + allocation = ( + allocate_hypothesis_mass( + self.candidates, + priority_ids=(), + ) + ) + + epoch = WeightedEvidenceEpoch( + self.candidates, + epoch_index=0, + allocation=allocation, + ) + + expected = ( + global_epoch_alpha_denominator( + 0 + ) + * len( + self.candidates + ) + ) + + self.assertTrue( + all( + threshold + == expected + for threshold + in epoch.thresholds.values() + ) + ) + + def test_priority_gets_more_alpha_budget( + self, + ): + priority = ( + self.candidates[ + 0 + ].construction_id + ) + + allocation = ( + allocate_hypothesis_mass( + self.candidates, + priority_ids=( + priority, + ), + ) + ) + + epoch = WeightedEvidenceEpoch( + self.candidates, + epoch_index=0, + allocation=allocation, + ) + + other = ( + self.candidates[ + -1 + ].construction_id + ) + + self.assertLess( + epoch.threshold_for( + priority + ), + epoch.threshold_for( + other + ), + ) + + def test_weighted_alpha_sum_stays_inside_epoch_budget( + self, + ): + priority = tuple( + spec.construction_id + for spec + in self.candidates[:7] + ) + + allocation = ( + allocate_hypothesis_mass( + self.candidates, + priority_ids=( + priority + ), + ) + ) + + epoch = WeightedEvidenceEpoch( + self.candidates, + epoch_index=0, + allocation=allocation, + ) + + spent_upper_bound = sum( + ( + Fraction( + 1, + threshold, + ) + for threshold + in epoch.thresholds.values() + ), + Fraction( + 0, + 1, + ), + ) + + epoch_budget = Fraction( + 1, + global_epoch_alpha_denominator( + 0 + ), + ) + + self.assertLessEqual( + spent_upper_bound, + epoch_budget, + ) + + +class CoverageTests( + unittest.TestCase +): + def test_prior_never_removes_universal_candidates( + self, + ): + cold = ( + EcologicalConstructionEngine() + ) + + priorities = ( + ConstructionSpec( + expression=lag(1) + ), + ConstructionSpec( + expression=binary( + FeatureOp.XOR, + lag(1), + lag(4), + ) + ), + ) + + primed = ( + EcologicalConstructionEngine( + priority_specs=( + priorities + ) + ) + ) + + cold_ids = set( + cold.candidate_construction_ids + ) + + primed_ids = set( + primed.candidate_construction_ids + ) + + self.assertTrue( + cold_ids.issubset( + primed_ids + ) + ) + + def test_higher_order_safety_field_survives_priming( + self, + ): + priorities = tuple( + ConstructionSpec( + expression=lag(k) + ) + for k in range( + 1, + 9, + ) + ) + + engine = ( + EcologicalConstructionEngine( + priority_specs=( + priorities + ) + ) + ) + + # The critical property is that priming does not collapse + # candidate coverage back to 64. + self.assertGreaterEqual( + len( + engine.candidate_construction_ids + ), + 256, + ) + + ecology = ( + engine.ecology_snapshot() + ) + + self.assertGreater( + ecology.priority_candidate_count, + 0, + ) + + self.assertGreater( + ecology.maximum_threshold, + ecology.minimum_threshold, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m23_causal_world.py b/tests/test_prime_m23_causal_world.py new file mode 100644 index 0000000..a5acad9 --- /dev/null +++ b/tests/test_prime_m23_causal_world.py @@ -0,0 +1,147 @@ +"""PRIME M23 causal developmental intelligence tests.""" + +import unittest + +from experiments.prime_m23_causal_world.episode import ( + solve_episode, +) +from experiments.prime_m23_causal_world.lab import ( + ALL_LAWS, + CausalLab, + DoorLaw, + evaluate_law, +) +from experiments.prime_m23_causal_world.scientist import ( + CausalScientist, +) + + +class LawTests( + unittest.TestCase +): + def test_truth_tables_are_distinct( + self, + ): + signatures = { + tuple( + evaluate_law( + law, + a, + b, + ) + for a, b in ( + (0, 0), + (0, 1), + (1, 0), + (1, 1), + ) + ) + for law + in ALL_LAWS + } + + self.assertEqual( + len(signatures), + len(ALL_LAWS), + ) + + +class ScientistTests( + unittest.TestCase +): + def test_every_law_can_be_identified( + self, + ): + for law in ALL_LAWS: + scientist = ( + CausalScientist() + ) + + while ( + scientist.verified_law + is None + ): + config = ( + scientist.choose_intervention() + ) + + scientist.observe( + config, + evaluate_law( + law, + config[0], + config[1], + ), + ) + + self.assertEqual( + scientist.verified_law, + law, + ) + + def test_wrong_prior_is_falsifiable( + self, + ): + result = solve_episode( + DoorLaw.XOR, + prior=DoorLaw.AND, + ) + + self.assertEqual( + result.verified_law, + DoorLaw.XOR, + ) + + self.assertTrue( + result.goal_reached + ) + + +class WorldTests( + unittest.TestCase +): + def test_closed_door_blocks_navigation( + self, + ): + lab = CausalLab( + DoorLaw.AND + ) + + path = lab.shortest_path( + lab.state.position, + lab.layout.goal, + ) + + self.assertIsNone( + path + ) + + def test_verified_causal_knowledge_reaches_goal( + self, + ): + for law in ALL_LAWS: + result = solve_episode( + law + ) + + self.assertTrue( + result.verified + ) + + self.assertEqual( + result.verified_law, + law, + ) + + self.assertTrue( + result.goal_reached + ) + + self.assertLessEqual( + result.interventions, + 4, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m24_causal_program.py b/tests/test_prime_m24_causal_program.py new file mode 100644 index 0000000..6951087 --- /dev/null +++ b/tests/test_prime_m24_causal_program.py @@ -0,0 +1,299 @@ +"""PRIME M24 causal program induction tests.""" + +import unittest + +from core.cognition import ( + MegaPrimeCognition, +) +from core.cognition.causal_certificate import ( + CausalAuthorityLedger, + compatible_program_ids, + minimal_certificate, +) +from core.cognition.causal_program import ( + CausalProgram, + ProgramOp, + program_universe, +) + +from experiments.prime_m24_causal_program_world.episode import ( + run_program_episode, +) + + +class ProgramUniverseTests( + unittest.TestCase +): + def test_universe_has_47_distinct_programs( + self, + ): + universe = ( + program_universe() + ) + + self.assertEqual( + len(universe), + 47, + ) + + self.assertEqual( + len( + { + program.signature + for program + in universe + } + ), + 47, + ) + + +class CertificateTests( + unittest.TestCase +): + def test_certificate_uniquely_identifies_program( + self, + ): + target = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + certificate = ( + minimal_certificate( + target.program_id + ) + ) + + observations = { + configuration: ( + target.evaluate( + configuration + ) + ) + for configuration + in certificate + } + + self.assertEqual( + compatible_program_ids( + observations + ), + ( + target.program_id, + ), + ) + + self.assertLessEqual( + len(certificate), + 5, + ) + + def test_authority_rejects_insufficient_evidence( + self, + ): + target = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + ledger = ( + CausalAuthorityLedger() + ) + + auth = ledger.authorize( + target.program_id, + { + (0, 0, 0, 0): 0, + }, + ) + + self.assertFalse( + auth.verdict + ) + + self.assertTrue( + ledger.verify_chain() + ) + + +class DevelopmentalTransferTests( + unittest.TestCase +): + def test_correct_prior_reduces_xor_experiment_count( + self, + ): + target = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + cold = ( + run_program_episode( + target + ) + ) + + primed = ( + run_program_episode( + target, + priority_program_ids=( + target.program_id, + ), + ) + ) + + self.assertLess( + primed.interventions, + cold.interventions, + ) + + self.assertTrue( + primed.authorization.verdict + ) + + self.assertTrue( + primed.goal_reached + ) + + def test_wrong_prior_cannot_authorize( + self, + ): + target = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + wrong = CausalProgram( + ProgramOp.AND, + ( + 0, + 1, + ), + ) + + result = ( + run_program_episode( + target, + priority_program_ids=( + wrong.program_id, + ), + ) + ) + + self.assertEqual( + result.authorization.program_id, + target.program_id, + ) + + self.assertTrue( + result.authorization.verdict + ) + + self.assertIn( + wrong.program_id, + result.falsified_priority_ids, + ) + + +class CausalSchemaTests( + unittest.TestCase +): + def test_shifted_causal_schema_proposes_unseen_program( + self, + ): + brain = ( + MegaPrimeCognition() + ) + + ledger = ( + CausalAuthorityLedger() + ) + + first = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + second = CausalProgram( + ProgramOp.XOR, + ( + 1, + 2, + ), + ) + + for program in ( + first, + second, + ): + certificate = ( + minimal_certificate( + program.program_id + ) + ) + + observations = { + configuration: ( + program.evaluate( + configuration + ) + ) + for configuration + in certificate + } + + authorization = ( + ledger.authorize( + program.program_id, + observations, + ) + ) + + self.assertTrue( + authorization.verdict + ) + + brain.causal_program_memory.ingest( + authorization + ) + + unseen = ( + CausalProgram( + ProgramOp.XOR, + ( + 2, + 3, + ), + ) + ) + + priorities = ( + brain.causal_program_memory.priority_program_ids( + limit=16 + ) + ) + + self.assertIn( + unseen.program_id, + priorities, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m25_epistemic_control.py b/tests/test_prime_m25_epistemic_control.py new file mode 100644 index 0000000..dba6597 --- /dev/null +++ b/tests/test_prime_m25_epistemic_control.py @@ -0,0 +1,323 @@ +"""PRIME M25 epistemic-control tests.""" + +import unittest + +from core.cognition import ( + MegaPrimeCognition, +) +from core.cognition.causal_certificate import ( + CausalAuthorityLedger, + minimal_certificate, +) +from core.cognition.causal_ecology import ( + WeightedCausalStudySelector, + build_causal_mass_field, +) +from core.cognition.causal_program import ( + CausalProgram, + ProgramOp, + program_universe, +) + +from experiments.prime_m24_causal_program_world.lab import ( + ProgramLab, +) +from experiments.prime_m25_epistemic_control.development import ( + curriculum, +) +from experiments.prime_m25_epistemic_control.episode import ( + run_epistemic_episode, +) + + +class EcologyTests( + unittest.TestCase +): + def test_every_program_keeps_positive_mass( + self, + ): + brain = ( + MegaPrimeCognition() + ) + + field = ( + build_causal_mass_field( + brain.causal_program_memory + ) + ) + + self.assertTrue( + all( + field.mass( + program.program_id + ) > 0 + for program + in program_universe() + ) + ) + + def test_prior_bonus_cannot_exceed_universal_mass( + self, + ): + brain = ( + MegaPrimeCognition() + ) + + ledger = ( + CausalAuthorityLedger() + ) + + for program in ( + program_universe()[:20] + ): + certificate = ( + minimal_certificate( + program.program_id + ) + ) + + observations = { + configuration: ( + program.evaluate( + configuration + ) + ) + for configuration + in certificate + } + + auth = ledger.authorize( + program.program_id, + observations, + ) + + self.assertTrue( + auth.verdict + ) + + brain.causal_program_memory.ingest( + auth + ) + + field = ( + build_causal_mass_field( + brain.causal_program_memory + ) + ) + + self.assertLessEqual( + field.bonus_mass, + field.universal_mass, + ) + + def test_verified_exact_memory_gets_extra_mass( + self, + ): + brain = ( + MegaPrimeCognition() + ) + + target = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + ledger = ( + CausalAuthorityLedger() + ) + + certificate = ( + minimal_certificate( + target.program_id + ) + ) + + auth = ledger.authorize( + target.program_id, + { + configuration: ( + target.evaluate( + configuration + ) + ) + for configuration + in certificate + }, + ) + + brain.causal_program_memory.ingest( + auth + ) + + field = ( + build_causal_mass_field( + brain.causal_program_memory + ) + ) + + self.assertGreater( + field.mass( + target.program_id + ), + field.base_mass, + ) + + +class SelectorTests( + unittest.TestCase +): + def test_selector_prices_physical_cost( + self, + ): + field = ( + build_causal_mass_field( + None + ) + ) + + lab = ProgramLab( + CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + ) + + selector = ( + WeightedCausalStudySelector() + ) + + study = selector.choose( + surviving_program_ids={ + program.program_id + for program + in program_universe() + }, + observations={}, + mass_field=field, + intervention_cost=( + lab.cost_to_probe + ), + ) + + self.assertGreater( + study.information_product, + 0, + ) + + self.assertGreater( + study.primitive_cost, + 0, + ) + + +class AuthorityTests( + unittest.TestCase +): + def test_weighted_prior_cannot_change_truth( + self, + ): + target = CausalProgram( + ProgramOp.XOR, + ( + 0, + 1, + ), + ) + + brain = ( + MegaPrimeCognition() + ) + + wrong = CausalProgram( + ProgramOp.AND, + ( + 0, + 1, + ), + ) + + ledger = ( + CausalAuthorityLedger() + ) + + certificate = ( + minimal_certificate( + wrong.program_id + ) + ) + + wrong_auth = ( + ledger.authorize( + wrong.program_id, + { + configuration: ( + wrong.evaluate( + configuration + ) + ) + for configuration + in certificate + }, + ) + ) + + brain.causal_program_memory.ingest( + wrong_auth + ) + + field = ( + build_causal_mass_field( + brain.causal_program_memory + ) + ) + + result = ( + run_epistemic_episode( + target, + mass_field=field, + ) + ) + + self.assertEqual( + result.target_program_id, + target.program_id, + ) + + self.assertTrue( + result.goal_reached + ) + + +class CurriculumTests( + unittest.TestCase +): + def test_lifetime_has_128_chapters( + self, + ): + rows = curriculum() + + self.assertEqual( + len(rows), + 128, + ) + + self.assertEqual( + len( + { + program.program_id + for _, program + in rows[:24] + } + ), + 24, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_m26_comparative_cognition.py b/tests/test_prime_m26_comparative_cognition.py new file mode 100644 index 0000000..d0cc237 --- /dev/null +++ b/tests/test_prime_m26_comparative_cognition.py @@ -0,0 +1,137 @@ +"""PRIME M26 comparative cognition tests.""" + +import unittest + +from experiments.prime_m26_comparative_cognition.gru_agent import ( + GRUOnlinePredictor, +) +from experiments.prime_m26_comparative_cognition.runner import ( + EVALUATION_SEEDS, + run_world, +) +from experiments.prime_m26_comparative_cognition.tasks import ( + tasks, +) + + +class TaskTests( + unittest.TestCase +): + def test_task_families_present( + self, + ): + rows = tasks() + + self.assertEqual( + len(rows), + 18, + ) + + families = { + row.family + for row in rows + } + + self.assertEqual( + families, + { + "explicit-relational", + "scaling", + "recurrent-state", + "nonstationary", + }, + ) + + +class GRUTests( + unittest.TestCase +): + def test_gru_has_recurrent_parameters( + self, + ): + gru = ( + GRUOnlinePredictor( + seed=123, + ) + ) + + self.assertGreater( + gru.parameter_count, + 1000, + ) + + prediction = ( + gru.predict(1) + ) + + self.assertIn( + prediction, + (0, 1), + ) + + gru.learn(1) + + +class GuardTests( + unittest.TestCase +): + def test_heldout_blocked( + self, + ): + with self.assertRaises( + PermissionError + ): + run_world( + tasks()[0], + EVALUATION_SEEDS[0], + "GRU32", + ) + + +class SmokeTests( + unittest.TestCase +): + def test_gru_development_world_runs( + self, + ): + result = run_world( + tasks()[1], + 26000, + "GRU32", + ).payload + + self.assertEqual( + result["condition"], + "GRU32", + ) + + self.assertGreater( + result[ + "gru_parameter_count" + ], + 1000, + ) + + def test_prime_development_world_runs( + self, + ): + result = run_world( + tasks()[1], + 26000, + "PRIME", + ).payload + + self.assertEqual( + result["condition"], + "PRIME", + ) + + self.assertTrue( + result[ + "prime_receipts_valid" + ] + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_prime_v19_authority_adapter.py b/tests/test_prime_v19_authority_adapter.py new file mode 100644 index 0000000..da3f162 --- /dev/null +++ b/tests/test_prime_v19_authority_adapter.py @@ -0,0 +1,911 @@ +from __future__ import annotations + +from dataclasses import replace +import threading + +import pytest + +import BoggersTheAI.core.kernel.kernel as kernel_module +import BoggersTheAI.core.kernel.transaction as transaction_module +from BoggersTheAI.core.graph.universal_living_graph import UniversalLivingGraph +from BoggersTheAI.core.kernel import ( + AUTHORITY_MODE_PRIME_REQUIRED, + PrimeV19AuthorityAdapter, + ReentrantGraphTransactionError, + TSKernel, + validate_receipt_hash, +) +from BoggersTheAI.core.kernel.ir import stable_hash as boggers_stable_hash +from BoggersTheAI.core.kernel.replay import replay_receipt +from BoggersTheAI.core.kernel.transaction import graph_state_hash +from prime_v19 import ( + AuthorityKernel, + AuthorityPolicy, + AuthorityRequest, + ProposerSpec, + Scope, + VerifierFinding, + VerifierSpec, + stable_hash, +) + + +AUTHORITY_KEY = b"boggers-prime-authority-test-key-0001" +SAFETY_KEY = b"boggers-prime-safety-test-key-000001" +SEMANTIC_KEY = b"boggers-prime-semantic-test-key-0001" +ECONOMICS_KEY = b"boggers-prime-economics-test-key-001" +PROPOSER_KEY = b"boggers-prime-proposer-test-key-0001" +WRONG_PROPOSER_KEY = b"boggers-prime-wrong-proposer-key-001" + +VALID_SYLLOGISM = """All mammals are warm-blooded. +Whales are mammals. +Prove that whales are warm-blooded.""" + +REPRESENTATION_CHALLENGE = ( + 'Introduce stronger authoritative evidence that "whales" refers to ' + "mechanical devices named Whales, not biological animals." +) + + +def _safety_validator(context, evidence, config): + del config + if evidence.get("proposal_hash") != context.proposal.proposal_hash: + return VerifierFinding.fail("safety evidence is not proposal-bound") + return VerifierFinding.pass_("bounded adapter payload passed safety") + + +def _semantic_validator(context, evidence, config): + del config + operation = context.proposal.operations[0] + node_payload = operation.body["payload"] + intent = node_payload["mutation_intent"] + if evidence.get("proposal_hash") != context.proposal.proposal_hash: + return VerifierFinding.fail("semantic evidence is not proposal-bound") + if evidence.get("mutation_intent_hash") != context.proposal.mutation_intent_hash: + return VerifierFinding.fail("semantic evidence is not intent-bound") + if ( + node_payload.get("mutation_intent_hash") + != context.proposal.mutation_intent_hash + ): + return VerifierFinding.fail("proposal does not carry its exact mutation intent") + obligations = intent["verifier_obligations"] + results = intent["verification_results"] + if evidence.get("boggers_document_hash") != intent["document_hash"]: + return VerifierFinding.fail("document evidence hash mismatch") + if ( + evidence.get("prospective_graph_delta_hash") + != intent["prospective_graph_delta_hash"] + ): + return VerifierFinding.fail("prospective delta evidence hash mismatch") + if evidence.get("expected_post_state_hash") != intent["expected_post_state_hash"]: + return VerifierFinding.fail("expected post-state evidence hash mismatch") + result_outcomes = {} + for result in results: + result_outcomes.setdefault(result["obligation_id"], []).append( + result["outcome"] + ) + if any( + result_outcomes.get(obligation["id"]) != ["pass"] + for obligation in obligations + if obligation["required"] + ): + return VerifierFinding.fail("Boggers required obligations did not all pass") + return VerifierFinding.pass_("Boggers commit intent replayed") + + +def _rejecting_semantic_validator(context, evidence, config): + del context, evidence, config + return VerifierFinding.fail("forced domain rejection") + + +def _economics_validator(context, evidence, config): + del config + operation = context.proposal.operations[0] + if operation.body.get("kind") != "boggers_representation_commit": + return VerifierFinding.unsupported("no representation transition found") + if evidence.get("obligation_id") != "representation_economics": + return VerifierFinding.fail("economics evidence channel mismatch") + if evidence.get("proposal_hash") != context.proposal.proposal_hash: + return VerifierFinding.fail("economics evidence is not proposal-bound") + return VerifierFinding.pass_( + "bounded representation objective recomputed", + candidate_objective_bits=0, + incumbent_objective_bits=1, + ) + + +def _make_prime_kernel(*, semantic_validator=_semantic_validator, checkpoint=None): + both_scopes = ( + Scope.DETERMINISTIC_SEMANTIC_COMMIT, + Scope.REPRESENTATION_TRANSITION, + ) + specs = ( + VerifierSpec.create( + obligation_id="safety", + verifier_id="prime.safety", + verifier_version="1", + verifier_key_id="boggers-test-safety", + accepted_scopes=both_scopes, + alpha_cost=0, + resource_cost=1, + validator=_safety_validator, + signing_key=SAFETY_KEY, + ), + VerifierSpec.create( + obligation_id="semantic", + verifier_id="boggers.domain.semantic", + verifier_version="1", + verifier_key_id="boggers-test-semantic", + accepted_scopes=both_scopes, + alpha_cost=1, + resource_cost=2, + validator=semantic_validator, + signing_key=SEMANTIC_KEY, + ), + VerifierSpec.create( + obligation_id="representation_economics", + verifier_id="prime.representation.economics", + verifier_version="1", + verifier_key_id="boggers-test-economics", + accepted_scopes=(Scope.REPRESENTATION_TRANSITION,), + alpha_cost=1, + resource_cost=3, + validator=_economics_validator, + signing_key=ECONOMICS_KEY, + ), + ) + policy = AuthorityPolicy.create( + version="boggers-adapter-test-policy-v1", + mandatory_obligations=("safety",), + scope_obligations={ + Scope.DETERMINISTIC_SEMANTIC_COMMIT: (), + Scope.REPRESENTATION_TRANSITION: (), + }, + authority_class_obligations={ + "semantic": ("semantic",), + "representation": ("semantic", "representation_economics"), + }, + node_kind_authority_classes={ + "boggers_document_commit": "semantic", + "boggers_representation_commit": "representation", + }, + edge_kind_authority_classes={}, + initial_alpha=100, + initial_resources=100, + ) + proposer_specs = ( + ProposerSpec.create( + proposer_id="boggers.tskernel.commit-proposer", + proposer_key_id="boggers-test-proposer", + accepted_scopes=both_scopes, + signing_key=PROPOSER_KEY, + ), + ) + bootstrap = { + "proposer_specs": proposer_specs, + "verifier_specs": specs, + "policy": policy, + "authority_key_id": "boggers-test-authority", + "authority_signing_key": AUTHORITY_KEY, + } + if checkpoint is not None: + return AuthorityKernel.restore_checkpoint(checkpoint, **bootstrap) + return AuthorityKernel( + graph_lineage_id="boggers-adapter-test-lineage", + **bootstrap, + ) + + +def _make_boggers_kernel(prime_kernel, *, graph=None, parent_receipt_hash=None): + return TSKernel( + graph=graph or UniversalLivingGraph(auto_load=False), + parent_receipt_hash=parent_receipt_hash, + authority_mode=AUTHORITY_MODE_PRIME_REQUIRED, + prime_authority=PrimeV19AuthorityAdapter( + prime_kernel, + proposer_key_id="boggers-test-proposer", + proposer_signing_key=PROPOSER_KEY, + ), + ) + + +class _BlockingPrimeProxy: + def __init__(self, delegate): + self.delegate = delegate + self.first_authority_call = threading.Event() + self.release_first = threading.Event() + self._calls_lock = threading.Lock() + self.calls = 0 + + @property + def context(self): + return self.delegate.context + + @property + def snapshot(self): + return self.delegate.snapshot + + def authorize_and_commit(self, request): + with self._calls_lock: + self.calls += 1 + call_number = self.calls + if call_number == 1: + self.first_authority_call.set() + if not self.release_first.wait(timeout=5): + raise RuntimeError("test did not release the blocked PRIME call") + return self.delegate.authorize_and_commit(request) + + def verify_receipt(self, receipt): + return self.delegate.verify_receipt(receipt) + + def verify_live_state(self): + return self.delegate.verify_live_state() + + +class _ObservableRLock: + """RLock which records whether the direct-writer acquisition had to wait.""" + + def __init__(self): + self._delegate = threading.RLock() + self.direct_outcome = threading.Event() + self.direct_was_blocked: bool | None = None + + def acquire(self, *args, **kwargs): + if threading.current_thread().name == "direct-graph-writer": + acquired = self._delegate.acquire(blocking=False) + self.direct_was_blocked = not acquired + self.direct_outcome.set() + if acquired: + return True + return self._delegate.acquire(*args, **kwargs) + + def release(self): + self._delegate.release() + + def __enter__(self): + self.acquire() + return self + + def __exit__(self, exc_type, exc_value, traceback): + del exc_type, exc_value, traceback + self.release() + + +class _NamedAttemptRLock: + """RLock which exposes when one named thread reaches acquisition.""" + + def __init__(self, observed_thread_name): + self._delegate = threading.RLock() + self._observed_thread_name = observed_thread_name + self.observed_attempt = threading.Event() + + def acquire(self, *args, **kwargs): + if threading.current_thread().name == self._observed_thread_name: + self.observed_attempt.set() + return self._delegate.acquire(*args, **kwargs) + + def release(self): + self._delegate.release() + + def __enter__(self): + self.acquire() + return self + + def __exit__(self, exc_type, exc_value, traceback): + del exc_type, exc_value, traceback + self.release() + + +def test_legacy_mode_is_explicit_and_receipt_visible(): + kernel = TSKernel(graph=UniversalLivingGraph(auto_load=False)) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "commit" + assert result.receipt.authority_mode == "legacy_local" + assert result.receipt.prime_authority_receipt == {} + + +def test_prime_required_without_adapter_fails_closed_before_commit(): + graph = UniversalLivingGraph(auto_load=False) + kernel = TSKernel( + graph=graph, + authority_mode=AUTHORITY_MODE_PRIME_REQUIRED, + ) + before = graph_state_hash(graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "abstain" + assert graph_state_hash(graph) == before + assert result.receipt.committed_graph_delta == {"nodes": [], "edges": []} + assert result.receipt.authority_mode == "prime_required" + assert result.receipt.prime_authority_receipt["authorized"] is False + assert result.receipt.prime_authority_receipt["reason_codes"] == [ + "prime_authority_unavailable" + ] + + +def test_prime_authorize_receipt_binds_exact_pending_commit_then_local_commit_runs(): + prime_kernel = _make_prime_kernel() + kernel = _make_boggers_kernel(prime_kernel) + before = graph_state_hash(kernel.graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "commit" + assert graph_state_hash(kernel.graph) != before + admission = result.receipt.prime_authority_receipt + assert admission["authorized"] is True + assert admission["decision"] == "AUTHORIZE" + prime_receipt = admission["receipt"] + proposal = prime_receipt["proposal"] + operation_payload = proposal["operations"][0]["body"]["payload"] + intent = operation_payload["mutation_intent"] + assert intent["boggers_base_graph_hash"] == before + assert intent["document_hash"] == proposal["metadata"]["boggers_document_hash"] + assert intent["prospective_graph_delta"] == ( + PrimeV19AuthorityAdapter._prime_canonical_value( + result.receipt.committed_graph_delta + ) + ) + assert intent["prospective_graph_delta_hash"] == boggers_stable_hash( + result.receipt.committed_graph_delta + ) + assert intent["expected_post_state_hash"] == result.receipt.post_state_hash + assert ( + proposal["metadata"]["prospective_graph_delta_hash"] + == intent["prospective_graph_delta_hash"] + ) + assert proposal["metadata"]["expected_post_state_hash"] == ( + result.receipt.post_state_hash + ) + assert stable_hash(intent) == proposal["mutation_intent_hash"] + assert admission["mutation_intent_hash"] == proposal["mutation_intent_hash"] + assert prime_receipt["previous_root"] == proposal["parent_root"] + assert prime_receipt["new_root"] == prime_kernel.snapshot.root + assert prime_kernel.verify_receipt(prime_kernel.ledger[-1]) + assert prime_kernel.verify_live_state() + + +def test_prime_authorizes_verified_syllogism_and_bogvm_commit_artifacts(): + prime_kernel = _make_prime_kernel() + kernel = _make_boggers_kernel(prime_kernel) + + result = kernel.transact(VALID_SYLLOGISM) + + assert result.decision.value == "commit" + assert result.receipt.derived_claims + assert result.receipt.BOGVM_artifacts + assert result.receipt.BOGVM_artifacts[0]["proof_obligation_satisfied"] is True + assert result.receipt.BOGVM_artifacts[0]["state_commit_authorized"] is True + assert validate_receipt_hash(result.receipt) + replay_graph = UniversalLivingGraph(auto_load=False) + assert ( + replay_receipt(replay_graph, result.receipt) == result.receipt.post_state_hash + ) + admission = result.receipt.prime_authority_receipt + assert admission["authorized"] is True + intent = admission["receipt"]["proposal"]["operations"][0]["body"]["payload"][ + "mutation_intent" + ] + required = { + item["id"] for item in intent["verifier_obligations"] if item["required"] + } + passed = { + item["obligation_id"] + for item in intent["verification_results"] + if item["outcome"] == "pass" + } + assert required <= passed + + +def test_restored_prime_checkpoint_continues_with_contextual_receipt_verification(): + prime_kernel = _make_prime_kernel() + kernel = _make_boggers_kernel(prime_kernel) + first = kernel.transact("All mammals are warm-blooded.") + restored = _make_prime_kernel(checkpoint=prime_kernel.export_checkpoint()) + continued_kernel = _make_boggers_kernel( + restored, + graph=kernel.graph, + parent_receipt_hash=first.receipt.receipt_hash, + ) + + continued = continued_kernel.transact("All birds are feathered.") + + assert continued.decision.value == "commit" + prime_receipt = restored.ledger[-1] + assert prime_receipt.sequence == 2 + assert restored.verify_receipt(prime_receipt) + assert restored.verify_live_state() + assert continued.receipt.prime_authority_receipt["authorized"] is True + + +def test_representation_transition_uses_protected_kind_and_economics_evidence(): + prime_kernel = _make_prime_kernel() + kernel = _make_boggers_kernel(prime_kernel) + kernel.transact("All mammals are warm-blooded.\nWhales are mammals.") + + result = kernel.transact(REPRESENTATION_CHALLENGE) + + assert result.decision.value == "branch" + assert kernel.graph.get_node("entity:individual:whale_mechanical_device_branch") + admission = result.receipt.prime_authority_receipt + assert admission["authorized"] is True + prime_receipt = admission["receipt"] + proposal = prime_receipt["proposal"] + assert proposal["scope"] == "representation_transition" + assert proposal["operations"][0]["body"]["kind"] == ( + "boggers_representation_commit" + ) + assert {item["obligation_id"] for item in prime_receipt["evidence"]} == { + "safety", + "semantic", + "representation_economics", + } + assert {item["obligation_id"] for item in prime_receipt["verifier_receipts"]} == { + "safety", + "semantic", + "representation_economics", + } + + +def test_representation_scope_cannot_authorize_without_economics_evidence(): + delegate = _make_prime_kernel() + + class EconomicsDroppingProxy: + @property + def context(self): + return delegate.context + + @property + def snapshot(self): + return delegate.snapshot + + def authorize_and_commit(self, request): + if request.proposal.scope.value == "representation_transition": + request = AuthorityRequest.create( + request.proposal, + tuple( + item + for item in request.evidence + if item.obligation_id != "representation_economics" + ), + ) + return delegate.authorize_and_commit(request) + + def verify_receipt(self, receipt): + return delegate.verify_receipt(receipt) + + def verify_live_state(self): + return delegate.verify_live_state() + + kernel = _make_boggers_kernel(EconomicsDroppingProxy()) + kernel.transact("All mammals are warm-blooded.\nWhales are mammals.") + before = graph_state_hash(kernel.graph) + + result = kernel.transact(REPRESENTATION_CHALLENGE) + + assert result.decision.value == "reject" + assert graph_state_hash(kernel.graph) == before + assert not kernel.graph.get_node("entity:individual:whale_mechanical_device_branch") + admission = result.receipt.prime_authority_receipt + assert admission["authorized"] is False + assert "evidence_coverage_mismatch" in admission["reason_codes"] + assert "adapter_binding_verification_failed" in admission["reason_codes"] + + +def test_prime_rejection_has_zero_boggers_graph_effect(): + prime_kernel = _make_prime_kernel(semantic_validator=_rejecting_semantic_validator) + kernel = _make_boggers_kernel(prime_kernel) + before = graph_state_hash(kernel.graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "reject" + assert graph_state_hash(kernel.graph) == before + assert result.receipt.committed_graph_delta == {"nodes": [], "edges": []} + assert result.receipt.prime_authority_receipt["authorized"] is False + assert result.receipt.prime_authority_receipt["decision"] == "REJECT" + + +def test_wrong_proposer_key_has_zero_boggers_graph_effect(): + prime_kernel = _make_prime_kernel() + graph = UniversalLivingGraph(auto_load=False) + kernel = TSKernel( + graph=graph, + authority_mode=AUTHORITY_MODE_PRIME_REQUIRED, + prime_authority=PrimeV19AuthorityAdapter( + prime_kernel, + proposer_key_id="boggers-test-proposer", + proposer_signing_key=WRONG_PROPOSER_KEY, + ), + ) + before = graph_state_hash(graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "reject" + assert graph_state_hash(graph) == before + assert ( + "proposer_signature_mismatch" + in (result.receipt.prime_authority_receipt["reason_codes"]) + ) + + +def test_tampered_prime_receipt_has_zero_boggers_graph_effect(): + delegate = _make_prime_kernel() + + class TamperingProxy: + @property + def context(self): + return delegate.context + + @property + def snapshot(self): + return delegate.snapshot + + def authorize_and_commit(self, request): + receipt = delegate.authorize_and_commit(request) + return replace(receipt, authority_mac="0" * 64) + + def verify_receipt(self, receipt): + return delegate.verify_receipt(receipt) + + def verify_live_state(self): + return delegate.verify_live_state() + + kernel = _make_boggers_kernel(TamperingProxy()) + before = graph_state_hash(kernel.graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "abstain" + assert graph_state_hash(kernel.graph) == before + assert ( + "prime_receipt_verification_failed" + in (result.receipt.prime_authority_receipt["reason_codes"]) + ) + + +def test_prime_runtime_error_has_zero_boggers_graph_effect(): + delegate = _make_prime_kernel() + + class ExplodingProxy: + @property + def context(self): + return delegate.context + + def authorize_and_commit(self, request): + del request + raise RuntimeError("authority process disappeared") + + kernel = _make_boggers_kernel(ExplodingProxy()) + before = graph_state_hash(kernel.graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "abstain" + assert graph_state_hash(kernel.graph) == before + assert result.receipt.prime_authority_receipt["reason_codes"] == [ + "prime_authority_unavailable" + ] + + +def test_stale_prime_request_has_zero_boggers_graph_effect(): + delegate = _make_prime_kernel() + + class StaleProxy: + @property + def context(self): + return delegate.context + + @property + def snapshot(self): + return delegate.snapshot + + def authorize_and_commit(self, request): + delegate.authorize_and_commit(request) + return delegate.authorize_and_commit(request) + + def verify_receipt(self, receipt): + return delegate.verify_receipt(receipt) + + def verify_live_state(self): + return delegate.verify_live_state() + + kernel = _make_boggers_kernel(StaleProxy()) + before = graph_state_hash(kernel.graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "reject" + assert graph_state_hash(kernel.graph) == before + reasons = result.receipt.prime_authority_receipt["reason_codes"] + assert any(reason.startswith("stale_") for reason in reasons) + assert "adapter_binding_verification_failed" in reasons + + +def test_configured_prime_cannot_silently_fall_back_to_legacy_mode(): + adapter = PrimeV19AuthorityAdapter( + _make_prime_kernel(), + proposer_key_id="boggers-test-proposer", + proposer_signing_key=PROPOSER_KEY, + ) + + with pytest.raises(ValueError, match="requires authority_mode='prime_required'"): + TSKernel( + graph=UniversalLivingGraph(auto_load=False), + prime_authority=adapter, + ) + + +def test_adapter_rejects_low_diversity_proposer_key_at_construction(): + with pytest.raises(ValueError, match="8 distinct byte values"): + PrimeV19AuthorityAdapter( + _make_prime_kernel(), + proposer_key_id="boggers-test-proposer", + proposer_signing_key=b"x" * 32, + ) + + +def test_prime_canonicalization_rejects_non_string_object_keys(): + with pytest.raises(TypeError, match="object keys must be strings"): + PrimeV19AuthorityAdapter._prime_canonical_value({1: "collision"}) + + +def test_adapter_projection_swap_is_rejected_before_boggers_commit(): + prime_kernel = _make_prime_kernel() + + class ProjectionSwappingAdapter(PrimeV19AuthorityAdapter): + def authorize_document_commit(self, **kwargs): + forged_delta = {"nodes": [], "edges": []} + kwargs["prospective_graph_delta"] = forged_delta + kwargs["prospective_graph_delta_hash"] = boggers_stable_hash(forged_delta) + kwargs["expected_post_state_hash"] = kwargs["base_graph_hash"] + return super().authorize_document_commit(**kwargs) + + graph = UniversalLivingGraph(auto_load=False) + kernel = TSKernel( + graph=graph, + authority_mode=AUTHORITY_MODE_PRIME_REQUIRED, + prime_authority=ProjectionSwappingAdapter( + prime_kernel, + proposer_key_id="boggers-test-proposer", + proposer_signing_key=PROPOSER_KEY, + ), + ) + before = graph_state_hash(graph) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "abstain" + assert graph_state_hash(graph) == before + assert result.receipt.committed_graph_delta == {"nodes": [], "edges": []} + admission = result.receipt.prime_authority_receipt + assert admission["authorized"] is False + assert admission["receipt"]["decision"] == "AUTHORIZE" + assert "boggers_projection_binding_failed" in admission["reason_codes"] + + +def test_live_commit_post_state_mismatch_rolls_back_and_fails_closed(monkeypatch): + prime_kernel = _make_prime_kernel() + graph = UniversalLivingGraph(auto_load=False) + kernel = _make_boggers_kernel(prime_kernel, graph=graph) + before = graph_state_hash(graph) + original_commit = kernel_module.commit_document + + def commit_with_unprojected_mutation(*args, **kwargs): + delta = original_commit(*args, **kwargs) + args[0].add_node( + node_id="tampered:unprojected", + content="not authorized by PRIME", + ) + return delta + + monkeypatch.setattr( + kernel_module, "commit_document", commit_with_unprojected_mutation + ) + + result = kernel.transact("All humans are refrigerators.") + + assert result.decision.value == "abstain" + assert graph_state_hash(graph) == before + assert graph.get_node("tampered:unprojected") is None + assert result.receipt.committed_graph_delta == {"nodes": [], "edges": []} + admission = result.receipt.prime_authority_receipt + assert admission["authorized"] is False + assert admission["receipt"]["decision"] == "AUTHORIZE" + assert "boggers_post_commit_verification_failed" in admission["reason_codes"] + + +def test_shared_graph_transactions_serialize_before_prime_authorization(monkeypatch): + graph = UniversalLivingGraph(auto_load=False) + proxy = _BlockingPrimeProxy(_make_prime_kernel()) + first_kernel = _make_boggers_kernel(proxy, graph=graph) + second_kernel = _make_boggers_kernel(proxy, graph=graph) + original_guard_lookup = transaction_module._graph_transaction_guard + guards = {} + second_guard_found = threading.Event() + + def tracking_guard_lookup(target_graph): + guard = original_guard_lookup(target_graph) + guards[threading.current_thread().name] = guard + if threading.current_thread().name == "boggers-second": + second_guard_found.set() + return guard + + monkeypatch.setattr( + transaction_module, + "_graph_transaction_guard", + tracking_guard_lookup, + ) + results = {} + errors = [] + + def run_transaction(name, kernel, text): + try: + results[name] = kernel.transact(text) + except BaseException as exc: # pragma: no cover - surfaced below + errors.append(exc) + + first_thread = threading.Thread( + target=run_transaction, + args=("first", first_kernel, "All mammals are warm-blooded."), + name="boggers-first", + ) + second_thread = threading.Thread( + target=run_transaction, + args=("second", second_kernel, "All birds are feathered."), + name="boggers-second", + ) + first_thread.start() + assert proxy.first_authority_call.wait(timeout=5) + second_thread.start() + assert second_guard_found.wait(timeout=5) + assert guards["boggers-first"] is guards["boggers-second"] + assert proxy.calls == 1 + + proxy.release_first.set() + first_thread.join(timeout=5) + second_thread.join(timeout=5) + + assert not first_thread.is_alive() + assert not second_thread.is_alive() + assert not errors + assert results["first"].decision.value == "commit" + assert results["second"].decision.value == "commit" + assert results["second"].receipt.base_graph_hash == ( + results["first"].receipt.post_state_hash + ) + for result in results.values(): + for node in result.receipt.committed_graph_delta["nodes"]: + assert graph.get_node(node["id"]) is not None + + +def test_reentrant_transaction_on_shared_graph_fails_immediately(): + graph = UniversalLivingGraph(auto_load=False) + kernel = TSKernel(graph=graph) + before = graph_state_hash(graph) + + class ReenteringCommitPolicy: + def verify(self, obligation, workspace): + del obligation, workspace + kernel.transact("All birds are feathered.") + raise AssertionError("nested transaction unexpectedly returned") + + kernel.commit_policy = ReenteringCommitPolicy() + + with pytest.raises(ReentrantGraphTransactionError, match="cannot re-enter"): + kernel.transact("All mammals are warm-blooded.") + + assert graph_state_hash(graph) == before + assert kernel.receipts == [] + + +def test_direct_graph_mutation_waits_for_entire_kernel_transaction(): + graph = UniversalLivingGraph(auto_load=False) + observable_lock = _ObservableRLock() + graph._lock = observable_lock + proxy = _BlockingPrimeProxy(_make_prime_kernel()) + kernel = _make_boggers_kernel(proxy, graph=graph) + results = [] + errors = [] + + def run_kernel_transaction(): + try: + results.append(kernel.transact("All mammals are warm-blooded.")) + except BaseException as exc: # pragma: no cover - surfaced below + errors.append(exc) + + def mutate_graph_directly(): + try: + graph.add_node( + node_id="direct:after-transaction", + content="direct graph mutation", + ) + except BaseException as exc: # pragma: no cover - surfaced below + errors.append(exc) + + transaction_thread = threading.Thread( + target=run_kernel_transaction, + name="kernel-transaction", + ) + direct_thread = threading.Thread( + target=mutate_graph_directly, + name="direct-graph-writer", + ) + transaction_thread.start() + assert proxy.first_authority_call.wait(timeout=5) + direct_thread.start() + assert observable_lock.direct_outcome.wait(timeout=5) + assert observable_lock.direct_was_blocked is True + assert graph.get_node("direct:after-transaction") is None + + proxy.release_first.set() + transaction_thread.join(timeout=5) + direct_thread.join(timeout=5) + + assert not transaction_thread.is_alive() + assert not direct_thread.is_alive() + assert not errors + assert results[0].decision.value == "commit" + assert graph.get_node("direct:after-transaction") is not None + + +def test_graph_native_lock_precedes_process_guard_to_avoid_lock_inversion(): + graph = UniversalLivingGraph(auto_load=False) + graph_lock = _NamedAttemptRLock("competing-kernel") + graph._lock = graph_lock + holder_kernel = TSKernel(graph=graph) + competitor_kernel = TSKernel(graph=graph) + holder_has_lock = threading.Event() + holder_may_transact = threading.Event() + holder_done = threading.Event() + competitor_done = threading.Event() + errors = [] + + def hold_native_lock_then_transact(): + try: + with graph._lock: + holder_has_lock.set() + if not holder_may_transact.wait(timeout=5): + raise RuntimeError("test did not release the native-lock holder") + holder_kernel.transact("All mammals are warm-blooded.") + except BaseException as exc: # pragma: no cover - surfaced below + errors.append(exc) + finally: + holder_done.set() + + def transact_while_native_lock_is_held(): + try: + competitor_kernel.transact("All birds are feathered.") + except BaseException as exc: # pragma: no cover - surfaced below + errors.append(exc) + finally: + competitor_done.set() + + holder = threading.Thread( + target=hold_native_lock_then_transact, + name="native-lock-holder", + daemon=True, + ) + competitor = threading.Thread( + target=transact_while_native_lock_is_held, + name="competing-kernel", + daemon=True, + ) + holder.start() + assert holder_has_lock.wait(timeout=5) + competitor.start() + assert graph_lock.observed_attempt.wait(timeout=5) + holder_may_transact.set() + + assert holder_done.wait(timeout=5), "graph/process lock-order inversion deadlocked" + assert competitor_done.wait(timeout=5) + holder.join(timeout=1) + competitor.join(timeout=1) + + assert not errors + assert len(holder_kernel.receipts) == 1 + assert len(competitor_kernel.receipts) == 1 diff --git a/tests/test_problem_analysis_workflow.py b/tests/test_problem_analysis_workflow.py new file mode 100644 index 0000000..2ddd4cb --- /dev/null +++ b/tests/test_problem_analysis_workflow.py @@ -0,0 +1,856 @@ +from __future__ import annotations + +from copy import deepcopy +import os +from pathlib import Path +import threading + +import pytest + +from BoggersTheAI.reasoner.ts_reasoner.problem_workflow import ( + ProblemAnalysisWorkflow, + ProblemSpec, + ProblemSpecError, + WorkflowAuthorityKeys, + WorkflowBuildError, + WorkflowCanonicalizationError, + WorkflowState, + build_problem_workflow_kernel, + canonicalize_source, + contains_native_float, + workflow_stable_hash, +) +from BoggersTheAI.reasoner.ts_reasoner.problem_workflow.validators import ( + expected_mutation_intent, + expected_node_payload, + expected_proposal_metadata, +) +from prime_v19 import ( + AuthorityKernel, + AuthorityRequest, + Decision, + EvidenceEnvelope, + GraphNode, + GraphPatchProposal, + PatchOperation, + Scope, + V18ArchiveReceipt, + V18MountReceipt, + V18ProposalBatch, + V18StructuralProposal, + mount_v18_proposer, + stable_hash, +) + + +V18_ARCHIVE = "e8fed342857776a90ec75f1e86bec216374a08be0d9c9eb25d83958088498005" +V18_MANIFEST = "aa0b131b9b961805937d9c2686d721511e3f74612907daa3cc9ef512a95774cd" +V18_SEALED = "268ca140d5ff26f4c1da4177d422d59c93d7caa184af4d869911cea966da4ae8" +V18_FREEZE = "7d4531ab3664c0bb20270e5927a6b53f47a70603b45431facfe9ec9aba0b1e3d" +V18_PARENT_FIELD = "d3a72d0fd5c11e9a50e19e45aff1535e4e9064de6200cb6200408a7626bcb2ea" +V18_MODEL = "c6e6daf0b26ea873c7561020f36bb05f26c3adcc6e3106dcab10d17524604845" +V18_NUMPY_ARCHIVE = "8cd72ef4d3ab7f152bb477f7d0a00d3989e3cfc577f10db1ed23acc277228889" +V18_TENSOR = "b6eaad261abbb644c4f1113153d6b9657875fe37d89168cba1f76ff3a07bc99f" + + +def _key(label: str) -> bytes: + return f"{label}-0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ".encode() + + +KEYS = WorkflowAuthorityKeys( + authority_key_id="problem-test-authority", + authority_signing_key=_key("authority"), + proposer_key_id="problem-test-proposer", + proposer_signing_key=_key("proposer"), + workflow_verifier_key_id="problem-test-workflow", + workflow_verifier_signing_key=_key("workflow"), + field_verifier_key_id="problem-test-field", + field_verifier_signing_key=_key("field"), + provenance_verifier_key_id="problem-test-provenance", + provenance_verifier_signing_key=_key("provenance"), + economics_verifier_key_id="problem-test-economics", + economics_verifier_signing_key=_key("economics"), +) + + +def _kernel(lineage: str = "problem-test-lineage", *, checkpoint=None): + return build_problem_workflow_kernel( + graph_lineage_id=lineage, + keys=KEYS, + checkpoint=checkpoint, + ) + + +def _workflow(kernel): + return ProblemAnalysisWorkflow( + kernel, + proposer_key_id=KEYS.proposer_key_id, + proposer_signing_key=KEYS.proposer_signing_key, + ) + + +def _receipt_advice(receipt): + envelope = next( + item + for item in receipt.evidence + if item.obligation_id == "provenance_binding_v1" + ) + return envelope.payload["advice"] + + +def _spec(problem_id: str = "bounded_problem", *, marker: str = "base"): + return ProblemSpec.create( + problem_id=problem_id, + question=f"How should the {marker} constraint system evolve?", + context=(f"Context {marker}",), + constraints=("Preserve the authority boundary",), + desired_outcomes=("Produce one auditable analysis",), + failure_modes=("Proposal evidence becomes authority",), + testable_predictions=("Exactly one analysis node is admitted",), + scope="Repository-local deterministic behavior only", + provenance={"source": "focused-test", "weight": 0.5}, + ) + + +class _SealedV18Stub: + def __init__(self, *, barrier: threading.Barrier | None = None, corrupt=None): + self._barrier = barrier + self._corrupt = corrupt + + def describe(self): + receipt = { + "schema": "prime-v19-v18-mount-receipt-v1", + "status": "MOUNTED_EXACT_READ_ONLY", + "archive": { + "schema": "prime-v19-v18-archive-receipt-v1", + "status": "VERIFIED_EXACT_SEALED_PARENT", + "archive_name": "prime-v18-v1.0.0.zip", + "archive_sha256": V18_ARCHIVE, + "archive_bytes": 17_394_063, + "archive_root": "prime-v18-v1.0.0", + "manifest_sha256": V18_MANIFEST, + "manifest_files": 148, + "zip_entries": 149, + "expanded_bytes": 34_158_295, + "sealed_release_sha256": V18_SEALED, + "scientific_freeze_sha256": V18_FREEZE, + "public_version": "1.0.0", + "semantic_authority": "NONE", + }, + "cache_hit": True, + "semantic_authority": "NONE", + } + if self._corrupt == "archive": + receipt["archive"]["archive_sha256"] = "0" * 64 + return receipt + + def propose_structural_features(self, text: str, *, top_k: int = 5): + if self._barrier is not None: + self._barrier.wait(timeout=5) + request = { + "schema": "prime-v19-v18-worker-request-v1", + "archive_sha256": V18_ARCHIVE, + "operation": "structural_proposals", + "payload": {"text": text, "top_k": top_k}, + } + body = { + "schema": "prime-v19-v18-structural-proposals-v1", + "status": "PROVISIONAL_NON_AUTHORITATIVE", + "semantic_authority": "NONE", + "semantic_promotions": 0, + "request_hash": workflow_stable_hash(request), + "source": { + "archive_sha256": V18_ARCHIVE, + "manifest_sha256": V18_MANIFEST, + "model_sha256": V18_MODEL, + "numpy_archive_sha256": V18_NUMPY_ARCHIVE, + "parent_field_archive_sha256": V18_PARENT_FIELD, + "tensor_sha256": V18_TENSOR, + }, + "runtime": {"numpy_version": "test", "python_version": "test"}, + "observed_features": ["constraint", "failure"], + "proposals": [ + { + "feature": f"sealed-feature-{rank}", + "rank": rank, + "status": "PROVISIONAL_NON_AUTHORITATIVE", + } + for rank in range(1, top_k + 1) + ], + } + if self._corrupt == "promotion_bool": + body["semantic_promotions"] = False + if self._corrupt == "rank_bool": + body["proposals"][0]["rank"] = True + if self._corrupt == "model": + body["source"]["model_sha256"] = "0" * 64 + if self._corrupt == "numpy_archive": + body["source"]["numpy_archive_sha256"] = "0" * 64 + if self._corrupt == "request": + body["request_hash"] = "0" * 64 + return {**body, "result_hash": workflow_stable_hash(body)} + + +class _TypedSealedV18Client: + """Exact typed surface returned by prime_v19.mount_v18_proposer.""" + + def describe(self): + archive = V18ArchiveReceipt( + archive_name="prime-v18-v1.0.0.zip", + archive_sha256=V18_ARCHIVE, + archive_bytes=17_394_063, + archive_root="prime-v18-v1.0.0", + manifest_sha256=V18_MANIFEST, + manifest_files=148, + zip_entries=149, + expanded_bytes=34_158_295, + sealed_release_sha256=V18_SEALED, + scientific_freeze_sha256=V18_FREEZE, + public_version="1.0.0", + ) + return V18MountReceipt(archive=archive, cache_hit=True) + + def propose_structural_features(self, text: str, *, top_k: int = 5): + request = { + "schema": "prime-v19-v18-worker-request-v1", + "archive_sha256": V18_ARCHIVE, + "operation": "structural_proposals", + "payload": {"text": text, "top_k": top_k}, + } + proposals = tuple( + V18StructuralProposal(feature=f"typed-feature-{rank}", rank=rank) + for rank in range(1, top_k + 1) + ) + body = { + "schema": "prime-v19-v18-structural-proposals-v1", + "status": "PROVISIONAL_NON_AUTHORITATIVE", + "semantic_authority": "NONE", + "semantic_promotions": 0, + "request_hash": workflow_stable_hash(request), + "source": { + "archive_sha256": V18_ARCHIVE, + "manifest_sha256": V18_MANIFEST, + "model_sha256": V18_MODEL, + "numpy_archive_sha256": V18_NUMPY_ARCHIVE, + "parent_field_archive_sha256": V18_PARENT_FIELD, + "tensor_sha256": V18_TENSOR, + }, + "runtime": {"numpy_version": "typed", "python_version": "typed"}, + "observed_features": ["constraint", "failure"], + "proposals": [proposal.to_dict() for proposal in proposals], + } + return V18ProposalBatch( + request_hash=body["request_hash"], + result_hash=workflow_stable_hash(body), + archive_sha256=V18_ARCHIVE, + manifest_sha256=V18_MANIFEST, + tensor_sha256=V18_TENSOR, + parent_field_archive_sha256=V18_PARENT_FIELD, + model_sha256=V18_MODEL, + numpy_archive_sha256=V18_NUMPY_ARCHIVE, + python_version="typed", + numpy_version="typed", + observed_features=("constraint", "failure"), + proposals=proposals, + ) + + +def _signed_proposal( + prepared, + kernel, + *, + operation, + affected_nodes=None, + scope=Scope.DETERMINISTIC_SEMANTIC_COMMIT, + current_parent: bool = False, + mutation_intent_hash=None, + metadata=None, +): + base = prepared.request.proposal + context = kernel.context if current_parent else None + return GraphPatchProposal.create( + graph_lineage_id=base.graph_lineage_id, + scope=scope, + proposer_id=base.proposer_id, + proposer_key_id=base.proposer_key_id, + proposer_signing_key=KEYS.proposer_signing_key, + parent_root=context.current_root if context else base.parent_root, + parent_authority_hash=( + context.parent_authority_hash if context else base.parent_authority_hash + ), + expected_sequence=( + context.next_sequence if context else base.expected_sequence + ), + mutation_intent_hash=mutation_intent_hash or base.mutation_intent_hash, + provenance_hash=base.provenance_hash, + affected_nodes=affected_nodes or base.affected_nodes, + operations=(operation,), + metadata=metadata or base.metadata, + ) + + +def _rebound_request(prepared, proposal, *, parent_binding=None, mutate=None): + evidence = [] + for envelope in prepared.request.evidence: + payload = deepcopy(envelope.payload) + payload["proposal_hash"] = proposal.proposal_hash + if parent_binding is not None: + payload["parent_binding"] = deepcopy(parent_binding) + if mutate is not None: + mutate(envelope.obligation_id, payload) + evidence.append(EvidenceEnvelope.create(envelope.obligation_id, payload)) + return AuthorityRequest.create(proposal, evidence) + + +def test_happy_path_commits_exactly_one_prime_node_and_verifies_receipt(): + kernel = _kernel() + outcome = _workflow(kernel).analyze( + _spec(), advice=_SealedV18Stub(), advice_top_k=3 + ) + + assert outcome.state is WorkflowState.COMMITTED + assert [state.value for state in outcome.trace] == [ + "READY", + "BOUND", + "FIELD_READY", + "FOCUSED", + "PROPOSED", + "ROUTED", + "REQUEST_READY", + "SUBMITTED", + "COMMITTED", + ] + assert outcome.receipt_verified and outcome.live_state_verified + assert kernel.verify_receipt(outcome.receipt) + assert kernel.verify_live_state() + assert len(kernel.snapshot.nodes) == 1 + assert len(kernel.snapshot.edges) == 0 + node = kernel.snapshot.nodes[0] + assert node.kind == "ts.problem_analysis" + assert node.node_id == f"ts.problem_analysis:{outcome.problem_spec_hash}" + assert node.payload["semantics"] == "DETERMINISTIC_ANALYSIS_NOT_WORLD_TRUTH" + assert node.payload["analysis"]["advice_boundary"]["semantic_use"] == ( + "RECEIPT_EVIDENCE_ONLY" + ) + assert "proposal_batch" not in node.payload + assert not contains_native_float(outcome.receipt.to_dict()) + + +def test_request_and_constraint_projection_are_deterministic_and_deep_detached(): + first = _workflow(_kernel("determinism-lineage")).prepare_request(_spec()) + second = _workflow(_kernel("determinism-lineage")).prepare_request(_spec()) + + assert first.request.signing_payload() == second.request.signing_payload() + assert first.request.request_hash == second.request.request_hash + detached = first.node_payload + detached["analysis"]["focus"]["active_frontier"].append("forged") + assert "forged" not in first.node_payload["analysis"]["focus"]["active_frontier"] + assert ( + "forged" + not in first.request.proposal.operations[0].body["payload"]["analysis"][ + "focus" + ]["active_frontier"] + ) + + +def test_serialized_problem_spec_round_trips_and_can_be_analyzed(): + serialized = _spec(problem_id="serialized_spec").to_dict() + + assert ProblemSpec.from_value(serialized).to_dict() == serialized + outcome = _workflow(_kernel("serialized-spec-lineage")).analyze(serialized) + assert outcome.state is WorkflowState.COMMITTED + + serialized["schema"] = "unknown-spec-schema" + with pytest.raises(ProblemSpecError, match="schema"): + ProblemSpec.from_value(serialized) + + +def test_workflow_hash_is_exactly_prime_hash_for_unicode_and_tagged_floats(): + payloads = ( + {"z": "fish", "a": [1, True, None]}, + {"unicode": "café Ω", "float": {"$ts_float_hex": "0x1.0000000000000p-2"}}, + {"escaped": 'line\n"quoted"\\tail'}, + ) + assert all( + workflow_stable_hash(payload) == stable_hash(payload) for payload in payloads + ) + + +def test_invalid_spec_and_ambiguous_numbers_create_no_request_or_effect(): + kernel = _kernel() + root = kernel.snapshot.root + invalid = _spec().to_dict() + invalid["constraints"] = [] + + outcome = _workflow(kernel).analyze(invalid) + assert outcome.state is WorkflowState.ABSTAINED + assert not outcome.request_created + assert kernel.snapshot.root == root + assert not kernel.ledger + + with pytest.raises(ProblemSpecError): + ProblemSpec.create( + problem_id="bad", + question="Q", + constraints=("C",), + desired_outcomes=("D",), + failure_modes=("F",), + testable_predictions=("T",), + scope="S", + provenance={"score": float("inf")}, + ) + with pytest.raises(ProblemSpecError): + ProblemSpec.create( + problem_id="bad", + question="Q", + constraints=("C",), + desired_outcomes=("D",), + failure_modes=("F",), + testable_predictions=("T",), + scope="S", + provenance={"$ts_float_hex": "0x1.0p+0"}, + ) + with pytest.raises(WorkflowCanonicalizationError): + canonicalize_source({1: "non-string key"}) + + +@pytest.mark.parametrize( + "corrupt", + [ + "archive", + "promotion_bool", + "rank_bool", + "model", + "numpy_archive", + "request", + ], +) +def test_forged_or_boolean_v18_attribution_is_ablated_not_promoted(corrupt): + kernel = _kernel(f"advice-{corrupt}") + outcome = _workflow(kernel).analyze( + _spec(problem_id=f"advice_{corrupt}"), + advice=_SealedV18Stub(corrupt=corrupt), + advice_top_k=1, + ) + + assert outcome.state is WorkflowState.COMMITTED + advice = _receipt_advice(outcome.receipt) + assert advice["mode"] == "UNAVAILABLE" + assert advice["semantic_promotions"] == 0 + + +def test_actual_prime_v18_typed_proposal_client_shape_is_accepted(): + kernel = _kernel("typed-v18-client") + outcome = _workflow(kernel).analyze( + _spec(problem_id="typed_v18_client"), + advice=_TypedSealedV18Client(), + advice_top_k=2, + ) + + assert outcome.state is WorkflowState.COMMITTED + advice = _receipt_advice(outcome.receipt) + assert advice["mode"] == "PRESENT" + assert advice["semantic_promotions"] == 0 + + +def test_exact_sealed_v18_archive_is_proposal_only_and_canonically_inert(tmp_path): + archive_path = os.environ.get("PRIME_V18_ARCHIVE") + if archive_path is None: + pytest.skip("set PRIME_V18_ARCHIVE to run the exact sealed-v18 integration") + proposer = mount_v18_proposer( + archive_path, + cache_dir=tmp_path / "prime-v18-cache", + ) + advised_kernel = _kernel("real-v18-integration-lineage") + ablated_kernel = _kernel("real-v18-integration-lineage") + spec = _spec(problem_id="real_v18_integration") + + advised = _workflow(advised_kernel).analyze( + spec, + advice=proposer, + advice_top_k=2, + ) + ablated = _workflow(ablated_kernel).analyze(spec) + + assert advised.state is WorkflowState.COMMITTED + assert ablated.state is WorkflowState.COMMITTED + advice = _receipt_advice(advised.receipt) + assert advice["mode"] == "PRESENT" + assert advice["semantic_promotions"] == 0 + assert advice["description"]["archive"]["archive_sha256"] == V18_ARCHIVE + assert advice["proposal_batch"]["source"]["model_sha256"] == V18_MODEL + assert advice["proposal_batch"]["source"]["numpy_archive_sha256"] == ( + V18_NUMPY_ARCHIVE + ) + assert advised_kernel.snapshot.nodes == ablated_kernel.snapshot.nodes + assert advised.new_root == ablated.new_root + assert advised.receipt.receipt_hash != ablated.receipt.receipt_hash + + +def test_advice_ablation_changes_only_evidence_binding_not_validated_field(): + no_advice_kernel = _kernel("ablation-lineage") + advice_kernel = _kernel("ablation-lineage") + no_advice = _workflow(no_advice_kernel).analyze(_spec()) + with_advice = _workflow(advice_kernel).analyze(_spec(), advice=_SealedV18Stub()) + + assert no_advice.committed and with_advice.committed + left = no_advice_kernel.snapshot.nodes[0] + right = advice_kernel.snapshot.nodes[0] + assert left == right + assert no_advice.new_root == with_advice.new_root + assert no_advice.receipt.receipt_hash != with_advice.receipt.receipt_hash + assert no_advice.receipt.proposal.proposal_hash != ( + with_advice.receipt.proposal.proposal_hash + ) + assert _receipt_advice(no_advice.receipt)["mode"] == "ABLATED" + assert _receipt_advice(with_advice.receipt)["mode"] == "PRESENT" + + +def test_problem_commit_order_converges_to_identical_graph_state(): + left_kernel = _kernel("order-convergence-lineage") + right_kernel = _kernel("order-convergence-lineage") + problem_a = _spec(problem_id="order_a", marker="A") + problem_b = _spec(problem_id="order_b", marker="B") + + assert _workflow(left_kernel).analyze(problem_a).committed + assert _workflow(left_kernel).analyze(problem_b).committed + assert _workflow(right_kernel).analyze(problem_b).committed + assert _workflow(right_kernel).analyze(problem_a).committed + + assert left_kernel.snapshot.root == right_kernel.snapshot.root + assert left_kernel.snapshot.nodes == right_kernel.snapshot.nodes + assert left_kernel.snapshot.edges == right_kernel.snapshot.edges == () + + +def test_forged_constraint_field_is_rejected_with_zero_canonical_effect(): + kernel = _kernel("forged-field") + prepared = _workflow(kernel).prepare_request(_spec()) + + def mutate(obligation, payload): + if obligation == "constraint_field_integrity_v1": + payload["constraint_field"]["status"] = "forged" + + request = _rebound_request(prepared, prepared.request.proposal, mutate=mutate) + root = kernel.snapshot.root + receipt = kernel.authorize_and_commit(request) + + assert receipt.decision is Decision.REJECT + assert receipt.previous_root == receipt.new_root == root + assert not kernel.snapshot.nodes + assert kernel.verify_receipt(receipt) and kernel.verify_live_state() + + +def test_split_view_evidence_envelopes_cannot_authorize_a_forged_node(): + kernel = _kernel("split-view-evidence") + prepared = _workflow(kernel).prepare_request(_spec()) + forged = deepcopy( + next( + envelope.payload + for envelope in prepared.request.evidence + if envelope.obligation_id == "workflow_boundary_v1" + ) + ) + forged["constraint_field"]["status"] = "forged-but-authorized" + forged["node_payload"] = expected_node_payload(forged) + forged["node_payload_hash"] = workflow_stable_hash(forged["node_payload"]) + forged["mutation_intent"] = expected_mutation_intent(forged) + forged["mutation_intent_hash"] = workflow_stable_hash(forged["mutation_intent"]) + node = GraphNode.create( + prepared.node_id, + "ts.problem_analysis", + forged["node_payload"], + ) + proposal = _signed_proposal( + prepared, + kernel, + operation=PatchOperation.upsert_node(node), + mutation_intent_hash=forged["mutation_intent_hash"], + metadata=expected_proposal_metadata(forged), + ) + envelopes = [] + for envelope in prepared.request.evidence: + payload = ( + deepcopy(forged) + if envelope.obligation_id == "workflow_boundary_v1" + else deepcopy(envelope.payload) + ) + payload["proposal_hash"] = proposal.proposal_hash + envelopes.append(EvidenceEnvelope.create(envelope.obligation_id, payload)) + request = AuthorityRequest.create(proposal, envelopes) + root = kernel.snapshot.root + + receipt = kernel.authorize_and_commit(request) + + assert receipt.decision is Decision.REJECT + assert receipt.previous_root == receipt.new_root == root + assert not kernel.snapshot.nodes + findings = {item.obligation_id: item.finding for item in receipt.verifier_receipts} + assert findings["workflow_boundary_v1"].outcome.value == "pass" + assert findings["constraint_field_integrity_v1"].outcome.value == "fail" + assert findings["provenance_binding_v1"].outcome.value == "fail" + assert kernel.verify_receipt(receipt) and kernel.verify_live_state() + + +def test_missing_evidence_is_rejected_before_any_canonical_effect(): + kernel = _kernel("missing-evidence") + prepared = _workflow(kernel).prepare_request(_spec()) + request = AuthorityRequest.create( + prepared.request.proposal, + prepared.request.evidence[:-1], + ) + root = kernel.snapshot.root + + receipt = kernel.authorize_and_commit(request) + assert receipt.decision is Decision.REJECT + assert "evidence_coverage_mismatch" in receipt.reason_codes + assert receipt.previous_root == receipt.new_root == root + assert not receipt.ledgered + + +def test_stale_request_is_rejected_without_undoing_the_winning_commit(): + kernel = _kernel("stale-request") + workflow = _workflow(kernel) + stale = workflow.prepare_request(_spec(problem_id="stale_a", marker="stale")) + winner = workflow.analyze(_spec(problem_id="stale_b", marker="winner")) + winning_root = kernel.snapshot.root + + receipt = kernel.authorize_and_commit(stale.request) + assert winner.committed + assert receipt.decision is Decision.REJECT + assert "stale_parent_root" in receipt.reason_codes + assert receipt.previous_root == receipt.new_root == winning_root + assert len(kernel.snapshot.nodes) == 1 + + +def test_unknown_kind_and_representation_payload_are_rejected(): + for attack in ("unknown_kind", "representation"): + kernel = _kernel(f"attack-{attack}") + prepared = _workflow(kernel).prepare_request(_spec()) + base_payload = prepared.node_payload + kind = "ts.unknown" if attack == "unknown_kind" else "ts.problem_analysis" + if attack == "representation": + base_payload["representation"] = {"scheme": "forged"} + node = GraphNode.create(prepared.node_id, kind, base_payload) + proposal = _signed_proposal( + prepared, + kernel, + operation=PatchOperation.upsert_node(node), + ) + request = _rebound_request(prepared, proposal) + root = kernel.snapshot.root + + receipt = kernel.authorize_and_commit(request) + assert receipt.decision is Decision.REJECT + assert receipt.previous_root == receipt.new_root == root + assert not kernel.snapshot.nodes + + +def test_alternate_node_id_for_same_spec_is_rejected(): + kernel = _kernel("alternate-node-id") + prepared = _workflow(kernel).prepare_request(_spec()) + alternate = f"ts.problem_analysis:{'f' * 64}" + base_evidence = prepared.request.evidence[0].payload + alternate_intent = deepcopy(base_evidence["mutation_intent"]) + alternate_intent["node_id"] = alternate + alternate_intent_hash = workflow_stable_hash(alternate_intent) + node = GraphNode.create(alternate, "ts.problem_analysis", prepared.node_payload) + proposal = _signed_proposal( + prepared, + kernel, + operation=PatchOperation.upsert_node(node), + affected_nodes=(alternate,), + mutation_intent_hash=alternate_intent_hash, + ) + + def mutate(_obligation, payload): + payload["node_id"] = alternate + payload["mutation_intent"] = deepcopy(alternate_intent) + payload["mutation_intent_hash"] = alternate_intent_hash + + request = _rebound_request(prepared, proposal, mutate=mutate) + root = kernel.snapshot.root + receipt = kernel.authorize_and_commit(request) + + assert receipt.decision is Decision.REJECT + assert receipt.previous_root == receipt.new_root == root + assert not kernel.snapshot.nodes + + +def test_overwrite_of_existing_problem_node_is_rejected(): + kernel = _kernel("overwrite") + workflow = _workflow(kernel) + prepared = workflow.prepare_request(_spec()) + first = kernel.authorize_and_commit(prepared.request) + assert first.decision is Decision.AUTHORIZE + committed_root = kernel.snapshot.root + + changed = prepared.node_payload + changed["bindings"]["forged_revision"] = 1 + node = GraphNode.create(prepared.node_id, "ts.problem_analysis", changed) + proposal = _signed_proposal( + prepared, + kernel, + operation=PatchOperation.upsert_node(node), + current_parent=True, + ) + context = kernel.context + parent_binding = { + "graph_lineage_id": context.graph_lineage_id, + "parent_root": context.current_root, + "parent_authority_hash": context.parent_authority_hash, + "expected_sequence": context.next_sequence, + } + request = _rebound_request( + prepared, + proposal, + parent_binding=parent_binding, + ) + receipt = kernel.authorize_and_commit(request) + + assert receipt.decision is Decision.REJECT + assert receipt.previous_root == receipt.new_root == committed_root + assert kernel.snapshot.nodes[0].payload == prepared.node_payload + + +def test_concurrent_same_problem_has_exactly_one_commit(): + kernel = _kernel("same-problem-race") + workflow = _workflow(kernel) + barrier = threading.Barrier(2) + outcomes = [] + lock = threading.Lock() + + def run(): + outcome = workflow.analyze(_spec(), advice=_SealedV18Stub(barrier=barrier)) + with lock: + outcomes.append(outcome) + + threads = [threading.Thread(target=run) for _ in range(2)] + for thread in threads: + thread.start() + for thread in threads: + thread.join(timeout=10) + + assert all(not thread.is_alive() for thread in threads) + assert len(outcomes) == 2 + assert sum(outcome.committed for outcome in outcomes) == 1 + assert len(kernel.snapshot.nodes) == 1 + assert sum(receipt.decision is Decision.AUTHORIZE for receipt in kernel.ledger) == 1 + assert kernel.verify_live_state() + + +class _CommitDuringVerifyProxy: + def __init__(self, delegate, callback): + self.delegate = delegate + self.callback = callback + self.callback_outcome = None + + @property + def context(self): + return self.delegate.context + + @property + def snapshot(self): + return self.delegate.snapshot + + def authorize_and_commit(self, request): + return self.delegate.authorize_and_commit(request) + + def verify_receipt(self, receipt): + if self.callback_outcome is None: + self.callback_outcome = self.callback() + return self.delegate.verify_receipt(receipt) + + def verify_live_state(self): + return self.delegate.verify_live_state() + + +def test_later_concurrent_commit_does_not_false_fail_verified_outcome(): + kernel = _kernel("different-problem-race") + second_workflow = _workflow(kernel) + proxy = _CommitDuringVerifyProxy( + kernel, + lambda: second_workflow.analyze(_spec(problem_id="problem_b", marker="second")), + ) + first_workflow = _workflow(proxy) + + first = first_workflow.analyze(_spec(problem_id="problem_a", marker="first")) + assert first.state is WorkflowState.COMMITTED + assert proxy.callback_outcome.state is WorkflowState.COMMITTED + assert first.new_root == first.receipt.new_root + assert first.new_root != kernel.snapshot.root + assert len(kernel.snapshot.nodes) == 2 + assert kernel.verify_live_state() + + +def test_checkpoint_restore_preserves_authority_chain_and_allows_next_problem(): + kernel = _kernel("checkpoint-lineage") + first = _workflow(kernel).analyze(_spec(problem_id="checkpoint_a")) + checkpoint = kernel.export_checkpoint() + + restored = _kernel("checkpoint-lineage", checkpoint=checkpoint) + assert restored.verify_live_state() + assert restored.verify_receipt(first.receipt) + duplicate = _workflow(restored).analyze(_spec(problem_id="checkpoint_a")) + second = _workflow(restored).analyze( + _spec(problem_id="checkpoint_b", marker="next") + ) + assert duplicate.state is WorkflowState.ABSTAINED + assert not duplicate.request_created + assert second.state is WorkflowState.COMMITTED + assert second.receipt.sequence == 2 + assert len(restored.snapshot.nodes) == 2 + + +def test_checkpoint_restore_rejects_a_different_requested_lineage(): + kernel = _kernel("checkpoint-bound-lineage") + assert _workflow(kernel).analyze(_spec(problem_id="checkpoint_bound")).committed + checkpoint = kernel.export_checkpoint() + + with pytest.raises(WorkflowBuildError, match="lineage"): + _kernel("wrong-lineage", checkpoint=checkpoint) + + +def test_specialized_kernel_builder_always_has_empty_genesis(): + kernel = _kernel("empty-genesis") + assert not kernel.snapshot.nodes + assert not kernel.snapshot.edges + assert not kernel.ledger + + +def test_checkpoint_with_unvalidated_foreign_genesis_is_rejected(): + template = _kernel("foreign-genesis-lineage") + foreign_node = GraphNode.create( + "ts.problem_analysis:foreign-genesis", + "ts.problem_analysis", + {"schema": "foreign-genesis-v1", "code": "unvalidated"}, + ) + foreign = AuthorityKernel( + graph_lineage_id="foreign-genesis-lineage", + proposer_specs=tuple(template._proposers.values()), + verifier_specs=tuple(template._registry.values()), + policy=template._policy, + authority_key_id=template._authority_key_id, + authority_signing_key=template._authority_signing_key, + initial_nodes=(foreign_node,), + ) + assert foreign.verify_live_state() + + with pytest.raises(WorkflowBuildError, match="empty-genesis"): + _kernel( + "foreign-genesis-lineage", + checkpoint=foreign.export_checkpoint(), + ) + + +def test_workflow_package_has_no_direct_ulg_or_commit_document_bypass(): + package = ( + Path(__file__).parents[1] / "reasoner" / "ts_reasoner" / "problem_workflow" + ) + source = "\n".join( + path.read_text(encoding="utf-8") for path in package.glob("*.py") + ) + + assert "UniversalLivingGraph" not in source + assert "commit_document" not in source + assert ".add_node(" not in source + assert ".add_edge(" not in source diff --git a/tools/build_cortex_prime_supervision.py b/tools/build_cortex_prime_supervision.py new file mode 100755 index 0000000..2c19f6f --- /dev/null +++ b/tools/build_cortex_prime_supervision.py @@ -0,0 +1,338 @@ +#!/usr/bin/env python3 +"""Build provenance-bound Cortex <-> PRIME supervision. + +HELDOUT IS FORBIDDEN. +""" + +from __future__ import annotations + +import argparse +from collections import Counter +import hashlib +import json +from pathlib import Path + +from core.cortex.prime_bridge import ( + PrimeCortexBridge, + canonical_json, + stable_hash, +) + + +def sha256_file( + path: Path, +) -> str: + digest = hashlib.sha256() + + with path.open( + "rb" + ) as handle: + for chunk in iter( + lambda: handle.read( + 1024 * 1024 + ), + b"", + ): + digest.update( + chunk + ) + + return digest.hexdigest() + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--source", + default=( + "data/native_cortex/" + "splits/train.jsonl" + ), + ) + + parser.add_argument( + "--output", + default=( + "data/native_cortex/" + "prime_bridge/train" + ), + ) + + parser.add_argument( + "--max-docs", + type=int, + default=6000, + ) + + parser.add_argument( + "--max-chars", + type=int, + default=1200, + ) + + args = parser.parse_args() + + source_path = Path( + args.source + ) + + if ( + "heldout" + in source_path.name.lower() + ): + raise RuntimeError( + "HELDOUT BRIDGE ACCESS FORBIDDEN" + ) + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + semantic_path = ( + output + / "semantic.jsonl" + ) + + verifier_path = ( + output + / "verifier.jsonl" + ) + + bridge = PrimeCortexBridge() + + semantic_count = 0 + verifier_count = 0 + action_counts = Counter() + label_counts = Counter() + + parent_hash = "" + + with ( + source_path.open( + "r", + encoding="utf-8", + ) as source, + semantic_path.open( + "w", + encoding="utf-8", + ) as semantic_file, + verifier_path.open( + "w", + encoding="utf-8", + ) as verifier_file, + ): + for document_index, line in enumerate( + source + ): + if ( + document_index + >= args.max_docs + ): + break + + source_record = json.loads( + line + ) + + text = str( + source_record["text"] + )[ + :args.max_chars + ] + + source_hash = ( + source_record.get( + "sha256" + ) + or stable_hash( + text + ) + ) + + compiled = ( + bridge.compile_source( + text + ) + ) + + proposal = ( + bridge.semantic_proposal( + text + ) + ) + + semantic_record = { + "source_sha256": ( + source_hash + ), + "source_text": text, + "proposal": proposal, + "proposal_text": ( + canonical_json( + proposal + ) + ), + "proposal_sha256": ( + stable_hash( + proposal + ) + ), + "teacher": ( + "TSLCCompiler" + ), + "authority": "NONE", + } + + semantic_file.write( + json.dumps( + semantic_record, + sort_keys=True, + ensure_ascii=False, + ) + + "\n" + ) + + semantic_count += 1 + + experiences = ( + bridge.verify_proposal( + source_text=text, + source_sha256=( + source_hash + ), + proposal=proposal, + parent_hash=( + parent_hash + ), + ) + ) + + for experience in ( + experiences + ): + payload = ( + experience + .__dict__ + .copy() + ) + + verifier_file.write( + json.dumps( + payload, + sort_keys=True, + ensure_ascii=False, + default=str, + ) + + "\n" + ) + + parent_hash = ( + experience.record_hash + ) + + verifier_count += 1 + + action_counts[ + experience.verifier_action + ] += 1 + + label_counts[ + experience.verifier_label + ] += 1 + + if ( + document_index + 1 + ) % 250 == 0: + print( + "documents:", + document_index + 1, + "semantic:", + semantic_count, + "verifier:", + verifier_count, + "labels:", + dict( + label_counts + ), + ) + + manifest = { + "format": ( + "mega-prime-cortex-" + "verifier-experience-v1" + ), + "source": str( + source_path + ), + "source_sha256": ( + sha256_file( + source_path + ) + ), + "max_docs": ( + args.max_docs + ), + "semantic_records": ( + semantic_count + ), + "verifier_records": ( + verifier_count + ), + "actions": dict( + sorted( + action_counts.items() + ) + ), + "labels": dict( + sorted( + label_counts.items() + ) + ), + "semantic_sha256": ( + sha256_file( + semantic_path + ) + ), + "verifier_sha256": ( + sha256_file( + verifier_path + ) + ), + "final_experience_hash": ( + parent_hash + ), + "authority": "NONE", + } + + manifest_path = ( + output + / "MANIFEST.json" + ) + + manifest_path.write_text( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + print() + print( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tools/build_counterfactual_verifier_curriculum.py b/tools/build_counterfactual_verifier_curriculum.py new file mode 100755 index 0000000..6182e2f --- /dev/null +++ b/tools/build_counterfactual_verifier_curriculum.py @@ -0,0 +1,534 @@ +#!/usr/bin/env python3 +"""Build matched counterfactual Cortex-PRIME verifier curriculum. + +ACCEPT and REJECT are newly generated matched pairs using canonical +typed PRIME verifiers. + +UNKNOWN, REPAIR and ABSTAIN are copied from the frozen v1 curriculum. + +HELDOUT IS NEVER ACCESSED. +""" + +from __future__ import annotations + +import argparse +from collections import Counter +import hashlib +import json +from pathlib import Path +import random + +from core.cortex.counterfactual_verifier import ( + PAIR_CHANNELS, + build_counterfactual_pair, +) + +from core.cortex.prime_bridge import ( + stable_hash, +) + + +FROZEN_TRAIN_SHA256 = ( + "09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516" +) + +FROZEN_DEVELOPMENT_SHA256 = ( + "071305f8af9974b9014a297dbcf2058aa768ccb80224ef962b184447c61c2f57" +) + +CONTROL_LABELS = ( + "UNKNOWN", + "REPAIR", + "ABSTAIN", +) + + +def sha256_file( + path: Path, +) -> str: + digest = hashlib.sha256() + + with path.open( + "rb" + ) as handle: + for chunk in iter( + lambda: handle.read( + 1024 * 1024 + ), + b"", + ): + digest.update( + chunk + ) + + return digest.hexdigest() + + +def load_jsonl( + path: Path, +): + with path.open( + "r", + encoding="utf-8", + ) as handle: + return [ + json.loads(line) + for line in handle + if line.strip() + ] + + +def copy_control_records( + records, + *, + count_per_label: int, + source_name: str, +): + selected = [] + + for label in CONTROL_LABELS: + candidates = [ + row + for row in records + if row.get( + "verifier_label" + ) == label + ] + + if len(candidates) < count_per_label: + raise RuntimeError( + f"not enough {label} controls " + f"in {source_name}: " + f"{len(candidates)} " + f"< {count_per_label}" + ) + + for source in candidates[ + :count_per_label + ]: + row = dict(source) + + source_record_hash = row.pop( + "record_hash", + "" + ) + + source_experience_hash = row.pop( + "experience_hash", + "" + ) + + source_parent_hash = row.pop( + "parent_hash", + "" + ) + + row[ + "counterfactual_pair" + ] = False + + row[ + "curriculum_origin" + ] = ( + "frozen_v1_control" + ) + + row[ + "source_curriculum" + ] = source_name + + row[ + "source_record_hash" + ] = source_record_hash + + if source_experience_hash: + row[ + "source_experience_hash" + ] = source_experience_hash + + if source_parent_hash: + row[ + "source_parent_hash" + ] = source_parent_hash + + row["record_hash"] = ( + stable_hash(row) + ) + + selected.append( + row + ) + + return selected + + +def build_split( + *, + split_name: str, + pair_count: int, + index_offset: int, + control_source, + output_path: Path, + rng_seed: int, +): + records = [] + pair_hashes = [] + + for pair_number in range( + pair_count + ): + channel = PAIR_CHANNELS[ + pair_number + % len(PAIR_CHANNELS) + ] + + pair_index = ( + index_offset + + pair_number + ) + + pair = ( + build_counterfactual_pair( + channel, + pair_index, + split=split_name, + ) + ) + + if len(pair) != 2: + raise RuntimeError( + "counterfactual pair " + "must contain exactly " + "two records" + ) + + labels = { + row[ + "verifier_label" + ] + for row in pair + } + + if labels != { + "ACCEPT", + "REJECT", + }: + raise RuntimeError( + "counterfactual pair " + "must contain exactly " + "ACCEPT and REJECT" + ) + + pair_hash = pair[0][ + "pair_hash" + ] + + if pair[1][ + "pair_hash" + ] != pair_hash: + raise RuntimeError( + "pair hash mismatch" + ) + + pair_hashes.append( + pair_hash + ) + + records.extend( + pair + ) + + controls = copy_control_records( + control_source, + count_per_label=pair_count, + source_name=split_name, + ) + + records.extend( + controls + ) + + label_counts = Counter( + row[ + "verifier_label" + ] + for row in records + ) + + expected = { + "UNKNOWN": pair_count, + "ACCEPT": pair_count, + "REJECT": pair_count, + "REPAIR": pair_count, + "ABSTAIN": pair_count, + } + + if dict( + sorted( + label_counts.items() + ) + ) != expected: + raise RuntimeError( + "unexpected label balance: " + + str(label_counts) + ) + + rng = random.Random( + rng_seed + ) + + rng.shuffle( + records + ) + + output_path.parent.mkdir( + parents=True, + exist_ok=True, + ) + + with output_path.open( + "w", + encoding="utf-8", + ) as handle: + for row in records: + handle.write( + json.dumps( + row, + sort_keys=True, + ensure_ascii=False, + ) + + "\n" + ) + + channel_counts = Counter( + row["verifier_type"] + for row in records + if row.get( + "counterfactual_pair" + ) + ) + + return { + "split": split_name, + "records": len(records), + "pairs": pair_count, + "labels": dict( + sorted( + label_counts.items() + ) + ), + "paired_channels": dict( + sorted( + channel_counts.items() + ) + ), + "pair_set_sha256": stable_hash( + sorted( + pair_hashes + ) + ), + "sha256": sha256_file( + output_path + ), + } + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--source-train", + default=( + "data/native_cortex/" + "prime_bridge/curriculum/" + "train.jsonl" + ), + ) + + parser.add_argument( + "--source-development", + default=( + "data/native_cortex/" + "prime_bridge/curriculum/" + "development.jsonl" + ), + ) + + parser.add_argument( + "--output", + default=( + "data/native_cortex/" + "verifier_semantics/" + "counterfactual_v1" + ), + ) + + parser.add_argument( + "--train-pairs", + type=int, + default=500, + ) + + parser.add_argument( + "--development-pairs", + type=int, + default=100, + ) + + parser.add_argument( + "--seed", + type=int, + default=26082501, + ) + + args = parser.parse_args() + + train_path = Path( + args.source_train + ) + + development_path = Path( + args.source_development + ) + + for path in ( + train_path, + development_path, + ): + if "heldout" in str( + path + ).lower(): + raise RuntimeError( + "HELDOUT ACCESS FORBIDDEN" + ) + + observed_train_sha = ( + sha256_file( + train_path + ) + ) + + observed_development_sha = ( + sha256_file( + development_path + ) + ) + + if ( + observed_train_sha + != FROZEN_TRAIN_SHA256 + ): + raise RuntimeError( + "frozen train curriculum " + "hash mismatch: " + + observed_train_sha + ) + + if ( + observed_development_sha + != FROZEN_DEVELOPMENT_SHA256 + ): + raise RuntimeError( + "frozen development " + "curriculum hash mismatch: " + + observed_development_sha + ) + + train_source = load_jsonl( + train_path + ) + + development_source = load_jsonl( + development_path + ) + + output = Path( + args.output + ) + + train_result = build_split( + split_name="train", + pair_count=args.train_pairs, + index_offset=0, + control_source=train_source, + output_path=( + output + / "train.jsonl" + ), + rng_seed=args.seed, + ) + + development_result = build_split( + split_name="development", + pair_count=( + args.development_pairs + ), + index_offset=100000, + control_source=( + development_source + ), + output_path=( + output + / "development.jsonl" + ), + rng_seed=( + args.seed + + 1 + ), + ) + + manifest = { + "format": ( + "mega-prime-counterfactual-" + "verifier-curriculum-v1" + ), + "authority": "NONE", + "construction": ( + "matched ACCEPT/REJECT " + "canonical typed verifier pairs " + "plus frozen v1 UNKNOWN/REPAIR/" + "ABSTAIN controls" + ), + "source_train_sha256": ( + observed_train_sha + ), + "source_development_sha256": ( + observed_development_sha + ), + "builder_sha256": sha256_file( + Path(__file__) + ), + "seed": args.seed, + "splits": { + "train": train_result, + "development": ( + development_result + ), + }, + } + + manifest_path = ( + output + / "MANIFEST.json" + ) + + manifest_path.write_text( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + print( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tools/build_native_cortex_corpus.py b/tools/build_native_cortex_corpus.py new file mode 100755 index 0000000..bc8e5df --- /dev/null +++ b/tools/build_native_cortex_corpus.py @@ -0,0 +1,315 @@ +#!/usr/bin/env python3 +"""Build a deterministic provenance-bound Native Cortex language corpus.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path + +from datasets import load_dataset +from tqdm import tqdm + + +def digest_text(text: str) -> str: + return hashlib.sha256( + text.encode("utf-8") + ).hexdigest() + + +def split_from_hash( + digest: str, +) -> str: + """Document-level deterministic split. + + ~98% train + ~1% development + ~1% heldout + + The split depends only on document content. + """ + + value = int( + digest[:16], + 16, + ) % 10_000 + + if value < 100: + return "heldout" + + if value < 200: + return "development" + + return "train" + + +def write_record( + handles, + *, + source, + source_split, + index, + text, +): + text = text.strip() + + if len(text) < 80: + return None + + digest = digest_text( + text + ) + + split = split_from_hash( + digest + ) + + record = { + "sha256": digest, + "source": source, + "source_split": source_split, + "source_index": index, + "characters": len(text), + "text": text, + } + + handles[ + split + ].write( + json.dumps( + record, + ensure_ascii=False, + sort_keys=True, + ) + + "\n" + ) + + return split + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--output", + default="data/native_cortex/splits", + ) + + parser.add_argument( + "--tinystories", + type=int, + default=25_000, + help="Maximum TinyStories documents.", + ) + + parser.add_argument( + "--wikitext", + type=int, + default=20_000, + help="Maximum non-empty WikiText passages.", + ) + + args = parser.parse_args() + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + paths = { + split: output / f"{split}.jsonl" + for split in ( + "train", + "development", + "heldout", + ) + } + + handles = { + split: path.open( + "w", + encoding="utf-8", + ) + for split, path in paths.items() + } + + counts = { + split: 0 + for split in handles + } + + characters = { + split: 0 + for split in handles + } + + provenance = [] + + try: + tiny = load_dataset( + "roneneldan/TinyStories", + split="train", + streaming=True, + ) + + for index, row in enumerate( + tqdm( + tiny, + total=args.tinystories, + desc="TinyStories", + ) + ): + if index >= args.tinystories: + break + + text = row.get( + "text", + "", + ) + + result = write_record( + handles, + source="roneneldan/TinyStories", + source_split="train", + index=index, + text=text, + ) + + if result is not None: + counts[result] += 1 + characters[result] += len( + text.strip() + ) + + provenance.append( + { + "source": "roneneldan/TinyStories", + "source_split": "train", + "maximum_records_examined": args.tinystories, + } + ) + + wiki = load_dataset( + "Salesforce/wikitext", + "wikitext-103-v1", + split="train", + streaming=True, + ) + + accepted = 0 + + for index, row in enumerate( + tqdm( + wiki, + desc="WikiText", + ) + ): + text = row.get( + "text", + "", + ).strip() + + if len(text) < 80: + continue + + result = write_record( + handles, + source="Salesforce/wikitext", + source_split="train", + index=index, + text=text, + ) + + if result is not None: + counts[result] += 1 + characters[result] += len( + text + ) + + accepted += 1 + + if accepted >= args.wikitext: + break + + provenance.append( + { + "source": "Salesforce/wikitext", + "configuration": "wikitext-103-v1", + "source_split": "train", + "maximum_accepted_records": args.wikitext, + } + ) + + finally: + for handle in handles.values(): + handle.close() + + manifest = { + "format": "mega-prime-native-cortex-corpus-v1", + "split_policy": ( + "sha256(document) mod 10000: " + "0..99 heldout, " + "100..199 development, " + "200..9999 train" + ), + "counts": counts, + "characters": characters, + "sources": provenance, + "files": {}, + } + + for split, path in paths.items(): + digest = hashlib.sha256( + path.read_bytes() + ).hexdigest() + + manifest["files"][ + split + ] = { + "path": str(path), + "sha256": digest, + "bytes": path.stat().st_size, + } + + manifest_path = ( + output + / "CORPUS_MANIFEST.json" + ) + + manifest_path.write_text( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + manifest_digest = hashlib.sha256( + manifest_path.read_bytes() + ).hexdigest() + + ( + output + / "CORPUS_MANIFEST.sha256" + ).write_text( + f"{manifest_digest} CORPUS_MANIFEST.json\n", + encoding="utf-8", + ) + + print( + json.dumps( + manifest, + indent=2, + sort_keys=True, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tools/build_typed_verifier_curriculum.py b/tools/build_typed_verifier_curriculum.py new file mode 100755 index 0000000..8b65c56 --- /dev/null +++ b/tools/build_typed_verifier_curriculum.py @@ -0,0 +1,965 @@ +#!/usr/bin/env python3 +"""Build balanced supervision from canonical PRIME verifier outcomes. + +No labels are invented: + pass -> ACCEPT + fail -> REJECT + open_repair -> REPAIR + unsupported -> ABSTAIN + error -> UNKNOWN + +HELDOUT IS NEVER ACCESSED. +""" + +from __future__ import annotations + +import argparse +from collections import Counter +import hashlib +import json +from pathlib import Path +import random + +from core.cortex.prime_bridge import ( + VERIFIER_LABEL_TO_ID, + stable_hash, +) + +from core.kernel.ir import ( + ClaimNode, + EntityNode, + Provenance, + TSIRDocument, + VerifierObligation, +) + +from core.kernel.obligations import ( + ArithmeticVerifier, + CodePropertyVerifier, + StructuralVerifier, +) + +from core.kernel.transaction import ( + TransactionWorkspace, +) + + +LABEL_FROM_OUTCOME = { + "pass": "ACCEPT", + "fail": "REJECT", + "unsupported": "ABSTAIN", + "error": "UNKNOWN", +} + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + + with path.open("rb") as handle: + for chunk in iter( + lambda: handle.read(1024 * 1024), + b"", + ): + digest.update(chunk) + + return digest.hexdigest() + + +def workspace( + document: TSIRDocument | None = None, +): + return TransactionWorkspace( + base_graph_hash="curriculum", + document=( + document + if document is not None + else TSIRDocument() + ), + base_nodes={}, + base_edges=[], + ) + + +def finalize_record( + *, + verifier_type, + source_text, + premises, + obligation, + outcome, + verifier_result, +): + label = LABEL_FROM_OUTCOME[ + outcome + ] + + record = { + "source_text": source_text, + "premises": list(premises), + "obligation": obligation, + "verifier_type": verifier_type, + "verifier_action": ( + f"typed_{outcome}" + ), + "verifier_label": label, + "verifier_label_id": ( + VERIFIER_LABEL_TO_ID[ + label + ] + ), + "verifier_result": ( + verifier_result + ), + "authority": "NONE", + } + + record["record_hash"] = ( + stable_hash(record) + ) + + return record + + +def arithmetic_record( + index, + *, + should_pass, +): + verifier = ArithmeticVerifier() + + a = ( + 3 + + ( + index * 17 + ) % 89 + ) + + b = ( + 2 + + ( + index * 31 + ) % 73 + ) + + correct = a + b + + expected = ( + correct + if should_pass + else correct + 1 + ) + + expression = ( + f"{a} + {b} = {expected}" + ) + + obligation = VerifierObligation( + id=f"curriculum:arith:{index}", + verifier_type="arithmetic", + target_claim=expression, + expected_property={ + "expression": expression, + }, + ) + + result = verifier.verify( + obligation, + workspace(), + ) + + expected_outcome = ( + "pass" + if should_pass + else "fail" + ) + + if ( + result.outcome + != expected_outcome + ): + raise RuntimeError( + ( + "arithmetic verifier mismatch: " + f"{result.outcome} " + f"!= {expected_outcome}" + ) + ) + + return finalize_record( + verifier_type="arithmetic", + source_text=( + "Verify the arithmetic proposition: " + + expression + ), + premises=[], + obligation=expression, + outcome=result.outcome, + verifier_result=( + result.to_dict() + ), + ) + + +def code_record( + index, + *, + should_pass, +): + verifier = CodePropertyVerifier() + + multiplier = ( + 2 + + index % 5 + ) + + offset = ( + index % 7 + ) + + function = ( + f"transform_{index}" + ) + + body = ( + f"x * {multiplier} + {offset}" + ) + + examples = [] + + for value in ( + 0, + 1, + 2, + 5, + ): + expected = ( + value + * multiplier + + offset + ) + + examples.append( + { + "input": value, + "expected": expected, + } + ) + + if not should_pass: + examples[-1][ + "expected" + ] += 1 + + spec = { + "function": function, + "parameter": "x", + "body": body, + "examples": examples, + } + + obligation = VerifierObligation( + id=f"curriculum:code:{index}", + verifier_type="code_property", + target_claim=function, + expected_property=spec, + ) + + result = verifier.verify( + obligation, + workspace(), + ) + + expected_outcome = ( + "pass" + if should_pass + else "fail" + ) + + if ( + result.outcome + != expected_outcome + ): + raise RuntimeError( + ( + "code verifier mismatch: " + f"{result.outcome} " + f"!= {expected_outcome}" + ) + ) + + premise = ( + f"{function}(x) = {body}; " + f"examples = {examples}" + ) + + return finalize_record( + verifier_type="code_property", + source_text=( + "Verify this bounded code property: " + + premise + ), + premises=[ + premise + ], + obligation=( + f"{function} satisfies " + "the supplied examples" + ), + outcome=result.outcome, + verifier_result=( + result.to_dict() + ), + ) + + +def structural_record( + index, + *, + should_pass, +): + verifier = StructuralVerifier() + + provenance = Provenance( + "system_seed", + reliability=1.0, + ) + + subject = ( + f"entity:subject:{index}" + ) + + object_id = ( + f"entity:object:{index}" + ) + + entities = [ + EntityNode( + id=subject, + entity_type="object", + label=f"subject {index}", + provenance=provenance, + ) + ] + + if should_pass: + entities.append( + EntityNode( + id=object_id, + entity_type="object", + label=f"object {index}", + provenance=provenance, + ) + ) + + claim = ClaimNode( + id=f"claim:struct:{index}", + subject=subject, + predicate="related_to", + object=object_id, + status="proposed", + provenance=provenance, + ) + + document = TSIRDocument( + entities=entities, + claims=[ + claim + ], + ) + + obligation = VerifierObligation( + id=f"curriculum:struct:{index}", + verifier_type="structural", + target_claim="__document__", + ) + + result = verifier.verify( + obligation, + workspace(document), + ) + + expected_outcome = ( + "pass" + if should_pass + else "fail" + ) + + if ( + result.outcome + != expected_outcome + ): + raise RuntimeError( + ( + "structural verifier mismatch: " + f"{result.outcome} " + f"!= {expected_outcome}" + ) + ) + + premise = ( + f"subject={subject}; " + f"object={object_id}; " + f"object_declared={should_pass}" + ) + + return finalize_record( + verifier_type="structural", + source_text=( + "Check TSIR structural consistency: " + + premise + ), + premises=[ + premise + ], + obligation=( + "TSIR document is " + "internally consistent" + ), + outcome=result.outcome, + verifier_result=( + result.to_dict() + ), + ) + + +def abstain_record( + index, +): + verifier = CodePropertyVerifier() + + obligation = VerifierObligation( + id=f"curriculum:unsupported:{index}", + verifier_type="code_property", + target_claim=( + f"unsupported program {index}" + ), + expected_property={ + "unsupported_input": True, + }, + ) + + result = verifier.verify( + obligation, + workspace(), + ) + + if ( + result.outcome + != "unsupported" + ): + raise RuntimeError( + "expected unsupported outcome" + ) + + return finalize_record( + verifier_type="code_property", + source_text=( + "Verify an unrestricted program " + f"outside the bounded verifier: {index}" + ), + premises=[], + obligation=( + "verify unsupported general " + f"program property {index}" + ), + outcome=result.outcome, + verifier_result=( + result.to_dict() + ), + ) + + +def unknown_record( + index, +): + verifier = ArithmeticVerifier() + + expression = ( + f"unknown_symbol_{index} + 2 = 4" + ) + + obligation = VerifierObligation( + id=f"curriculum:error:{index}", + verifier_type="arithmetic", + target_claim=expression, + expected_property={ + "expression": expression, + }, + ) + + result = verifier.verify( + obligation, + workspace(), + ) + + if ( + result.outcome + != "error" + ): + raise RuntimeError( + ( + "expected arithmetic " + "error outcome" + ) + ) + + return finalize_record( + verifier_type="arithmetic", + source_text=( + "Attempt verifier evaluation " + "with unresolved symbol: " + + expression + ), + premises=[], + obligation=expression, + outcome=result.outcome, + verifier_result=( + result.to_dict() + ), + ) + + +def load_repairs( + path: Path, +): + records = [] + + with path.open( + "r", + encoding="utf-8", + ) as handle: + for line in handle: + row = json.loads(line) + + if ( + row.get( + "verifier_label" + ) + != "REPAIR" + ): + continue + + record = { + "source_text": ( + row.get( + "source_text", + "", + ) + ), + "premises": ( + row.get( + "premises", + [], + ) + ), + "obligation": ( + row.get( + "obligation", + "", + ) + ), + "verifier_type": ( + "general_claim" + ), + "verifier_action": ( + row.get( + "verifier_action", + "open_repair", + ) + ), + "verifier_label": ( + "REPAIR" + ), + "verifier_label_id": ( + VERIFIER_LABEL_TO_ID[ + "REPAIR" + ] + ), + "verifier_result": ( + row.get( + "verifier_result", + {}, + ) + ), + "authority": "NONE", + "source_record_hash": ( + row.get( + "record_hash", + "", + ) + ), + } + + record[ + "record_hash" + ] = stable_hash( + record + ) + + records.append( + record + ) + + return sorted( + records, + key=lambda row: ( + row["record_hash"] + ), + ) + + +def create_split( + *, + split, + per_class, + repair_path, + seed, +): + records = [] + + for index in range( + per_class + ): + selector = ( + index % 3 + ) + + if selector == 0: + accept = ( + arithmetic_record( + index, + should_pass=True, + ) + ) + + reject = ( + arithmetic_record( + index + 100000, + should_pass=False, + ) + ) + + elif selector == 1: + accept = ( + code_record( + index, + should_pass=True, + ) + ) + + reject = ( + code_record( + index + 100000, + should_pass=False, + ) + ) + + else: + accept = ( + structural_record( + index, + should_pass=True, + ) + ) + + reject = ( + structural_record( + index + 100000, + should_pass=False, + ) + ) + + records.append( + accept + ) + + records.append( + reject + ) + + records.append( + abstain_record( + index + ) + ) + + records.append( + unknown_record( + index + ) + ) + + repairs = load_repairs( + repair_path + ) + + if ( + len(repairs) + < per_class + ): + raise RuntimeError( + ( + f"{split}: need " + f"{per_class} REPAIR " + "records but only found " + f"{len(repairs)}" + ) + ) + + records.extend( + repairs[ + :per_class + ] + ) + + rng = random.Random( + seed + ) + + rng.shuffle( + records + ) + + counts = Counter( + row[ + "verifier_label" + ] + for row + in records + ) + + expected = { + label: per_class + for label in ( + "ACCEPT", + "REJECT", + "REPAIR", + "ABSTAIN", + "UNKNOWN", + ) + } + + if dict( + sorted( + counts.items() + ) + ) != dict( + sorted( + expected.items() + ) + ): + raise RuntimeError( + ( + f"unbalanced split: " + f"{counts}" + ) + ) + + return ( + records, + counts, + ) + + +def write_jsonl( + path, + records, +): + parent_hash = "" + + with path.open( + "w", + encoding="utf-8", + ) as handle: + for record in records: + output = dict( + record + ) + + output[ + "parent_hash" + ] = parent_hash + + output[ + "experience_hash" + ] = stable_hash( + output + ) + + parent_hash = ( + output[ + "experience_hash" + ] + ) + + handle.write( + json.dumps( + output, + sort_keys=True, + ensure_ascii=False, + default=str, + ) + + "\n" + ) + + return parent_hash + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--train-repairs", + default=( + "data/native_cortex/" + "prime_bridge/train/" + "verifier.jsonl" + ), + ) + + parser.add_argument( + "--development-repairs", + default=( + "data/native_cortex/" + "prime_bridge/development/" + "verifier.jsonl" + ), + ) + + parser.add_argument( + "--output", + default=( + "data/native_cortex/" + "prime_bridge/curriculum" + ), + ) + + parser.add_argument( + "--train-per-class", + type=int, + default=500, + ) + + parser.add_argument( + "--development-per-class", + type=int, + default=100, + ) + + args = parser.parse_args() + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + specifications = ( + ( + "train", + args.train_per_class, + Path( + args.train_repairs + ), + 26082311, + ), + ( + "development", + args.development_per_class, + Path( + args.development_repairs + ), + 26082312, + ), + ) + + manifest = { + "format": ( + "mega-prime-typed-" + "verifier-curriculum-v1" + ), + "mapping": { + "pass": "ACCEPT", + "fail": "REJECT", + "open_repair": "REPAIR", + "unsupported": "ABSTAIN", + "error": "UNKNOWN", + }, + "authority": "NONE", + "splits": {}, + } + + for ( + split, + per_class, + repair_path, + seed, + ) in specifications: + records, counts = ( + create_split( + split=split, + per_class=per_class, + repair_path=repair_path, + seed=seed, + ) + ) + + path = ( + output + / f"{split}.jsonl" + ) + + final_hash = write_jsonl( + path, + records, + ) + + manifest[ + "splits" + ][split] = { + "records": len( + records + ), + "labels": dict( + sorted( + counts.items() + ) + ), + "sha256": ( + sha256_file( + path + ) + ), + "final_experience_hash": ( + final_hash + ), + } + + manifest_path = ( + output + / "MANIFEST.json" + ) + + manifest_path.write_text( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + print( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tools/evaluate_cortex_counterfactual_verifier_development.py b/tools/evaluate_cortex_counterfactual_verifier_development.py new file mode 100755 index 0000000..b603cbc --- /dev/null +++ b/tools/evaluate_cortex_counterfactual_verifier_development.py @@ -0,0 +1,1001 @@ +#!/usr/bin/env python3 +"""Development-only counterfactual verifier-semantics evaluation. + +Measures ordinary five-way performance plus matched ACCEPT/REJECT +pair discrimination and score-margin reversal. + +The neural cortex has authority NONE. + +HELDOUT IS FORBIDDEN. +""" + +from __future__ import annotations + +import argparse +from collections import Counter, defaultdict +import hashlib +import json +from pathlib import Path + +import torch + +from core.cortex import ( + BPETokenizer, + CortexV1Config, + NativeCortexV1, +) + +from core.cortex.prime_bridge import ( + VERIFIER_LABELS, +) + +from core.cortex.verifier_prompt import ( + format_verifier_prompt, +) + + +ACCEPT_ID = VERIFIER_LABELS.index( + "ACCEPT" +) + +REJECT_ID = VERIFIER_LABELS.index( + "REJECT" +) + +REQUIRED_CHANNELS = ( + "arithmetic", + "structural", + "code_property", +) + + +def sha256_file( + path: Path, +): + digest = hashlib.sha256() + + with path.open( + "rb" + ) as handle: + for chunk in iter( + lambda: handle.read( + 1024 * 1024 + ), + b"", + ): + digest.update( + chunk + ) + + return digest.hexdigest() + + +def stable_token_hash( + ids, +): + digest = hashlib.sha256() + + for token_id in ids: + digest.update( + int(token_id).to_bytes( + 4, + "big", + signed=False, + ) + ) + + return digest.hexdigest() + + +def load_model( + checkpoint_path: Path, + device: str, +): + checkpoint = torch.load( + checkpoint_path, + map_location=device, + weights_only=False, + ) + + config = CortexV1Config( + **checkpoint["config"] + ) + + tokenizer = BPETokenizer( + checkpoint["tokenizer"] + ) + + model = NativeCortexV1( + config + ).to(device) + + model.load_state_dict( + checkpoint["model"] + ) + + model.eval() + + return ( + checkpoint, + model, + tokenizer, + ) + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--checkpoint", + required=True, + ) + + parser.add_argument( + "--development", + default=( + "data/native_cortex/" + "verifier_semantics/" + "counterfactual_v1/" + "development.jsonl" + ), + ) + + parser.add_argument( + "--max-length", + type=int, + default=192, + ) + + parser.add_argument( + "--output-json", + default="", + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + development_path = Path( + args.development + ) + + if "heldout" in str( + development_path + ).lower(): + raise RuntimeError( + "HELDOUT EVALUATION IS FORBIDDEN" + ) + + checkpoint_path = Path( + args.checkpoint + ) + + ( + checkpoint, + model, + tokenizer, + ) = load_model( + checkpoint_path, + args.device, + ) + + label_count = len( + VERIFIER_LABELS + ) + + confusion = [ + [ + 0 + for _ in range( + label_count + ) + ] + for _ in range( + label_count + ) + ] + + class_total = Counter() + class_correct = Counter() + prediction_counts = Counter() + + channel_ar_total = Counter() + channel_ar_correct = Counter() + + pair_members = defaultdict( + dict + ) + + total = 0 + correct = 0 + + with torch.no_grad(): + with development_path.open( + "r", + encoding="utf-8", + ) as handle: + for line in handle: + if not line.strip(): + continue + + record = json.loads( + line + ) + + prompt = ( + format_verifier_prompt( + record + ) + ) + + full_ids = tokenizer.encode( + prompt, + add_bos=True, + add_eos=True, + ) + + ids = full_ids[ + -args.max_length: + ] + + x = torch.tensor( + ids, + dtype=torch.long, + device=args.device, + ).unsqueeze(0) + + result = model( + x + ) + + logits = ( + result + .verifier_logits[ + 0, + -1, + : + ] + ) + + probabilities = ( + torch.softmax( + logits, + dim=-1, + ) + ) + + prediction = int( + torch.argmax( + logits + ).item() + ) + + target = int( + record[ + "verifier_label_id" + ] + ) + + confusion[ + target + ][ + prediction + ] += 1 + + class_total[ + target + ] += 1 + + prediction_counts[ + prediction + ] += 1 + + total += 1 + + is_correct = ( + prediction + == target + ) + + if is_correct: + correct += 1 + + class_correct[ + target + ] += 1 + + target_label = ( + VERIFIER_LABELS[ + target + ] + ) + + channel = str( + record.get( + "verifier_type", + "unknown", + ) + ) + + if target_label in { + "ACCEPT", + "REJECT", + }: + channel_ar_total[ + channel + ] += 1 + + if is_correct: + channel_ar_correct[ + channel + ] += 1 + + pair_id = record.get( + "pair_id" + ) + + pair_member = record.get( + "pair_member" + ) + + if ( + record.get( + "counterfactual_pair" + ) + and pair_id + and pair_member + in { + "ACCEPT", + "REJECT", + } + ): + margin = float( + probabilities[ + ACCEPT_ID + ].item() + - probabilities[ + REJECT_ID + ].item() + ) + + pair_members[ + pair_id + ][ + pair_member + ] = { + "prediction": ( + VERIFIER_LABELS[ + prediction + ] + ), + "target": ( + target_label + ), + "channel": channel, + "margin": margin, + "prompt": prompt, + "full_token_hash": ( + stable_token_hash( + full_ids + ) + ), + "truncated_token_hash": ( + stable_token_hash( + ids + ) + ), + } + + accuracy = ( + correct / total + if total + else 0.0 + ) + + per_class = {} + + for index, label in enumerate( + VERIFIER_LABELS + ): + denominator = ( + class_total[ + index + ] + ) + + per_class[label] = ( + class_correct[index] + / denominator + if denominator + else 0.0 + ) + + macro_accuracy = ( + sum( + per_class.values() + ) + / label_count + ) + + minimum_class_accuracy = min( + per_class.values() + ) + + channel_ar_accuracy = {} + + for channel in REQUIRED_CHANNELS: + denominator = ( + channel_ar_total[ + channel + ] + ) + + channel_ar_accuracy[ + channel + ] = ( + channel_ar_correct[ + channel + ] + / denominator + if denominator + else 0.0 + ) + + pair_total = 0 + pair_correct = 0 + margin_reversal_count = 0 + + accept_margins = [] + reject_margins = [] + margin_flips = [] + + pair_channel_total = Counter() + pair_channel_correct = Counter() + + full_prompt_collisions = 0 + truncated_token_collisions = 0 + malformed_pairs = 0 + + for pair_id, members in ( + pair_members.items() + ): + if set( + members + ) != { + "ACCEPT", + "REJECT", + }: + malformed_pairs += 1 + continue + + positive = members[ + "ACCEPT" + ] + + negative = members[ + "REJECT" + ] + + if ( + positive["channel"] + != negative["channel"] + ): + malformed_pairs += 1 + continue + + channel = positive[ + "channel" + ] + + pair_total += 1 + + pair_channel_total[ + channel + ] += 1 + + both_correct = ( + positive[ + "prediction" + ] + == "ACCEPT" + and + negative[ + "prediction" + ] + == "REJECT" + ) + + if both_correct: + pair_correct += 1 + + pair_channel_correct[ + channel + ] += 1 + + positive_margin = ( + positive[ + "margin" + ] + ) + + negative_margin = ( + negative[ + "margin" + ] + ) + + accept_margins.append( + positive_margin + ) + + reject_margins.append( + negative_margin + ) + + margin_flips.append( + positive_margin + - negative_margin + ) + + if ( + positive_margin > 0.0 + and + negative_margin < 0.0 + ): + margin_reversal_count += 1 + + if ( + positive["prompt"] + == negative["prompt"] + ): + full_prompt_collisions += 1 + + if ( + positive[ + "truncated_token_hash" + ] + == negative[ + "truncated_token_hash" + ] + ): + truncated_token_collisions += 1 + + pair_accuracy = ( + pair_correct / pair_total + if pair_total + else 0.0 + ) + + margin_reversal_rate = ( + margin_reversal_count + / pair_total + if pair_total + else 0.0 + ) + + mean_accept_margin = ( + sum(accept_margins) + / len(accept_margins) + if accept_margins + else 0.0 + ) + + mean_reject_margin = ( + sum(reject_margins) + / len(reject_margins) + if reject_margins + else 0.0 + ) + + mean_margin_flip = ( + sum(margin_flips) + / len(margin_flips) + if margin_flips + else 0.0 + ) + + pair_channel_accuracy = {} + + for channel in REQUIRED_CHANNELS: + denominator = ( + pair_channel_total[ + channel + ] + ) + + pair_channel_accuracy[ + channel + ] = ( + pair_channel_correct[ + channel + ] + / denominator + if denominator + else 0.0 + ) + + gates = { + "overall_gt_0_60": ( + accuracy > 0.60 + ), + "macro_gt_0_60": ( + macro_accuracy > 0.60 + ), + "minimum_class_gt_0_35": ( + minimum_class_accuracy + > 0.35 + ), + "accept_gt_0_60": ( + per_class[ + "ACCEPT" + ] > 0.60 + ), + "reject_gt_0_60": ( + per_class[ + "REJECT" + ] > 0.60 + ), + "pair_accuracy_gt_0_50": ( + pair_accuracy > 0.50 + ), + "margin_reversal_gt_0_50": ( + margin_reversal_rate + > 0.50 + ), + "all_channel_ar_gt_0_60": all( + channel_ar_accuracy[ + channel + ] > 0.60 + for channel + in REQUIRED_CHANNELS + ), + "no_full_prompt_collisions": ( + full_prompt_collisions == 0 + ), + "no_truncated_token_collisions": ( + truncated_token_collisions + == 0 + ), + "no_malformed_pairs": ( + malformed_pairs == 0 + ), + } + + full_gate = all( + gates.values() + ) + + summary = { + "format": ( + "mega-prime-counterfactual-" + "verifier-development-v1" + ), + "authority": "NONE", + "checkpoint": str( + checkpoint_path + ), + "checkpoint_sha256": ( + sha256_file( + checkpoint_path + ) + ), + "checkpoint_format": ( + checkpoint.get( + "format", + "unknown", + ) + ), + "development": str( + development_path + ), + "development_sha256": ( + sha256_file( + development_path + ) + ), + "records": total, + "accuracy": accuracy, + "macro_accuracy": ( + macro_accuracy + ), + "minimum_class_accuracy": ( + minimum_class_accuracy + ), + "per_class": per_class, + "prediction_counts": { + VERIFIER_LABELS[index]: ( + prediction_counts[ + index + ] + ) + for index in range( + label_count + ) + }, + "channel_accept_reject_accuracy": ( + channel_ar_accuracy + ), + "pairs": pair_total, + "pair_accuracy": pair_accuracy, + "pair_channel_accuracy": ( + pair_channel_accuracy + ), + "mean_accept_margin": ( + mean_accept_margin + ), + "mean_reject_margin": ( + mean_reject_margin + ), + "mean_margin_flip": ( + mean_margin_flip + ), + "margin_reversal_rate": ( + margin_reversal_rate + ), + "full_prompt_collisions": ( + full_prompt_collisions + ), + "truncated_token_collisions": ( + truncated_token_collisions + ), + "malformed_pairs": ( + malformed_pairs + ), + "gates": gates, + "full_verifier_semantics_gate": ( + full_gate + ), + "confusion": confusion, + } + + print("=" * 92) + print( + "MEGA PRIME — COUNTERFACTUAL " + "VERIFIER SEMANTICS DEVELOPMENT" + ) + print("=" * 92) + + print( + "checkpoint:", + checkpoint_path, + ) + + print( + "checkpoint sha256:", + summary[ + "checkpoint_sha256" + ], + ) + + print( + "development:", + development_path, + ) + + print( + "development sha256:", + summary[ + "development_sha256" + ], + ) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "records:", + total, + ) + + print( + "pairs:", + pair_total, + ) + + print( + "authority:", + "NONE", + ) + + print() + + print( + "accuracy:", + f"{accuracy:.4f}", + ) + + print( + "macro accuracy:", + f"{macro_accuracy:.4f}", + ) + + print( + "minimum class accuracy:", + f"{minimum_class_accuracy:.4f}", + ) + + print() + + print("=== PER CLASS ===") + + for label in VERIFIER_LABELS: + print( + f"{label:8s}", + f"{per_class[label]:.4f}", + ) + + print() + + print( + "=== WITHIN-CHANNEL " + "ACCEPT/REJECT ===" + ) + + for channel in REQUIRED_CHANNELS: + print( + f"{channel:14s}", + f"{channel_ar_accuracy[channel]:.4f}", + ) + + print() + + print( + "=== PAIRED SEMANTICS ===" + ) + + print( + "pair accuracy:", + f"{pair_accuracy:.4f}", + ) + + print( + "margin reversal rate:", + f"{margin_reversal_rate:.4f}", + ) + + print( + "mean ACCEPT margin:", + f"{mean_accept_margin:+.6f}", + ) + + print( + "mean REJECT margin:", + f"{mean_reject_margin:+.6f}", + ) + + print( + "mean margin flip:", + f"{mean_margin_flip:+.6f}", + ) + + print() + + print( + "pair accuracy by channel:" + ) + + for channel in REQUIRED_CHANNELS: + print( + f"{channel:14s}", + f"{pair_channel_accuracy[channel]:.4f}", + ) + + print() + + print( + "full prompt collisions:", + full_prompt_collisions, + ) + + print( + "truncated token collisions:", + truncated_token_collisions, + ) + + print( + "malformed pairs:", + malformed_pairs, + ) + + print() + + print( + "=== PREDICTION DISTRIBUTION ===" + ) + + for index, label in enumerate( + VERIFIER_LABELS + ): + print( + f"{label:8s}", + prediction_counts[ + index + ], + ) + + print() + + print( + "=== CONFUSION MATRIX ===" + ) + + print( + "true\\pred", + *[ + f"{label[:4]:>5s}" + for label + in VERIFIER_LABELS + ], + ) + + for index, label in enumerate( + VERIFIER_LABELS + ): + print( + f"{label[:8]:>8s}", + *[ + f"{value:5d}" + for value + in confusion[index] + ], + ) + + print() + + print( + "=== FROZEN SEMANTICS GATES ===" + ) + + for name, passed in ( + gates.items() + ): + print( + f"{name}:", + passed, + ) + + print() + + print( + "FULL VERIFIER SEMANTICS GATE:", + full_gate, + ) + + print("=" * 92) + + if args.output_json: + output_path = Path( + args.output_json + ) + + output_path.parent.mkdir( + parents=True, + exist_ok=True, + ) + + output_path.write_text( + json.dumps( + summary, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + print( + "result json:", + output_path, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/evaluate_cortex_prime_verifier_development.py b/tools/evaluate_cortex_prime_verifier_development.py new file mode 100755 index 0000000..5a7bde7 --- /dev/null +++ b/tools/evaluate_cortex_prime_verifier_development.py @@ -0,0 +1,429 @@ +#!/usr/bin/env python3 +"""Development-only evaluation of Cortex prediction of PRIME verdicts. + +This evaluates whether the neural cortex can predict PRIME's behaviour. +It does not grant the cortex verifier authority. + +HELDOUT IS FORBIDDEN. +""" + +from __future__ import annotations + +import argparse +from collections import Counter +import json +from pathlib import Path + +import torch + +from core.cortex import ( + BPETokenizer, + CortexV1Config, + NativeCortexV1, +) + +from core.cortex.prime_bridge import ( + VERIFIER_LABELS, +) + +from core.cortex.verifier_prompt import ( + format_verifier_prompt, +) + + +def load_model( + checkpoint_path: Path, + device: str, +): + checkpoint = torch.load( + checkpoint_path, + map_location=device, + weights_only=False, + ) + + config = CortexV1Config( + **checkpoint["config"] + ) + + tokenizer = BPETokenizer( + checkpoint["tokenizer"] + ) + + model = NativeCortexV1( + config + ).to(device) + + model.load_state_dict( + checkpoint["model"] + ) + + model.eval() + + return ( + checkpoint, + model, + tokenizer, + ) + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--checkpoint", + required=True, + ) + + parser.add_argument( + "--development", + default=( + "data/native_cortex/" + "prime_bridge/curriculum/" + "development.jsonl" + ), + ) + + parser.add_argument( + "--max-length", + type=int, + default=192, + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + development_path = Path( + args.development + ) + + if "heldout" in str( + development_path + ).lower(): + raise RuntimeError( + "HELDOUT EVALUATION IS FORBIDDEN" + ) + + checkpoint_path = Path( + args.checkpoint + ) + + ( + checkpoint, + model, + tokenizer, + ) = load_model( + checkpoint_path, + args.device, + ) + + label_count = len( + VERIFIER_LABELS + ) + + confusion = [ + [ + 0 + for _ in range( + label_count + ) + ] + for _ in range( + label_count + ) + ] + + class_total = Counter() + class_correct = Counter() + + total = 0 + correct = 0 + + prediction_counts = Counter() + + with torch.no_grad(): + with development_path.open( + "r", + encoding="utf-8", + ) as handle: + for line in handle: + if not line.strip(): + continue + + record = json.loads( + line + ) + + prompt = ( + format_verifier_prompt( + record + ) + ) + + ids = tokenizer.encode( + prompt, + add_bos=True, + add_eos=True, + ) + + ids = ids[ + -args.max_length: + ] + + x = torch.tensor( + ids, + dtype=torch.long, + device=args.device, + ).unsqueeze(0) + + result = model( + x + ) + + logits = ( + result + .verifier_logits[ + 0, + -1, + : + ] + ) + + prediction = int( + torch.argmax( + logits + ).item() + ) + + target = int( + record[ + "verifier_label_id" + ] + ) + + if not ( + 0 + <= target + < label_count + ): + raise RuntimeError( + "invalid target label" + ) + + confusion[ + target + ][ + prediction + ] += 1 + + class_total[ + target + ] += 1 + + prediction_counts[ + prediction + ] += 1 + + total += 1 + + if ( + prediction + == target + ): + correct += 1 + + class_correct[ + target + ] += 1 + + accuracy = ( + correct / total + if total + else 0.0 + ) + + per_class = {} + + for index, label in enumerate( + VERIFIER_LABELS + ): + denominator = ( + class_total[ + index + ] + ) + + per_class[ + label + ] = ( + class_correct[index] + / denominator + if denominator + else 0.0 + ) + + macro_accuracy = ( + sum( + per_class.values() + ) + / label_count + ) + + minimum_class_accuracy = min( + per_class.values() + ) + + print("=" * 92) + print( + "MEGA PRIME — CORTEX PRIME " + "VERIFIER DEVELOPMENT" + ) + print("=" * 92) + + print( + "checkpoint:", + checkpoint_path, + ) + + print( + "checkpoint format:", + checkpoint.get( + "format", + "unknown", + ), + ) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "records:", + total, + ) + + print( + "authority:", + "NONE", + ) + + print() + + print( + "accuracy:", + f"{accuracy:.4f}", + ) + + print( + "macro accuracy:", + f"{macro_accuracy:.4f}", + ) + + print( + "minimum class accuracy:", + f"{minimum_class_accuracy:.4f}", + ) + + print() + + print( + "=== PER CLASS ===" + ) + + for label in ( + VERIFIER_LABELS + ): + print( + f"{label:8s}", + f"{per_class[label]:.4f}", + ) + + print() + + print( + "=== PREDICTION DISTRIBUTION ===" + ) + + for index, label in enumerate( + VERIFIER_LABELS + ): + print( + f"{label:8s}", + prediction_counts[ + index + ], + ) + + print() + + print( + "=== CONFUSION MATRIX ===" + ) + + print( + "true\\pred", + *[ + f"{label[:4]:>5s}" + for label in VERIFIER_LABELS + ], + ) + + for index, label in enumerate( + VERIFIER_LABELS + ): + print( + f"{label[:8]:>8s}", + *[ + f"{value:5d}" + for value + in confusion[ + index + ] + ], + ) + + print() + + chance = ( + 1.0 / label_count + ) + + print( + "balanced chance:", + f"{chance:.4f}", + ) + + print() + + print( + "PRE-REGISTERED DEVELOPMENT GATES" + ) + + print( + "overall > 0.60:", + accuracy > 0.60, + ) + + print( + "macro > 0.60:", + macro_accuracy > 0.60, + ) + + print( + "every class > 0.35:", + minimum_class_accuracy > 0.35, + ) + + print("=" * 92) + + +if __name__ == "__main__": + main() diff --git a/tools/evaluate_native_cortex_development.py b/tools/evaluate_native_cortex_development.py new file mode 100755 index 0000000..1a2747e --- /dev/null +++ b/tools/evaluate_native_cortex_development.py @@ -0,0 +1,466 @@ +#!/usr/bin/env python3 +"""Development-only Native Cortex evaluator. + +HELDOUT IS EXPLICITLY FORBIDDEN. +""" + +from __future__ import annotations + +import argparse +import json +import math +from pathlib import Path + +import torch +import torch.nn.functional as F + +from core.cortex import ( + BPETokenizer, + CortexConfig, + NativeCortex, +) + + +def evaluate( + model, + tokenizer, + path, + *, + device, + reset_every_token, +): + total_loss = 0.0 + total_tokens = 0 + total_bytes = 0 + + expert_counts = [ + [ + 0 + for _ in range( + model.config.experts + ) + ] + for _ in range( + model.config.layers + ) + ] + + expert_confidence = [ + 0.0 + for _ in range( + model.config.layers + ) + ] + + gate_erase = [ + 0.0 + for _ in range( + model.config.layers + ) + ] + + gate_write = [ + 0.0 + for _ in range( + model.config.layers + ) + ] + + state_norm = [ + 0.0 + for _ in range( + model.config.layers + ) + ] + + telemetry_steps = 0 + + with open( + path, + "r", + encoding="utf-8", + ) as handle: + for line in handle: + record = json.loads(line) + + text = record["text"] + + total_bytes += len( + text.encode("utf-8") + ) + + tokens = tokenizer.encode( + text, + add_bos=True, + add_eos=True, + ) + + if len(tokens) < 2: + continue + + states = None + + for index in range( + len(tokens) - 1 + ): + source = torch.tensor( + [tokens[index]], + dtype=torch.long, + device=device, + ) + + target = torch.tensor( + [tokens[index + 1]], + dtype=torch.long, + device=device, + ) + + if reset_every_token: + states = None + + ( + logits, + _, + states, + _, + telemetry, + ) = model.step( + source, + states, + telemetry=True, + ) + + loss = F.cross_entropy( + logits, + target, + reduction="sum", + ) + + total_loss += float( + loss.item() + ) + + total_tokens += 1 + + telemetry_steps += 1 + + for layer, observation in ( + enumerate(telemetry) + ): + expert_counts[ + layer + ][ + observation.selected_expert + ] += 1 + + expert_confidence[ + layer + ] += ( + observation + .expert_probability + ) + + gate_erase[ + layer + ] += ( + observation + .erase_mean + ) + + gate_write[ + layer + ] += ( + observation + .write_mean + ) + + state_norm[ + layer + ] += ( + observation + .recurrent_state_norm + ) + + mean_nll = ( + total_loss + / total_tokens + ) + + bits_per_byte = ( + total_loss + / math.log(2) + / total_bytes + ) + + layers = [] + + for layer in range( + model.config.layers + ): + counts = expert_counts[ + layer + ] + + count_total = sum( + counts + ) + + probabilities = [ + count / count_total + for count in counts + ] + + entropy = -sum( + p * math.log( + p + 1e-12 + ) + for p in probabilities + ) + + normalized_entropy = ( + entropy + / math.log( + model.config.experts + ) + ) + + layers.append( + { + "layer": layer, + "expert_counts": counts, + "expert_shares": ( + probabilities + ), + "max_expert_share": ( + max(probabilities) + ), + "routing_entropy_normalized": ( + normalized_entropy + ), + "mean_router_confidence": ( + expert_confidence[layer] + / telemetry_steps + ), + "mean_erase": ( + gate_erase[layer] + / telemetry_steps + ), + "mean_write": ( + gate_write[layer] + / telemetry_steps + ), + "mean_state_norm": ( + state_norm[layer] + / telemetry_steps + ), + } + ) + + return { + "mode": ( + "RESET" + if reset_every_token + else "NORMAL" + ), + "tokens": total_tokens, + "utf8_bytes": total_bytes, + "cross_entropy_nats": ( + mean_nll + ), + "perplexity": ( + math.exp( + min( + mean_nll, + 50.0, + ) + ) + ), + "bits_per_byte": ( + bits_per_byte + ), + "layers": layers, + } + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--checkpoint", + required=True, + ) + + parser.add_argument( + "--development", + default=( + "data/native_cortex/splits/" + "development.jsonl" + ), + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + if "heldout" in ( + Path( + args.development + ).name.lower() + ): + raise RuntimeError( + "HELDOUT EVALUATION IS NOT AUTHORIZED" + ) + + checkpoint = torch.load( + args.checkpoint, + map_location=args.device, + weights_only=False, + ) + + config = CortexConfig( + **checkpoint["config"] + ) + + tokenizer = BPETokenizer( + checkpoint["tokenizer"] + ) + + model = NativeCortex( + config + ).to( + args.device + ) + + model.load_state_dict( + checkpoint["model"] + ) + + model.eval() + + print("=" * 90) + print( + "MEGA PRIME NATIVE CORTEX — " + "DEVELOPMENT EVALUATION" + ) + print("=" * 90) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "vocab:", + tokenizer.vocab_size, + ) + + print( + "authority:", + "NONE", + ) + + with torch.no_grad(): + normal = evaluate( + model, + tokenizer, + args.development, + device=args.device, + reset_every_token=False, + ) + + reset = evaluate( + model, + tokenizer, + args.development, + device=args.device, + reset_every_token=True, + ) + + print() + print("=== LANGUAGE GENERALISATION ===") + + for row in ( + normal, + reset, + ): + print( + f"{row['mode']:7s}", + ( + f"CE=" + f"{row['cross_entropy_nats']:.4f}" + ), + ( + f"PPL=" + f"{row['perplexity']:.2f}" + ), + ( + f"BPB=" + f"{row['bits_per_byte']:.4f}" + ), + ) + + print() + print( + "RECURRENT BPB GAIN:", + ( + f"{reset['bits_per_byte'] - normal['bits_per_byte']:+.4f}" + ), + ) + + print() + print("=== ROUTING / MEMORY HEALTH ===") + + for layer in ( + normal["layers"] + ): + print( + f"L{layer['layer']}", + ( + "experts=" + + ",".join( + f"{value:.3f}" + for value + in layer[ + "expert_shares" + ] + ) + ), + ( + f"max=" + f"{layer['max_expert_share']:.3f}" + ), + ( + f"H=" + f"{layer['routing_entropy_normalized']:.3f}" + ), + ( + f"conf=" + f"{layer['mean_router_confidence']:.3f}" + ), + ( + f"erase=" + f"{layer['mean_erase']:.4f}" + ), + ( + f"write=" + f"{layer['mean_write']:.4f}" + ), + ( + f"state=" + f"{layer['mean_state_norm']:.3f}" + ), + ) + + print() + print("=" * 90) + + +if __name__ == "__main__": + main() diff --git a/tools/evaluate_native_cortex_v1_development.py b/tools/evaluate_native_cortex_v1_development.py new file mode 100755 index 0000000..eb81112 --- /dev/null +++ b/tools/evaluate_native_cortex_v1_development.py @@ -0,0 +1,677 @@ +#!/usr/bin/env python3 +"""Development-only evaluator for Mega PRIME Native Cortex V1.""" + +from __future__ import annotations + +import argparse +import json +import math +from pathlib import Path + +import torch +import torch.nn.functional as F + +from core.cortex import ( + BPETokenizer, + CortexV1Config, + NativeCortexV1, +) + + +def empty_layer_stats( + layers, + experts, +): + return [ + { + "expert_counts": [ + 0 + for _ in range( + experts + ) + ], + "router_confidence_sum": 0.0, + "router_entropy_sum": 0.0, + "state_norm_sum": 0.0, + "read_norm_sum": 0.0, + "erase_sum": 0.0, + "write_sum": 0.0, + "retention_sum": 0.0, + "attention_entropy_sum": 0.0, + "attention_steps": 0, + "steps": 0, + } + for _ in range( + layers + ) + ] + + +def merge_diagnostics( + totals, + diagnostics, +): + for layer_index, row in enumerate( + diagnostics + ): + target = totals[ + layer_index + ] + + counts = ( + row[ + "expert_counts" + ].tolist() + ) + + for index, value in enumerate( + counts + ): + target[ + "expert_counts" + ][index] += int( + value + ) + + target[ + "router_confidence_sum" + ] += ( + row[ + "router_confidence_sum" + ] + ) + + target[ + "router_entropy_sum" + ] += ( + row[ + "router_entropy_sum" + ] + ) + + target[ + "state_norm_sum" + ] += ( + row[ + "state_norm_sum" + ] + ) + + target[ + "read_norm_sum" + ] += ( + row[ + "read_norm_sum" + ] + ) + + target[ + "erase_sum" + ] += row[ + "erase_sum" + ] + + target[ + "write_sum" + ] += row[ + "write_sum" + ] + + target[ + "retention_sum" + ] += ( + row[ + "retention_sum" + ] + ) + + target[ + "attention_entropy_sum" + ] += ( + row[ + "attention_entropy_sum" + ] + ) + + target[ + "attention_steps" + ] += int( + row[ + "attention_steps" + ] + ) + + target[ + "steps" + ] += int( + row[ + "steps" + ] + ) + + +def evaluate_mode( + model, + tokenizer, + development_path, + *, + device, + reset_recurrence, + disable_attention, + chunk_length=128, +): + total_nll = 0.0 + total_tokens = 0 + total_utf8_bytes = 0 + + layer_totals = ( + empty_layer_stats( + model.config.layers, + model.config.experts, + ) + ) + + with open( + development_path, + "r", + encoding="utf-8", + ) as handle: + for line in handle: + record = json.loads( + line + ) + + text = record[ + "text" + ] + + total_utf8_bytes += len( + text.encode( + "utf-8" + ) + ) + + ids = tokenizer.encode( + text, + add_bos=True, + add_eos=True, + ) + + if len(ids) < 2: + continue + + states = None + + for start in range( + 0, + len(ids) - 1, + chunk_length, + ): + remaining = ( + len(ids) + - 1 + - start + ) + + take = min( + chunk_length, + remaining, + ) + + source_ids = ids[ + start: + start + take + ] + + target_ids = ids[ + start + 1: + start + 1 + take + ] + + if ( + len(source_ids) + != len(target_ids) + ): + raise RuntimeError( + "source/target alignment failure" + ) + + source = torch.tensor( + source_ids, + dtype=torch.long, + device=device, + ).unsqueeze( + 0 + ) + + target = torch.tensor( + target_ids, + dtype=torch.long, + device=device, + ).unsqueeze( + 0 + ) + + result = model( + source, + states, + reset_recurrence=( + reset_recurrence + ), + disable_attention=( + disable_attention + ), + collect_diagnostics=True, + ) + + states = ( + result.states + ) + + loss = F.cross_entropy( + result.logits.reshape( + -1, + tokenizer.vocab_size, + ), + target.reshape( + -1 + ), + reduction="sum", + ) + + total_nll += float( + loss.item() + ) + + total_tokens += ( + target.numel() + ) + + merge_diagnostics( + layer_totals, + result.diagnostics, + ) + + mean_nll = ( + total_nll + / total_tokens + ) + + bits_per_byte = ( + total_nll + / math.log(2) + / total_utf8_bytes + ) + + layers = [] + + for layer_index, stats in enumerate( + layer_totals + ): + total_assignments = sum( + stats[ + "expert_counts" + ] + ) + + shares = [ + ( + count + / total_assignments + ) + if total_assignments + else 0.0 + for count + in stats[ + "expert_counts" + ] + ] + + entropy = -sum( + p + * math.log( + p + 1e-12 + ) + for p in shares + ) + + normalized_entropy = ( + entropy + / math.log( + model.config.experts + ) + if total_assignments + else 0.0 + ) + + steps = max( + stats[ + "steps" + ], + 1, + ) + + attention_steps = max( + stats[ + "attention_steps" + ], + 1, + ) + + layers.append( + { + "layer": ( + layer_index + ), + "expert_shares": ( + shares + ), + "max_expert_share": ( + max(shares) + if shares + else 0.0 + ), + "routing_entropy": ( + normalized_entropy + ), + "router_confidence": ( + stats[ + "router_confidence_sum" + ] + / steps + ), + "state_norm": ( + stats[ + "state_norm_sum" + ] + / steps + ), + "read_norm": ( + stats[ + "read_norm_sum" + ] + / steps + ), + "erase": ( + stats[ + "erase_sum" + ] + / steps + ), + "write": ( + stats[ + "write_sum" + ] + / steps + ), + "retention": ( + stats[ + "retention_sum" + ] + / steps + ), + "attention_entropy": ( + stats[ + "attention_entropy_sum" + ] + / attention_steps + ), + } + ) + + return { + "cross_entropy": ( + mean_nll + ), + "perplexity": math.exp( + min( + mean_nll, + 50.0, + ) + ), + "bits_per_byte": ( + bits_per_byte + ), + "tokens": ( + total_tokens + ), + "utf8_bytes": ( + total_utf8_bytes + ), + "layers": layers, + } + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--checkpoint", + required=True, + ) + + parser.add_argument( + "--development", + default=( + "data/native_cortex/" + "splits/development.jsonl" + ), + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + if ( + "heldout" + in Path( + args.development + ).name.lower() + ): + raise RuntimeError( + "HELDOUT EVALUATION IS FORBIDDEN" + ) + + checkpoint = torch.load( + args.checkpoint, + map_location=args.device, + weights_only=False, + ) + + config = CortexV1Config( + **checkpoint[ + "config" + ] + ) + + tokenizer = BPETokenizer( + checkpoint[ + "tokenizer" + ] + ) + + model = NativeCortexV1( + config + ).to( + args.device + ) + + model.load_state_dict( + checkpoint[ + "model" + ] + ) + + model.eval() + + print("=" * 96) + print( + "MEGA PRIME — NATIVE CORTEX V1 DEVELOPMENT" + ) + print("=" * 96) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "authority:", + "NONE", + ) + + modes = { + "NORMAL": ( + False, + False, + ), + "RESET_RECURRENCE": ( + True, + False, + ), + "NO_LOCAL_ATTENTION": ( + False, + True, + ), + } + + results = {} + + with torch.no_grad(): + for name, ( + reset, + no_attention, + ) in modes.items(): + print() + print( + "running:", + name, + ) + + results[name] = ( + evaluate_mode( + model, + tokenizer, + args.development, + device=args.device, + reset_recurrence=( + reset + ), + disable_attention=( + no_attention + ), + ) + ) + + print() + print("=== LANGUAGE ===") + + for name, result in ( + results.items() + ): + print( + f"{name:20s}", + ( + f"CE=" + f"{result['cross_entropy']:.4f}" + ), + ( + f"PPL=" + f"{result['perplexity']:.2f}" + ), + ( + f"BPB=" + f"{result['bits_per_byte']:.4f}" + ), + ) + + normal = results[ + "NORMAL" + ] + + print() + print( + "RECURRENT BPB CONTRIBUTION:", + ( + f"{results['RESET_RECURRENCE']['bits_per_byte'] - normal['bits_per_byte']:+.4f}" + ), + ) + + print( + "LOCAL ATTENTION BPB CONTRIBUTION:", + ( + f"{results['NO_LOCAL_ATTENTION']['bits_per_byte'] - normal['bits_per_byte']:+.4f}" + ), + ) + + print() + print( + "=== NORMAL ROUTING / MEMORY ===" + ) + + for row in normal[ + "layers" + ]: + print( + f"L{row['layer']}", + ( + "experts=" + + ",".join( + f"{value:.3f}" + for value + in row[ + "expert_shares" + ] + ) + ), + ( + f"max=" + f"{row['max_expert_share']:.3f}" + ), + ( + f"H=" + f"{row['routing_entropy']:.3f}" + ), + ( + f"conf=" + f"{row['router_confidence']:.3f}" + ), + ( + f"state=" + f"{row['state_norm']:.3f}" + ), + ( + f"read=" + f"{row['read_norm']:.3f}" + ), + ( + f"erase=" + f"{row['erase']:.4f}" + ), + ( + f"write=" + f"{row['write']:.4f}" + ), + ( + f"retain=" + f"{row['retention']:.4f}" + ), + ( + f"attnH=" + f"{row['attention_entropy']:.3f}" + ), + ) + + print() + print("=" * 96) + + +if __name__ == "__main__": + main() diff --git a/tools/native_cortex_generate.py b/tools/native_cortex_generate.py new file mode 100755 index 0000000..6366190 --- /dev/null +++ b/tools/native_cortex_generate.py @@ -0,0 +1,391 @@ +#!/usr/bin/env python3 +"""Streaming generation with native TSObs telemetry.""" + +from __future__ import annotations + +import argparse +import hashlib +from pathlib import Path + +import torch + +from core.cortex import ( + ByteTokenizer, + CortexConfig, + NativeCortex, + TSObs, + append_jsonl, +) + + +def sha256_file( + path, +): + digest = hashlib.sha256() + + with open( + path, + "rb", + ) as handle: + for chunk in iter( + lambda: handle.read( + 1024 * 1024 + ), + b"", + ): + digest.update( + chunk + ) + + return digest.hexdigest() + + +def sample_token( + logits, + *, + temperature, + top_k, +): + logits = ( + logits + / max( + temperature, + 1e-5, + ) + ) + + if top_k > 0: + values, indices = ( + torch.topk( + logits, + min( + top_k, + logits.shape[-1], + ), + ) + ) + + probabilities = ( + torch.softmax( + values, + dim=-1, + ) + ) + + selected = ( + torch.multinomial( + probabilities, + num_samples=1, + ) + ) + + return indices[ + selected + ].item() + + probabilities = ( + torch.softmax( + logits, + dim=-1, + ) + ) + + return torch.multinomial( + probabilities, + num_samples=1, + ).item() + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--checkpoint", + required=True, + ) + + parser.add_argument( + "--prompt", + required=True, + ) + + parser.add_argument( + "--tokens", + type=int, + default=200, + ) + + parser.add_argument( + "--temperature", + type=float, + default=0.8, + ) + + parser.add_argument( + "--top-k", + type=int, + default=32, + ) + + parser.add_argument( + "--telemetry", + default=( + "/tmp/native-cortex-tsobs.jsonl" + ), + ) + + parser.add_argument( + "--seed", + type=int, + default=260002, + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + torch.manual_seed( + args.seed + ) + + checkpoint = torch.load( + args.checkpoint, + map_location=( + args.device + ), + weights_only=False, + ) + + config = CortexConfig( + **checkpoint[ + "config" + ] + ) + + tokenizer = ( + ByteTokenizer() + ) + + model = NativeCortex( + config + ).to( + args.device + ) + + model.load_state_dict( + checkpoint[ + "model" + ] + ) + + model.eval() + + model_id = ( + sha256_file( + args.checkpoint + )[ + :16 + ] + ) + + telemetry_path = Path( + args.telemetry + ) + + if telemetry_path.exists(): + telemetry_path.unlink() + + prompt_tokens = ( + tokenizer.encode( + args.prompt, + add_bos=True, + add_eos=False, + ) + ) + + states = None + + logits = None + + sequence = 0 + + with torch.no_grad(): + for token in ( + prompt_tokens + ): + token_tensor = torch.tensor( + [ + token + ], + dtype=torch.long, + device=( + args.device + ), + ) + + ( + logits, + verifier_logits, + states, + _, + _, + ) = model.step( + token_tensor, + states, + telemetry=False, + ) + + generated = [] + + for _ in range( + args.tokens + ): + next_token = sample_token( + logits[ + 0 + ], + temperature=( + args.temperature + ), + top_k=( + args.top_k + ), + ) + + if ( + next_token + == tokenizer.EOS + ): + break + + generated.append( + next_token + ) + + token_tensor = torch.tensor( + [ + next_token + ], + dtype=torch.long, + device=args.device, + ) + + with torch.no_grad(): + ( + logits, + verifier_logits, + states, + _, + layer_observations, + ) = model.step( + token_tensor, + states, + telemetry=True, + ) + + verifier_probabilities = ( + torch.softmax( + verifier_logits[ + 0 + ], + dim=-1, + ) + ) + + verifier_confidence, verifier_index = ( + verifier_probabilities.max( + dim=-1 + ) + ) + + top_values, top_indices = ( + torch.topk( + torch.softmax( + logits[ + 0 + ], + dim=-1, + ), + 5, + ) + ) + + observation = TSObs( + sequence=sequence, + model_id=( + model_id + ), + token_id=( + next_token + ), + token_label=( + tokenizer.token_label( + next_token + ) + ), + authority="NONE", + verifier_prediction=( + int( + verifier_index.item() + ) + ), + verifier_confidence=( + float( + verifier_confidence.item() + ) + ), + top_output_tokens=tuple( + ( + int( + token.item() + ), + float( + probability.item() + ), + ) + for probability, token + in zip( + top_values, + top_indices, + ) + ), + layers=tuple( + layer_observations + ), + ) + + append_jsonl( + telemetry_path, + observation, + ) + + sequence += 1 + + print( + args.prompt + + tokenizer.decode( + generated + ) + ) + + print() + print( + "TSObs:", + telemetry_path, + ) + + print( + "model:", + model_id, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/prepare_native_cortex_tokens.py b/tools/prepare_native_cortex_tokens.py new file mode 100755 index 0000000..8e9bcf9 --- /dev/null +++ b/tools/prepare_native_cortex_tokens.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +"""Prepare deterministic BPE token streams for Native Cortex Phase II.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path + +import numpy as np + +from core.cortex import BPETokenizer + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + + with path.open("rb") as handle: + for chunk in iter( + lambda: handle.read(1024 * 1024), + b"", + ): + digest.update(chunk) + + return digest.hexdigest() + + +def prepare_split( + source: Path, + destination: Path, + tokenizer: BPETokenizer, +): + if "heldout" in source.name.lower(): + raise RuntimeError( + "Phase II preparation refuses held-out data" + ) + + encoded_documents = [] + + document_count = 0 + token_count = 0 + utf8_bytes = 0 + + with source.open( + "r", + encoding="utf-8", + ) as handle: + for line in handle: + record = json.loads(line) + + text = record["text"] + + tokens = tokenizer.encode( + text, + add_bos=True, + add_eos=True, + ) + + encoded_documents.append( + np.asarray( + tokens, + dtype=np.uint16, + ) + ) + + document_count += 1 + token_count += len(tokens) + utf8_bytes += len( + text.encode("utf-8") + ) + + stream = np.concatenate( + encoded_documents + ) + + stream.tofile( + destination + ) + + return { + "documents": document_count, + "tokens": token_count, + "utf8_bytes": utf8_bytes, + "bytes_on_disk": ( + destination.stat().st_size + ), + "sha256": sha256_file( + destination + ), + } + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--tokenizer", + default=( + "data/native_cortex/tokenizer/" + "tokenizer.json" + ), + ) + + parser.add_argument( + "--splits", + default=( + "data/native_cortex/splits" + ), + ) + + parser.add_argument( + "--output", + default=( + "data/native_cortex/tokens" + ), + ) + + args = parser.parse_args() + + tokenizer = BPETokenizer( + args.tokenizer + ) + + split_root = Path( + args.splits + ) + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + report = { + "format": ( + "mega-prime-native-cortex-" + "token-stream-v1" + ), + "dtype": "uint16", + "vocab_size": ( + tokenizer.vocab_size + ), + "splits": {}, + } + + for split in ( + "train", + "development", + ): + source = ( + split_root + / f"{split}.jsonl" + ) + + destination = ( + output + / f"{split}.bin" + ) + + report["splits"][split] = ( + prepare_split( + source, + destination, + tokenizer, + ) + ) + + manifest = ( + output + / "TOKEN_STREAM_MANIFEST.json" + ) + + manifest.write_text( + json.dumps( + report, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + print( + json.dumps( + report, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tools/tokenizer_efficiency.py b/tools/tokenizer_efficiency.py new file mode 100644 index 0000000..328e03f --- /dev/null +++ b/tools/tokenizer_efficiency.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python3 +"""Compare byte and BPE sequence cost on DEVELOPMENT prose.""" + +from __future__ import annotations + +import json + +from core.cortex import ( + BPETokenizer, + ByteTokenizer, +) + + +DEVELOPMENT_PATH = ( + "data/native_cortex/splits/" + "development.jsonl" +) + +TOKENIZER_PATH = ( + "data/native_cortex/tokenizer/" + "tokenizer.json" +) + + +byte_tokenizer = ( + ByteTokenizer() +) + +bpe_tokenizer = ( + BPETokenizer( + TOKENIZER_PATH + ) +) + +documents = 0 + +utf8_bytes = 0 + +byte_tokens = 0 + +bpe_tokens = 0 + +roundtrip_failures = 0 + + +with open( + DEVELOPMENT_PATH, + "r", + encoding="utf-8", +) as handle: + for line in handle: + row = json.loads(line) + + text = row["text"] + + encoded_byte = ( + byte_tokenizer.encode( + text + ) + ) + + encoded_bpe = ( + bpe_tokenizer.encode( + text + ) + ) + + decoded_bpe = ( + bpe_tokenizer.decode( + encoded_bpe + ) + ) + + if decoded_bpe != text: + roundtrip_failures += 1 + + documents += 1 + + utf8_bytes += len( + text.encode( + "utf-8" + ) + ) + + byte_tokens += len( + encoded_byte + ) + + bpe_tokens += len( + encoded_bpe + ) + + +print("=" * 78) + +print( + "MEGA PRIME — TOKENIZER EFFICIENCY" +) + +print("=" * 78) + +print( + "development documents:", + documents, +) + +print( + "UTF-8 bytes:", + utf8_bytes, +) + +print( + "byte tokens:", + byte_tokens, +) + +print( + "BPE tokens:", + bpe_tokens, +) + +print( + "byte tokens / UTF-8 byte:", + byte_tokens / utf8_bytes, +) + +print( + "BPE tokens / UTF-8 byte:", + bpe_tokens / utf8_bytes, +) + +print( + "sequence reduction:", + byte_tokens / bpe_tokens, + "x", +) + +print( + "effective context multiplier:", + byte_tokens / bpe_tokens, + "x", +) + +print( + "BPE roundtrip failures:", + roundtrip_failures, +) + +print("=" * 78) diff --git a/tools/train_cortex_prime_bridge.py b/tools/train_cortex_prime_bridge.py new file mode 100755 index 0000000..5372b31 --- /dev/null +++ b/tools/train_cortex_prime_bridge.py @@ -0,0 +1,866 @@ +#!/usr/bin/env python3 +"""Train Native Cortex V1 from PRIME semantic and verifier feedback. + +The cortex learns to predict PRIME. +It never becomes PRIME's authority. +""" + +from __future__ import annotations + +import argparse +from collections import Counter +from dataclasses import asdict +import hashlib +import json +from pathlib import Path +import random +import time + +import numpy as np +import torch +import torch.nn.functional as F + +from core.cortex import ( + BPETokenizer, + CortexV1Config, + NativeCortexV1, +) + +from core.cortex.prime_bridge import ( + VERIFIER_LABELS, +) + +from core.cortex.verifier_prompt import ( + format_verifier_prompt, +) + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + + with path.open("rb") as handle: + for chunk in iter( + lambda: handle.read(1024 * 1024), + b"", + ): + digest.update(chunk) + + return digest.hexdigest() + + +def load_jsonl(path: str): + with open( + path, + "r", + encoding="utf-8", + ) as handle: + return [ + json.loads(line) + for line in handle + if line.strip() + ] + + +def lm_batch( + stream, + *, + batch_size, + sequence_length, + rng, + device, +): + rows = [] + + maximum = ( + len(stream) + - sequence_length + - 1 + ) + + for _ in range(batch_size): + start = rng.randrange( + 0, + maximum, + ) + + row = np.asarray( + stream[ + start: + start + sequence_length + 1 + ], + dtype=np.int64, + ) + + rows.append( + torch.from_numpy(row) + ) + + batch = torch.stack( + rows + ).to(device) + + return ( + batch[:, :-1], + batch[:, 1:], + ) + + +def semantic_example( + tokenizer, + record, + *, + max_length, + device, +): + prefix_text = ( + "SOURCE:\n" + + str(record["source_text"]) + + "\n\nTSIR_PROPOSAL:\n" + ) + + target_text = str( + record["proposal_text"] + ) + + target = tokenizer.encode( + target_text, + add_bos=False, + add_eos=True, + ) + + # Avoid examples whose answer alone fills the context. + if len(target) >= max_length - 8: + return None + + prefix = tokenizer.encode( + prefix_text, + add_bos=True, + add_eos=False, + ) + + available_prefix = ( + max_length + - len(target) + ) + + if len(prefix) > available_prefix: + prefix = ( + [tokenizer.BOS] + + prefix[ + -(available_prefix - 1): + ] + ) + + tokens = ( + prefix + + target + ) + + x = torch.tensor( + tokens[:-1], + dtype=torch.long, + device=device, + ).unsqueeze(0) + + y = torch.tensor( + tokens[1:], + dtype=torch.long, + device=device, + ).unsqueeze(0) + + mask = torch.zeros_like( + y, + dtype=torch.bool, + ) + + first_target_prediction = ( + len(prefix) + - 1 + ) + + mask[ + :, + first_target_prediction: + ] = True + + return ( + x, + y, + mask, + ) + + +def verifier_example( + tokenizer, + record, + *, + max_length, + device, +): + text = format_verifier_prompt( + record + ) + + ids = tokenizer.encode( + text, + add_bos=True, + add_eos=True, + ) + + ids = ids[ + -max_length: + ] + + x = torch.tensor( + ids, + dtype=torch.long, + device=device, + ).unsqueeze(0) + + label = int( + record[ + "verifier_label_id" + ] + ) + + return ( + x, + label, + ) + + +def router_regularizer(result): + return ( + 0.025 + * result.router_balance_loss + + 0.001 + * result.router_z_loss + - 0.002 + * result.router_entropy_normalized + ) + + +def save_checkpoint( + path, + *, + model, + optimizer, + config, + tokenizer_path, + base_checkpoint_hash, + step, +): + torch.save( + { + "format": ( + "mega-prime-cortex-bridge-v1" + ), + "step": step, + "config": asdict( + config + ), + "model": model.state_dict(), + "optimizer": ( + optimizer.state_dict() + ), + "tokenizer": str( + tokenizer_path + ), + "base_checkpoint_sha256": ( + base_checkpoint_hash + ), + "authority": "NONE", + }, + path, + ) + + return sha256_file( + path + ) + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--checkpoint", + default=( + "artifacts/native_cortex/v1/" + "cortex-v1-final.pt" + ), + ) + + parser.add_argument( + "--semantic", + default=( + "data/native_cortex/" + "prime_bridge/train/" + "semantic.jsonl" + ), + ) + + parser.add_argument( + "--verifier", + default=( + "data/native_cortex/" + "prime_bridge/curriculum/" + "train.jsonl" + ), + ) + + parser.add_argument( + "--lm-stream", + default=( + "data/native_cortex/" + "tokens/train.bin" + ), + ) + + parser.add_argument( + "--output", + default=( + "artifacts/native_cortex/" + "prime-bridge-v1" + ), + ) + + parser.add_argument( + "--steps", + type=int, + default=2000, + ) + + parser.add_argument( + "--max-length", + type=int, + default=192, + ) + + parser.add_argument( + "--learning-rate", + type=float, + default=8e-5, + ) + + parser.add_argument( + "--seed", + type=int, + default=26082301, + ) + + parser.add_argument( + "--log-every", + type=int, + default=25, + ) + + parser.add_argument( + "--save-every", + type=int, + default=500, + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + random.seed(args.seed) + torch.manual_seed(args.seed) + + rng = random.Random( + args.seed + ) + + device = args.device + + checkpoint_path = Path( + args.checkpoint + ) + + checkpoint = torch.load( + checkpoint_path, + map_location=device, + weights_only=False, + ) + + config = CortexV1Config( + **checkpoint["config"] + ) + + tokenizer_path = Path( + checkpoint["tokenizer"] + ) + + tokenizer = BPETokenizer( + str(tokenizer_path) + ) + + model = NativeCortexV1( + config + ).to(device) + + model.load_state_dict( + checkpoint["model"] + ) + + semantic_records = load_jsonl( + args.semantic + ) + + verifier_records = load_jsonl( + args.verifier + ) + + if not semantic_records: + raise RuntimeError( + "semantic supervision is empty" + ) + + if not verifier_records: + raise RuntimeError( + "verifier curriculum is empty" + ) + + label_counts = Counter( + int( + row["verifier_label_id"] + ) + for row in verifier_records + ) + + expected_labels = set( + range( + len(VERIFIER_LABELS) + ) + ) + + if set(label_counts) != expected_labels: + raise RuntimeError( + "verifier curriculum does not " + "contain every verdict class: " + + str(label_counts) + ) + + class_weights = torch.tensor( + [ + len(verifier_records) + / ( + len(VERIFIER_LABELS) + * label_counts[index] + ) + for index in range( + len(VERIFIER_LABELS) + ) + ], + dtype=torch.float32, + device=device, + ) + + stream = np.memmap( + args.lm_stream, + dtype=np.uint16, + mode="r", + ) + + optimizer = torch.optim.AdamW( + model.parameters(), + lr=args.learning_rate, + betas=(0.9, 0.95), + weight_decay=0.01, + ) + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + base_hash = sha256_file( + checkpoint_path + ) + + print("=" * 92) + print( + "MEGA PRIME — CORTEX <-> PRIME TRAINING" + ) + print("=" * 92) + + print( + "device:", + device, + ) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "base checkpoint:", + base_hash, + ) + + print( + "semantic records:", + len(semantic_records), + ) + + print( + "verifier records:", + len(verifier_records), + ) + + print( + "verifier labels:", + { + VERIFIER_LABELS[index]: + label_counts[index] + for index in range( + len(VERIFIER_LABELS) + ) + }, + ) + + print( + "class weights:", + [ + round( + float(value), + 4, + ) + for value + in class_weights + ], + ) + + print( + "task schedule:", + "50% LM / 30% semantics / 20% verifier", + ) + + print( + "authority:", + "NONE", + ) + + print("=" * 92) + + model.train() + + accumulators = { + "lm": [], + "semantic": [], + "verifier": [], + } + + started = ( + time.perf_counter() + ) + + for step in range( + 1, + args.steps + 1, + ): + slot = ( + step - 1 + ) % 10 + + optimizer.zero_grad( + set_to_none=True + ) + + if slot < 5: + task = "lm" + + x, y = lm_batch( + stream, + batch_size=2, + sequence_length=128, + rng=rng, + device=device, + ) + + result = model( + x + ) + + task_loss = ( + F.cross_entropy( + result.logits.reshape( + -1, + config.vocab_size, + ), + y.reshape(-1), + ) + ) + + elif slot < 8: + task = "semantic" + + example = None + + attempts = 0 + + while ( + example is None + ): + attempts += 1 + + if attempts > 100: + raise RuntimeError( + "could not construct " + "semantic example" + ) + + record = rng.choice( + semantic_records + ) + + example = ( + semantic_example( + tokenizer, + record, + max_length=( + args.max_length + ), + device=device, + ) + ) + + x, y, mask = example + + result = model( + x + ) + + selected_logits = ( + result.logits[ + mask + ] + ) + + selected_targets = ( + y[ + mask + ] + ) + + task_loss = ( + F.cross_entropy( + selected_logits, + selected_targets, + ) + ) + + else: + task = "verifier" + + record = rng.choice( + verifier_records + ) + + x, label = ( + verifier_example( + tokenizer, + record, + max_length=( + args.max_length + ), + device=device, + ) + ) + + result = model( + x + ) + + verifier_logits = ( + result.verifier_logits[ + :, + -1, + : + ] + ) + + target = torch.tensor( + [label], + dtype=torch.long, + device=device, + ) + + task_loss = ( + F.cross_entropy( + verifier_logits, + target, + weight=( + class_weights + ), + ) + ) + + total_loss = ( + task_loss + + router_regularizer( + result + ) + ) + + total_loss.backward() + + gradient_norm = ( + torch.nn.utils + .clip_grad_norm_( + model.parameters(), + 1.0, + ) + ) + + optimizer.step() + + accumulators[ + task + ].append( + float( + task_loss.item() + ) + ) + + if ( + step == 1 + or step + % args.log_every + == 0 + ): + def mean(name): + values = ( + accumulators[ + name + ] + ) + + if not values: + return float( + "nan" + ) + + return ( + sum(values) + / len(values) + ) + + elapsed = ( + time.perf_counter() + - started + ) + + print( + f"step={step:6d}", + f"lm={mean('lm'):.4f}", + ( + "semantic=" + f"{mean('semantic'):.4f}" + ), + ( + "verifier=" + f"{mean('verifier'):.4f}" + ), + ( + "H=" + f"{result.router_entropy_normalized.item():.3f}" + ), + ( + "grad=" + f"{float(gradient_norm):.3f}" + ), + ( + "elapsed=" + f"{elapsed:.0f}s" + ), + ) + + accumulators = { + "lm": [], + "semantic": [], + "verifier": [], + } + + if ( + step + % args.save_every + == 0 + ): + path = ( + output + / ( + "cortex-prime-step-" + f"{step:06d}.pt" + ) + ) + + digest = save_checkpoint( + path, + model=model, + optimizer=optimizer, + config=config, + tokenizer_path=( + tokenizer_path + ), + base_checkpoint_hash=( + base_hash + ), + step=step, + ) + + print( + "checkpoint:", + path, + ) + + print( + "sha256:", + digest, + ) + + final_path = ( + output + / "cortex-prime-final.pt" + ) + + digest = save_checkpoint( + final_path, + model=model, + optimizer=optimizer, + config=config, + tokenizer_path=( + tokenizer_path + ), + base_checkpoint_hash=( + base_hash + ), + step=args.steps, + ) + + print() + print( + "final checkpoint:", + final_path, + ) + + print( + "final sha256:", + digest, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/train_native_cortex.py b/tools/train_native_cortex.py new file mode 100755 index 0000000..3cdb3c3 --- /dev/null +++ b/tools/train_native_cortex.py @@ -0,0 +1,715 @@ +#!/usr/bin/env python3 +"""Train Mega PRIME Native Cortex on provenance-bound prose.""" + +from __future__ import annotations + +import argparse +from dataclasses import asdict +import hashlib +import json +from pathlib import Path +import random +import time + +import torch +import torch.nn.functional as F + +from core.cortex import ( + ByteTokenizer, + CortexConfig, + NativeCortex, +) + + +TEXT_EXTENSIONS = { + ".txt", + ".md", +} + + +def sha256_file( + path: Path, +) -> str: + digest = hashlib.sha256() + + with path.open( + "rb" + ) as handle: + for chunk in iter( + lambda: handle.read( + 1024 * 1024 + ), + b"", + ): + digest.update( + chunk + ) + + return digest.hexdigest() + + +def discover_files( + inputs, +): + files = [] + + for raw in inputs: + path = Path( + raw + ) + + if path.is_file(): + files.append( + path + ) + + elif path.is_dir(): + files.extend( + candidate + for candidate + in path.rglob("*") + if ( + candidate.is_file() + and candidate.suffix.lower() + in TEXT_EXTENSIONS + ) + ) + + else: + raise FileNotFoundError( + path + ) + + unique = sorted( + { + path.resolve() + for path in files + } + ) + + if not unique: + raise RuntimeError( + "no prose files discovered" + ) + + return unique + + +def build_corpus( + paths, + tokenizer, +): + tokens = [] + + provenance = [] + + for path in paths: + text = path.read_text( + encoding="utf-8", + errors="replace", + ) + + encoded = ( + tokenizer.encode( + text, + add_bos=True, + add_eos=True, + ) + ) + + tokens.extend( + encoded + ) + + provenance.append( + { + "path": str( + path + ), + "sha256": ( + sha256_file( + path + ) + ), + "characters": ( + len(text) + ), + "tokens": ( + len(encoded) + ), + } + ) + + return ( + torch.tensor( + tokens, + dtype=torch.long, + ), + provenance, + ) + + +def sample_batch( + corpus, + *, + batch_size, + sequence_length, + generator, + device, +): + maximum = ( + corpus.numel() + - sequence_length + - 1 + ) + + if maximum <= 0: + raise RuntimeError( + "corpus smaller than one sequence" + ) + + starts = torch.randint( + 0, + maximum, + ( + batch_size, + ), + generator=generator, + ) + + offsets = torch.arange( + sequence_length + 1 + ) + + indices = ( + starts[:, None] + + offsets[None, :] + ) + + batch = corpus[ + indices + ].to( + device + ) + + return ( + batch[ + :, + :-1, + ], + batch[ + :, + 1:, + ], + ) + + +def save_checkpoint( + path, + *, + model, + optimizer, + config, + step, + provenance, +): + payload = { + "format": ( + "mega-prime-native-cortex-v0" + ), + "step": step, + "config": ( + asdict( + config + ) + ), + "model": ( + model.state_dict() + ), + "optimizer": ( + optimizer.state_dict() + ), + "provenance": ( + provenance + ), + } + + torch.save( + payload, + path, + ) + + digest = sha256_file( + Path( + path + ) + ) + + Path( + str(path) + + ".sha256" + ).write_text( + ( + f"{digest} " + f"{Path(path).name}\n" + ), + encoding="utf-8", + ) + + return digest + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--paths", + nargs="+", + required=True, + ) + + parser.add_argument( + "--output", + default=( + "artifacts/native_cortex" + ), + ) + + parser.add_argument( + "--steps", + type=int, + default=1000, + ) + + parser.add_argument( + "--batch-size", + type=int, + default=8, + ) + + parser.add_argument( + "--sequence-length", + type=int, + default=96, + ) + + parser.add_argument( + "--learning-rate", + type=float, + default=3e-4, + ) + + parser.add_argument( + "--seed", + type=int, + default=260001, + ) + + parser.add_argument( + "--log-every", + type=int, + default=25, + ) + + parser.add_argument( + "--save-every", + type=int, + default=250, + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + random.seed( + args.seed + ) + + torch.manual_seed( + args.seed + ) + + if ( + torch.cuda.is_available() + and args.device.startswith( + "cuda" + ) + ): + torch.cuda.manual_seed_all( + args.seed + ) + + tokenizer = ( + ByteTokenizer() + ) + + paths = discover_files( + args.paths + ) + + corpus, provenance = ( + build_corpus( + paths, + tokenizer, + ) + ) + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + ( + output + / "provenance.json" + ).write_text( + json.dumps( + provenance, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + config = CortexConfig( + vocab_size=( + tokenizer.vocab_size + ), + d_model=96, + layers=3, + memory_heads=4, + experts=4, + expert_hidden=192, + dropout=0.0, + ) + + model = NativeCortex( + config + ).to( + args.device + ) + + optimizer = ( + torch.optim.AdamW( + model.parameters(), + lr=( + args.learning_rate + ), + weight_decay=0.01, + ) + ) + + generator = ( + torch.Generator( + device="cpu" + ) + ) + + generator.manual_seed( + args.seed + ) + + telemetry_path = ( + output + / "training_telemetry.jsonl" + ) + + print( + "device:", + args.device, + ) + + print( + "files:", + len(paths), + ) + + print( + "corpus tokens:", + corpus.numel(), + ) + + print( + "parameters:", + model.parameter_count(), + ) + + print( + "effective architecture:", + ( + "ternary-delta-recurrent-" + "sparse-moe" + ), + ) + + model.train() + + interval_start = ( + time.perf_counter() + ) + + interval_tokens = 0 + + for step in range( + 1, + args.steps + 1, + ): + x, y = sample_batch( + corpus, + batch_size=( + args.batch_size + ), + sequence_length=( + args.sequence_length + ), + generator=generator, + device=( + args.device + ), + ) + + optimizer.zero_grad( + set_to_none=True + ) + + output_batch = model( + x + ) + + language_loss = ( + F.cross_entropy( + output_batch.logits.reshape( + -1, + tokenizer.vocab_size, + ), + y.reshape( + -1 + ), + ) + ) + + auxiliary_loss = ( + output_batch.auxiliary_loss + ) + + loss = ( + language_loss + + 0.01 + * auxiliary_loss + ) + + loss.backward() + + torch.nn.utils.clip_grad_norm_( + model.parameters(), + 1.0, + ) + + optimizer.step() + + interval_tokens += ( + x.numel() + ) + + if ( + step + % args.log_every + == 0 + or step == 1 + ): + now = ( + time.perf_counter() + ) + + elapsed = max( + now + - interval_start, + 1e-9, + ) + + tokens_per_second = ( + interval_tokens + / elapsed + ) + + with torch.no_grad(): + probe = model( + x[ + :1, + :min( + 16, + x.shape[1], + ), + ], + telemetry=True, + ) + + last_layers = ( + probe.telemetry[ + -1 + ] + ) + + telemetry_row = { + "step": step, + "language_loss": ( + float( + language_loss + .detach() + .cpu() + .item() + ) + ), + "auxiliary_loss": ( + float( + auxiliary_loss + .detach() + .cpu() + .item() + ) + ), + "tokens_per_second": ( + tokens_per_second + ), + "layers": [ + { + "layer": ( + row.layer + ), + "state_norm": ( + row.recurrent_state_norm + ), + "read_norm": ( + row.read_norm + ), + "erase_mean": ( + row.erase_mean + ), + "write_mean": ( + row.write_mean + ), + "expert": ( + row.selected_expert + ), + "expert_probability": ( + row.expert_probability + ), + } + for row in ( + last_layers + ) + ], + } + + with telemetry_path.open( + "a", + encoding="utf-8", + ) as handle: + handle.write( + json.dumps( + telemetry_row, + sort_keys=True, + ) + ) + + handle.write( + "\n" + ) + + print( + f"step={step:6d}", + ( + f"loss=" + f"{language_loss.item():.4f}" + ), + ( + f"moe=" + f"{auxiliary_loss.item():.4f}" + ), + ( + f"tok/s=" + f"{tokens_per_second:.0f}" + ), + ) + + interval_start = ( + now + ) + + interval_tokens = 0 + + if ( + step + % args.save_every + == 0 + ): + checkpoint = ( + output + / ( + f"cortex-step-" + f"{step:06d}.pt" + ) + ) + + digest = ( + save_checkpoint( + checkpoint, + model=model, + optimizer=optimizer, + config=config, + step=step, + provenance=( + provenance + ), + ) + ) + + print( + "checkpoint:", + checkpoint, + ) + + print( + "sha256:", + digest, + ) + + final_path = ( + output + / "cortex-final.pt" + ) + + digest = save_checkpoint( + final_path, + model=model, + optimizer=optimizer, + config=config, + step=args.steps, + provenance=provenance, + ) + + print() + print( + "final checkpoint:", + final_path, + ) + + print( + "final sha256:", + digest, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/train_native_cortex_phase2.py b/tools/train_native_cortex_phase2.py new file mode 100755 index 0000000..d5f82b4 --- /dev/null +++ b/tools/train_native_cortex_phase2.py @@ -0,0 +1,453 @@ +#!/usr/bin/env python3 +"""Train Native Cortex Phase II on prepared BPE streams.""" + +from __future__ import annotations + +import argparse +from dataclasses import asdict +import hashlib +import json +from pathlib import Path +import time + +import numpy as np +import torch +import torch.nn.functional as F + +from core.cortex import ( + BPETokenizer, + CortexConfig, + NativeCortex, +) + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + + with path.open("rb") as handle: + for chunk in iter( + lambda: handle.read(1024 * 1024), + b"", + ): + digest.update(chunk) + + return digest.hexdigest() + + +def save_checkpoint( + path, + *, + model, + optimizer, + config, + step, + tokenizer_path, +): + payload = { + "format": ( + "mega-prime-native-cortex-p2-v1" + ), + "step": step, + "config": asdict(config), + "model": model.state_dict(), + "optimizer": ( + optimizer.state_dict() + ), + "tokenizer": str( + tokenizer_path + ), + "tokenizer_sha256": ( + sha256_file( + tokenizer_path + ) + ), + "authority": "NONE", + } + + torch.save( + payload, + path, + ) + + return sha256_file( + path + ) + + +def sample_batch( + stream, + *, + batch_size, + sequence_length, + generator, + device, +): + maximum = ( + len(stream) + - sequence_length + - 1 + ) + + starts = torch.randint( + 0, + maximum, + (batch_size,), + generator=generator, + ) + + rows = [] + + for start in starts.tolist(): + row = np.asarray( + stream[ + start: + start + + sequence_length + + 1 + ], + dtype=np.int64, + ) + + rows.append( + torch.from_numpy(row) + ) + + batch = torch.stack( + rows + ).to( + device + ) + + return ( + batch[:, :-1], + batch[:, 1:], + ) + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--train", + default=( + "data/native_cortex/tokens/" + "train.bin" + ), + ) + + parser.add_argument( + "--tokenizer", + default=( + "data/native_cortex/tokenizer/" + "tokenizer.json" + ), + ) + + parser.add_argument( + "--output", + default=( + "artifacts/native_cortex/" + "phase2-bpe-v1" + ), + ) + + parser.add_argument( + "--steps", + type=int, + default=2000, + ) + + parser.add_argument( + "--batch-size", + type=int, + default=8, + ) + + parser.add_argument( + "--sequence-length", + type=int, + default=128, + ) + + parser.add_argument( + "--learning-rate", + type=float, + default=3e-4, + ) + + parser.add_argument( + "--seed", + type=int, + default=260101, + ) + + parser.add_argument( + "--log-every", + type=int, + default=50, + ) + + parser.add_argument( + "--save-every", + type=int, + default=500, + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + torch.manual_seed( + args.seed + ) + + tokenizer_path = Path( + args.tokenizer + ) + + tokenizer = BPETokenizer( + str(tokenizer_path) + ) + + stream = np.memmap( + args.train, + dtype=np.uint16, + mode="r", + ) + + config = CortexConfig( + vocab_size=( + tokenizer.vocab_size + ), + d_model=96, + layers=3, + memory_heads=4, + experts=4, + expert_hidden=192, + dropout=0.0, + ) + + model = NativeCortex( + config + ).to( + args.device + ) + + optimizer = torch.optim.AdamW( + model.parameters(), + lr=args.learning_rate, + weight_decay=0.01, + ) + + generator = torch.Generator() + generator.manual_seed( + args.seed + ) + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + print( + "device:", + args.device, + ) + + print( + "training tokens:", + f"{len(stream):,}", + ) + + print( + "vocab:", + tokenizer.vocab_size, + ) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "architecture:", + ( + "BPE + ternary + delta recurrence " + "+ sparse experts" + ), + ) + + print( + "authority:", + "NONE", + ) + + model.train() + + interval_start = ( + time.perf_counter() + ) + + interval_tokens = 0 + + for step in range( + 1, + args.steps + 1, + ): + x, y = sample_batch( + stream, + batch_size=args.batch_size, + sequence_length=( + args.sequence_length + ), + generator=generator, + device=args.device, + ) + + optimizer.zero_grad( + set_to_none=True + ) + + result = model(x) + + language_loss = ( + F.cross_entropy( + result.logits.reshape( + -1, + tokenizer.vocab_size, + ), + y.reshape(-1), + ) + ) + + loss = ( + language_loss + + 0.01 + * result.auxiliary_loss + ) + + loss.backward() + + torch.nn.utils.clip_grad_norm_( + model.parameters(), + 1.0, + ) + + optimizer.step() + + interval_tokens += ( + x.numel() + ) + + if ( + step == 1 + or step + % args.log_every + == 0 + ): + now = time.perf_counter() + + elapsed = max( + now - interval_start, + 1e-9, + ) + + throughput = ( + interval_tokens + / elapsed + ) + + print( + f"step={step:6d}", + ( + f"loss=" + f"{language_loss.item():.4f}" + ), + ( + f"moe=" + f"{result.auxiliary_loss.item():.4f}" + ), + ( + f"tok/s=" + f"{throughput:.0f}" + ), + ) + + interval_start = now + interval_tokens = 0 + + if ( + step + % args.save_every + == 0 + ): + path = ( + output + / ( + f"cortex-step-" + f"{step:06d}.pt" + ) + ) + + digest = save_checkpoint( + path, + model=model, + optimizer=optimizer, + config=config, + step=step, + tokenizer_path=( + tokenizer_path + ), + ) + + print( + "checkpoint:", + path, + ) + + print( + "sha256:", + digest, + ) + + final = ( + output + / "cortex-final.pt" + ) + + digest = save_checkpoint( + final, + model=model, + optimizer=optimizer, + config=config, + step=args.steps, + tokenizer_path=( + tokenizer_path + ), + ) + + print() + print( + "final checkpoint:", + final, + ) + + print( + "final sha256:", + digest, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/train_native_cortex_v1.py b/tools/train_native_cortex_v1.py new file mode 100755 index 0000000..fd91cdd --- /dev/null +++ b/tools/train_native_cortex_v1.py @@ -0,0 +1,715 @@ +#!/usr/bin/env python3 +"""Train Mega PRIME Native Cortex V1.""" + +from __future__ import annotations + +import argparse +from dataclasses import asdict +import hashlib +import json +from pathlib import Path +import time + +import numpy as np +import torch +import torch.nn.functional as F + +from core.cortex import ( + BPETokenizer, + CortexV1Config, + NativeCortexV1, +) + + +def sha256_file( + path: Path, +) -> str: + digest = hashlib.sha256() + + with path.open( + "rb" + ) as handle: + for chunk in iter( + lambda: handle.read( + 1024 * 1024 + ), + b"", + ): + digest.update( + chunk + ) + + return digest.hexdigest() + + +def sample_batch( + stream, + *, + batch_size, + sequence_length, + generator, + device, +): + maximum = ( + len(stream) + - sequence_length + - 1 + ) + + starts = torch.randint( + 0, + maximum, + ( + batch_size, + ), + generator=generator, + ) + + rows = [] + + for start in ( + starts.tolist() + ): + row = np.asarray( + stream[ + start: + start + + sequence_length + + 1 + ], + dtype=np.int64, + ) + + rows.append( + torch.from_numpy( + row + ) + ) + + batch = torch.stack( + rows + ).to( + device + ) + + return ( + batch[:, :-1], + batch[:, 1:], + ) + + +def save_checkpoint( + path, + *, + model, + optimizer, + config, + step, + tokenizer_path, +): + torch.save( + { + "format": ( + "mega-prime-native-cortex-v1" + ), + "architecture": ( + "multi-timescale-delta-" + "local-attention-top2-moe" + ), + "step": step, + "config": ( + asdict( + config + ) + ), + "model": ( + model.state_dict() + ), + "optimizer": ( + optimizer.state_dict() + ), + "tokenizer": ( + str( + tokenizer_path + ) + ), + "tokenizer_sha256": ( + sha256_file( + tokenizer_path + ) + ), + "authority": "NONE", + }, + path, + ) + + return sha256_file( + path + ) + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--train", + default=( + "data/native_cortex/" + "tokens/train.bin" + ), + ) + + parser.add_argument( + "--token-manifest", + default=( + "data/native_cortex/tokens/" + "TOKEN_STREAM_MANIFEST.json" + ), + ) + + parser.add_argument( + "--tokenizer", + default=( + "data/native_cortex/tokenizer/" + "tokenizer.json" + ), + ) + + parser.add_argument( + "--output", + default=( + "artifacts/native_cortex/v1" + ), + ) + + parser.add_argument( + "--steps", + type=int, + default=2000, + ) + + parser.add_argument( + "--batch-size", + type=int, + default=4, + ) + + parser.add_argument( + "--sequence-length", + type=int, + default=128, + ) + + parser.add_argument( + "--learning-rate", + type=float, + default=2e-4, + ) + + parser.add_argument( + "--seed", + type=int, + default=260823, + ) + + parser.add_argument( + "--log-every", + type=int, + default=25, + ) + + parser.add_argument( + "--save-every", + type=int, + default=500, + ) + + parser.add_argument( + "--resume", + default=None, + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + torch.manual_seed( + args.seed + ) + + tokenizer_path = Path( + args.tokenizer + ) + + tokenizer = BPETokenizer( + str( + tokenizer_path + ) + ) + + stream = np.memmap( + args.train, + dtype=np.uint16, + mode="r", + ) + + config = CortexV1Config( + vocab_size=( + tokenizer.vocab_size + ) + ) + + model = NativeCortexV1( + config + ).to( + args.device + ) + + optimizer = torch.optim.AdamW( + model.parameters(), + lr=args.learning_rate, + betas=( + 0.9, + 0.95, + ), + weight_decay=0.01, + ) + + start_step = 0 + + if args.resume: + checkpoint = torch.load( + args.resume, + map_location=args.device, + weights_only=False, + ) + + model.load_state_dict( + checkpoint[ + "model" + ] + ) + + optimizer.load_state_dict( + checkpoint[ + "optimizer" + ] + ) + + start_step = int( + checkpoint[ + "step" + ] + ) + + print( + "resumed:", + args.resume, + ) + + print( + "start step:", + start_step, + ) + + generator = torch.Generator() + generator.manual_seed( + args.seed + ) + + output = Path( + args.output + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + bytes_per_token = None + + manifest_path = Path( + args.token_manifest + ) + + if manifest_path.exists(): + manifest = json.loads( + manifest_path.read_text() + ) + + train_info = ( + manifest[ + "splits" + ][ + "train" + ] + ) + + bytes_per_token = ( + train_info[ + "utf8_bytes" + ] + / train_info[ + "tokens" + ] + ) + + print("=" * 88) + print( + "MEGA PRIME — NATIVE CORTEX V1" + ) + print("=" * 88) + + print( + "device:", + args.device, + ) + + print( + "training tokens:", + f"{len(stream):,}", + ) + + print( + "parameters:", + f"{model.parameter_count():,}", + ) + + print( + "vocab:", + tokenizer.vocab_size, + ) + + print( + "model width:", + config.d_model, + ) + + print( + "layers:", + config.layers, + ) + + print( + "experts:", + config.experts, + ) + + print( + "train routing:", + "TOP-2", + ) + + print( + "inference routing:", + "TOP-1", + ) + + print( + "local attention window:", + config.attention_window, + ) + + print( + "authority:", + "NONE", + ) + + print("=" * 88) + + interval_start = ( + time.perf_counter() + ) + + interval_tokens = 0 + + model.train() + + for step in range( + start_step + 1, + args.steps + 1, + ): + x, y = sample_batch( + stream, + batch_size=( + args.batch_size + ), + sequence_length=( + args.sequence_length + ), + generator=generator, + device=args.device, + ) + + optimizer.zero_grad( + set_to_none=True + ) + + result = model( + x + ) + + language_loss = ( + F.cross_entropy( + result.logits.reshape( + -1, + tokenizer.vocab_size, + ), + y.reshape(-1), + ) + ) + + future_offset = 8 + + if ( + result.hidden.shape[1] + > future_offset + ): + predicted_future = ( + model.future_predictor( + result.hidden[ + :, + :-future_offset, + : + ] + ) + ) + + predicted_future = ( + F.normalize( + predicted_future, + dim=-1, + ) + ) + + target_future = ( + F.normalize( + result.hidden[ + :, + future_offset:, + : + ].detach(), + dim=-1, + ) + ) + + future_loss = ( + 1.0 + - ( + predicted_future + * target_future + ).sum( + dim=-1 + ) + ).mean() + + else: + future_loss = ( + language_loss + .new_zeros(()) + ) + + training_progress = ( + step + / max( + args.steps, + 1, + ) + ) + + anneal = min( + training_progress + / 0.70, + 1.0, + ) + + balance_weight = ( + 0.15 + * ( + 1.0 + - anneal + ) + + 0.03 + * anneal + ) + + entropy_weight = ( + 0.03 + * ( + 1.0 + - anneal + ) + + 0.003 + * anneal + ) + + z_weight = 0.001 + + total_loss = ( + language_loss + + 0.05 + * future_loss + + balance_weight + * result.router_balance_loss + + z_weight + * result.router_z_loss + - entropy_weight + * result.router_entropy_normalized + ) + + total_loss.backward() + + gradient_norm = ( + torch.nn.utils + .clip_grad_norm_( + model.parameters(), + 1.0, + ) + ) + + optimizer.step() + + interval_tokens += ( + x.numel() + ) + + if ( + step == 1 + or step + % args.log_every + == 0 + ): + now = ( + time.perf_counter() + ) + + elapsed = max( + now + - interval_start, + 1e-9, + ) + + tokens_per_second = ( + interval_tokens + / elapsed + ) + + pieces = [ + f"step={step:6d}", + ( + f"lm=" + f"{language_loss.item():.4f}" + ), + ( + f"future=" + f"{future_loss.item():.4f}" + ), + ( + f"balance=" + f"{result.router_balance_loss.item():.3f}" + ), + ( + f"H=" + f"{result.router_entropy_normalized.item():.3f}" + ), + ( + f"grad=" + f"{float(gradient_norm):.3f}" + ), + ( + f"tok/s=" + f"{tokens_per_second:.0f}" + ), + ] + + if ( + bytes_per_token + is not None + ): + pieces.append( + ( + f"raw-B/s=" + f"{tokens_per_second * bytes_per_token:.0f}" + ) + ) + + print( + " ".join( + pieces + ) + ) + + interval_tokens = 0 + interval_start = now + + if ( + step + % args.save_every + == 0 + ): + path = ( + output + / ( + f"cortex-v1-step-" + f"{step:06d}.pt" + ) + ) + + digest = save_checkpoint( + path, + model=model, + optimizer=optimizer, + config=config, + step=step, + tokenizer_path=( + tokenizer_path + ), + ) + + print( + "checkpoint:", + path, + ) + + print( + "sha256:", + digest, + ) + + final_path = ( + output + / "cortex-v1-final.pt" + ) + + digest = save_checkpoint( + final_path, + model=model, + optimizer=optimizer, + config=config, + step=args.steps, + tokenizer_path=( + tokenizer_path + ), + ) + + print() + print( + "final checkpoint:", + final_path, + ) + + print( + "final sha256:", + digest, + ) + + +if __name__ == "__main__": + main() diff --git a/tools/train_native_tokenizer.py b/tools/train_native_tokenizer.py new file mode 100755 index 0000000..1e519ce --- /dev/null +++ b/tools/train_native_tokenizer.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +"""Train the provenance-bound BPE tokenizer for Mega PRIME Native Cortex.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path + +from tokenizers import Tokenizer +from tokenizers.decoders import ByteLevel as ByteLevelDecoder +from tokenizers.models import BPE +from tokenizers.normalizers import NFC +from tokenizers.pre_tokenizers import ByteLevel +from tokenizers.trainers import BpeTrainer + + +SPECIAL_TOKENS = ( + "", + "", + "", + "", +) + + +def documents(path: Path): + """Yield TRAIN text only. + + This script must never receive the held-out split. + """ + with path.open( + "r", + encoding="utf-8", + ) as handle: + for line in handle: + record = json.loads(line) + yield record["text"] + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + + with path.open("rb") as handle: + for chunk in iter( + lambda: handle.read(1024 * 1024), + b"", + ): + digest.update(chunk) + + return digest.hexdigest() + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--train", + default="data/native_cortex/splits/train.jsonl", + ) + + parser.add_argument( + "--output", + default="data/native_cortex/tokenizer", + ) + + parser.add_argument( + "--vocab-size", + type=int, + default=4096, + ) + + args = parser.parse_args() + + train_path = Path(args.train).resolve() + + if "heldout" in train_path.name.lower(): + raise RuntimeError( + "refusing to train tokenizer on held-out corpus" + ) + + output = Path(args.output) + output.mkdir( + parents=True, + exist_ok=True, + ) + + tokenizer = Tokenizer( + BPE( + unk_token="", + ) + ) + + tokenizer.normalizer = NFC() + + tokenizer.pre_tokenizer = ByteLevel( + add_prefix_space=False, + ) + + tokenizer.decoder = ByteLevelDecoder() + + trainer = BpeTrainer( + vocab_size=args.vocab_size, + min_frequency=2, + special_tokens=list( + SPECIAL_TOKENS + ), + initial_alphabet=( + ByteLevel.alphabet() + ), + show_progress=True, + ) + + tokenizer.train_from_iterator( + documents(train_path), + trainer=trainer, + ) + + tokenizer_path = ( + output / "tokenizer.json" + ) + + tokenizer.save( + str(tokenizer_path) + ) + + tokenizer_digest = sha256_file( + tokenizer_path + ) + + train_digest = sha256_file( + train_path + ) + + manifest = { + "format": "mega-prime-bpe-v1", + "vocab_size": ( + tokenizer.get_vocab_size() + ), + "requested_vocab_size": ( + args.vocab_size + ), + "special_tokens": list( + SPECIAL_TOKENS + ), + "train_corpus": str( + train_path + ), + "train_corpus_sha256": ( + train_digest + ), + "tokenizer_sha256": ( + tokenizer_digest + ), + } + + manifest_path = ( + output + / "TOKENIZER_MANIFEST.json" + ) + + manifest_path.write_text( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + manifest_digest = sha256_file( + manifest_path + ) + + ( + output + / "TOKENIZER_MANIFEST.sha256" + ).write_text( + ( + f"{manifest_digest} " + "TOKENIZER_MANIFEST.json\n" + ), + encoding="utf-8", + ) + + print( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tools/train_verifier_semantics_ab.py b/tools/train_verifier_semantics_ab.py new file mode 100755 index 0000000..c05d6e1 --- /dev/null +++ b/tools/train_verifier_semantics_ab.py @@ -0,0 +1,1390 @@ +#!/usr/bin/env python3 +"""Controlled A/B verifier-semantics training for PRIME Native Cortex. + +Condition A: + frozen original verifier curriculum + +Condition B: + matched counterfactual verifier curriculum + +Everything else is held constant. + +The cortex has authority NONE. +HELDOUT IS FORBIDDEN. +""" + +from __future__ import annotations + +import argparse +from collections import Counter +from dataclasses import asdict +import hashlib +import json +from pathlib import Path +import random +import time + +import numpy as np +import torch +import torch.nn.functional as F + +from core.cortex import ( + BPETokenizer, + CortexV1Config, + NativeCortexV1, +) + +from core.cortex.prime_bridge import ( + VERIFIER_LABELS, +) + +from core.cortex.verifier_prompt import ( + format_verifier_prompt, +) + + +CONDITIONS = { + "exposure_control": { + "verifier": ( + "data/native_cortex/" + "prime_bridge/curriculum/" + "train.jsonl" + ), + "expected_sha256": ( + "09a08d5924c7f0616d16beecce6c75f03e52ce6cfe100afa3f00c2d9cf4c6516" + ), + }, + "counterfactual_paired": { + "verifier": ( + "data/native_cortex/" + "verifier_semantics/" + "counterfactual_v1/" + "train.jsonl" + ), + "expected_sha256": ( + "b7ebab7b3b8bcee3a476a7a13cc41e356b2e25ba8c6f2c15b2c83e7994252025" + ), + }, +} + +EXPECTED_BASE_SHA256 = ( + "aa1119618e4668de79dce8d783a016d5699bd53df3232b0cffbada6938a59ca1" +) + +EXPECTED_SEMANTIC_SHA256 = ( + "4f0bd8a514a6160a466c52ab719f9035d29777558faecbcc7feb161c36336d4b" +) + + +def sha256_file(path: Path) -> str: + digest = hashlib.sha256() + + with path.open("rb") as handle: + for chunk in iter( + lambda: handle.read(1024 * 1024), + b"", + ): + digest.update(chunk) + + return digest.hexdigest() + + +def load_jsonl(path: Path): + with path.open( + "r", + encoding="utf-8", + ) as handle: + return [ + json.loads(line) + for line in handle + if line.strip() + ] + + +def lm_batch( + stream, + *, + batch_size, + sequence_length, + rng, + device, +): + rows = [] + + maximum = ( + len(stream) + - sequence_length + - 1 + ) + + for _ in range(batch_size): + start = rng.randrange( + 0, + maximum, + ) + + row = np.asarray( + stream[ + start: + start + + sequence_length + + 1 + ], + dtype=np.int64, + ) + + rows.append( + torch.from_numpy(row) + ) + + batch = torch.stack( + rows + ).to(device) + + return ( + batch[:, :-1], + batch[:, 1:], + ) + + +def semantic_example( + tokenizer, + record, + *, + max_length, + device, +): + prefix_text = ( + "SOURCE:\n" + + str(record["source_text"]) + + "\n\nTSIR_PROPOSAL:\n" + ) + + target_text = str( + record["proposal_text"] + ) + + target = tokenizer.encode( + target_text, + add_bos=False, + add_eos=True, + ) + + if len(target) >= max_length - 8: + return None + + prefix = tokenizer.encode( + prefix_text, + add_bos=True, + add_eos=False, + ) + + available_prefix = ( + max_length + - len(target) + ) + + if len(prefix) > available_prefix: + prefix = ( + [tokenizer.BOS] + + prefix[ + -(available_prefix - 1): + ] + ) + + tokens = prefix + target + + x = torch.tensor( + tokens[:-1], + dtype=torch.long, + device=device, + ).unsqueeze(0) + + y = torch.tensor( + tokens[1:], + dtype=torch.long, + device=device, + ).unsqueeze(0) + + mask = torch.zeros_like( + y, + dtype=torch.bool, + ) + + first_target_prediction = ( + len(prefix) - 1 + ) + + mask[ + :, + first_target_prediction: + ] = True + + return x, y, mask + + +def verifier_example( + tokenizer, + record, + *, + max_length, + device, +): + text = format_verifier_prompt( + record + ) + + ids = tokenizer.encode( + text, + add_bos=True, + add_eos=True, + ) + + ids = ids[ + -max_length: + ] + + x = torch.tensor( + ids, + dtype=torch.long, + device=device, + ).unsqueeze(0) + + label = int( + record[ + "verifier_label_id" + ] + ) + + return x, label + + +def router_regularizer(result): + return ( + 0.025 + * result.router_balance_loss + + 0.001 + * result.router_z_loss + - 0.002 + * result.router_entropy_normalized + ) + + +def save_checkpoint( + path, + *, + model, + optimizer, + config, + tokenizer_path, + base_checkpoint_hash, + condition, + verifier_curriculum_hash, + step, +): + torch.save( + { + "format": ( + "mega-prime-verifier-" + "semantics-ab-v1" + ), + "condition": condition, + "step": step, + "config": asdict( + config + ), + "model": model.state_dict(), + "optimizer": ( + optimizer.state_dict() + ), + "tokenizer": str( + tokenizer_path + ), + "base_checkpoint_sha256": ( + base_checkpoint_hash + ), + "verifier_curriculum_sha256": ( + verifier_curriculum_hash + ), + "authority": "NONE", + }, + path, + ) + + return sha256_file( + path + ) + + +def task_for_step(step: int) -> str: + slot = ( + step - 1 + ) % 10 + + if slot < 3: + return "lm" + + if slot < 5: + return "semantic" + + return "verifier" + + +def planned_counts( + steps: int, + verifier_batch_size: int, +): + counts = Counter( + task_for_step(step) + for step in range( + 1, + steps + 1, + ) + ) + + return { + "optimizer_steps": steps, + "lm_optimizer_steps": ( + counts["lm"] + ), + "semantic_optimizer_steps": ( + counts["semantic"] + ), + "verifier_optimizer_steps": ( + counts["verifier"] + ), + "verifier_batch_size": ( + verifier_batch_size + ), + "verifier_presentations": ( + counts["verifier"] + * verifier_batch_size + ), + } + + +def main(): + parser = argparse.ArgumentParser() + + parser.add_argument( + "--condition", + required=True, + choices=sorted( + CONDITIONS + ), + ) + + parser.add_argument( + "--checkpoint", + default=( + "artifacts/native_cortex/" + "prime-bridge-v1/" + "cortex-prime-final.pt" + ), + ) + + parser.add_argument( + "--semantic", + default=( + "data/native_cortex/" + "prime_bridge/train/" + "semantic.jsonl" + ), + ) + + parser.add_argument( + "--lm-stream", + default=( + "data/native_cortex/" + "tokens/train.bin" + ), + ) + + parser.add_argument( + "--input-lock", + default=( + "docs/native_cortex/" + "verifier_semantics/" + "AB_INPUTS.json" + ), + ) + + parser.add_argument( + "--output-root", + default=( + "artifacts/native_cortex/" + "verifier-semantics-ab-v1" + ), + ) + + parser.add_argument( + "--steps", + type=int, + default=1000, + ) + + parser.add_argument( + "--verifier-batch-size", + type=int, + default=5, + ) + + parser.add_argument( + "--max-length", + type=int, + default=192, + ) + + parser.add_argument( + "--learning-rate", + type=float, + default=8e-5, + ) + + parser.add_argument( + "--seed", + type=int, + default=26082511, + ) + + parser.add_argument( + "--log-every", + type=int, + default=25, + ) + + parser.add_argument( + "--save-every", + type=int, + default=500, + ) + + parser.add_argument( + "--dry-run", + action="store_true", + ) + + parser.add_argument( + "--device", + default=( + "cuda" + if torch.cuda.is_available() + else "cpu" + ), + ) + + args = parser.parse_args() + + if args.steps % 10 != 0: + raise RuntimeError( + "steps must be divisible by 10" + ) + + condition = CONDITIONS[ + args.condition + ] + + verifier_path = Path( + condition["verifier"] + ) + + semantic_path = Path( + args.semantic + ) + + checkpoint_path = Path( + args.checkpoint + ) + + lm_path = Path( + args.lm_stream + ) + + input_lock_path = Path( + args.input_lock + ) + + for path in ( + verifier_path, + semantic_path, + checkpoint_path, + lm_path, + input_lock_path, + ): + if "heldout" in str( + path + ).lower(): + raise RuntimeError( + "HELDOUT ACCESS FORBIDDEN" + ) + + if not path.exists(): + raise RuntimeError( + f"missing required input: {path}" + ) + + input_lock = json.loads( + input_lock_path.read_text( + encoding="utf-8" + ) + ) + + base_hash = sha256_file( + checkpoint_path + ) + + semantic_hash = sha256_file( + semantic_path + ) + + verifier_hash = sha256_file( + verifier_path + ) + + lm_hash = sha256_file( + lm_path + ) + + if ( + base_hash + != EXPECTED_BASE_SHA256 + ): + raise RuntimeError( + "base checkpoint hash mismatch: " + + base_hash + ) + + if ( + semantic_hash + != EXPECTED_SEMANTIC_SHA256 + ): + raise RuntimeError( + "semantic stream hash mismatch: " + + semantic_hash + ) + + if ( + verifier_hash + != condition[ + "expected_sha256" + ] + ): + raise RuntimeError( + "verifier curriculum hash mismatch: " + + verifier_hash + ) + + locked_lm_hash = ( + input_lock[ + "lm_stream_sha256" + ] + ) + + if lm_hash != locked_lm_hash: + raise RuntimeError( + "LM stream differs from " + "frozen A/B input lock: " + + lm_hash + ) + + verifier_records = load_jsonl( + verifier_path + ) + + semantic_records = load_jsonl( + semantic_path + ) + + if not verifier_records: + raise RuntimeError( + "empty verifier curriculum" + ) + + if not semantic_records: + raise RuntimeError( + "empty semantic supervision" + ) + + label_counts = Counter( + int( + row[ + "verifier_label_id" + ] + ) + for row in verifier_records + ) + + expected_labels = set( + range( + len( + VERIFIER_LABELS + ) + ) + ) + + if set( + label_counts + ) != expected_labels: + raise RuntimeError( + "curriculum does not contain " + "all five verifier labels" + ) + + plan = planned_counts( + args.steps, + args.verifier_batch_size, + ) + + if ( + plan[ + "verifier_presentations" + ] + != len( + verifier_records + ) + ): + raise RuntimeError( + "Stage-1 protocol requires " + "exactly one full verifier " + "curriculum presentation: " + f"planned=" + f"{plan['verifier_presentations']} " + f"records=" + f"{len(verifier_records)}" + ) + + print("=" * 92) + print( + "MEGA PRIME — VERIFIER SEMANTICS A/B" + ) + print("=" * 92) + + print( + "condition:", + args.condition, + ) + + print( + "device:", + args.device, + ) + + print( + "base checkpoint:", + base_hash, + ) + + print( + "semantic sha256:", + semantic_hash, + ) + + print( + "LM stream sha256:", + lm_hash, + ) + + print( + "verifier curriculum:", + verifier_path, + ) + + print( + "verifier sha256:", + verifier_hash, + ) + + print( + "verifier records:", + len( + verifier_records + ), + ) + + print( + "verifier labels:", + { + VERIFIER_LABELS[ + index + ]: + label_counts[index] + for index + in range( + len( + VERIFIER_LABELS + ) + ) + }, + ) + + print( + "plan:", + plan, + ) + + print( + "task schedule:", + "30% LM / 20% semantic / " + "50% verifier optimizer steps", + ) + + print( + "verifier sampling:", + "deterministic shuffled " + "without replacement", + ) + + print( + "optimizer:", + "continued AdamW state " + "from frozen bridge checkpoint", + ) + + print( + "authority:", + "NONE", + ) + + if args.dry_run: + print( + "DRY RUN: validation passed; " + "no model training performed." + ) + print("=" * 92) + return + + random.seed( + args.seed + ) + + torch.manual_seed( + args.seed + ) + + rng_main = random.Random( + args.seed + ) + + rng_verifier = random.Random( + args.seed + 1 + ) + + checkpoint = torch.load( + checkpoint_path, + map_location=args.device, + weights_only=False, + ) + + config = CortexV1Config( + **checkpoint["config"] + ) + + tokenizer_path = Path( + checkpoint["tokenizer"] + ) + + tokenizer = BPETokenizer( + str( + tokenizer_path + ) + ) + + model = NativeCortexV1( + config + ).to( + args.device + ) + + model.load_state_dict( + checkpoint["model"] + ) + + optimizer = torch.optim.AdamW( + model.parameters(), + lr=args.learning_rate, + betas=(0.9, 0.95), + weight_decay=0.01, + ) + + if "optimizer" not in checkpoint: + raise RuntimeError( + "base checkpoint has no " + "optimizer state" + ) + + optimizer.load_state_dict( + checkpoint["optimizer"] + ) + + for group in ( + optimizer.param_groups + ): + group["lr"] = ( + args.learning_rate + ) + + stream = np.memmap( + lm_path, + dtype=np.uint16, + mode="r", + ) + + verifier_order = list( + range( + len( + verifier_records + ) + ) + ) + + rng_verifier.shuffle( + verifier_order + ) + + verifier_cursor = 0 + + output = ( + Path( + args.output_root + ) + / args.condition + ) + + output.mkdir( + parents=True, + exist_ok=True, + ) + + model.train() + + accumulators = { + "lm": [], + "semantic": [], + "verifier": [], + } + + total_task_counts = Counter() + + verifier_label_presentations = ( + Counter() + ) + + verifier_record_hashes_seen = set() + + started = time.perf_counter() + + for step in range( + 1, + args.steps + 1, + ): + task = task_for_step( + step + ) + + optimizer.zero_grad( + set_to_none=True + ) + + if task == "lm": + x, y = lm_batch( + stream, + batch_size=2, + sequence_length=128, + rng=rng_main, + device=args.device, + ) + + result = model( + x + ) + + task_loss = ( + F.cross_entropy( + result.logits.reshape( + -1, + config.vocab_size, + ), + y.reshape(-1), + ) + ) + + total_loss = ( + task_loss + + router_regularizer( + result + ) + ) + + total_loss.backward() + + raw_task_loss = float( + task_loss.item() + ) + + elif task == "semantic": + example = None + attempts = 0 + + while example is None: + attempts += 1 + + if attempts > 100: + raise RuntimeError( + "could not construct " + "semantic example" + ) + + record = rng_main.choice( + semantic_records + ) + + example = semantic_example( + tokenizer, + record, + max_length=( + args.max_length + ), + device=args.device, + ) + + x, y, mask = example + + result = model( + x + ) + + selected_logits = ( + result.logits[ + mask + ] + ) + + selected_targets = ( + y[ + mask + ] + ) + + task_loss = ( + F.cross_entropy( + selected_logits, + selected_targets, + ) + ) + + total_loss = ( + task_loss + + router_regularizer( + result + ) + ) + + total_loss.backward() + + raw_task_loss = float( + task_loss.item() + ) + + else: + batch_losses = [] + + for _ in range( + args.verifier_batch_size + ): + if ( + verifier_cursor + >= len( + verifier_order + ) + ): + raise RuntimeError( + "verifier curriculum " + "exhausted before " + "protocol completion" + ) + + record_index = ( + verifier_order[ + verifier_cursor + ] + ) + + verifier_cursor += 1 + + record = ( + verifier_records[ + record_index + ] + ) + + x, label = ( + verifier_example( + tokenizer, + record, + max_length=( + args.max_length + ), + device=args.device, + ) + ) + + result = model( + x + ) + + verifier_logits = ( + result.verifier_logits[ + :, + -1, + : + ] + ) + + target = torch.tensor( + [label], + dtype=torch.long, + device=args.device, + ) + + one_loss = ( + F.cross_entropy( + verifier_logits, + target, + ) + ) + + scaled_loss = ( + one_loss + + router_regularizer( + result + ) + ) / ( + args.verifier_batch_size + ) + + scaled_loss.backward() + + batch_losses.append( + float( + one_loss.item() + ) + ) + + verifier_label_presentations[ + VERIFIER_LABELS[ + label + ] + ] += 1 + + record_hash = record.get( + "record_hash", + f"index:{record_index}", + ) + + verifier_record_hashes_seen.add( + record_hash + ) + + raw_task_loss = ( + sum( + batch_losses + ) + / len( + batch_losses + ) + ) + + gradient_norm = ( + torch.nn.utils + .clip_grad_norm_( + model.parameters(), + 1.0, + ) + ) + + optimizer.step() + + accumulators[ + task + ].append( + raw_task_loss + ) + + total_task_counts[ + task + ] += 1 + + if ( + step == 1 + or step + % args.log_every + == 0 + ): + def mean(name): + values = ( + accumulators[ + name + ] + ) + + if not values: + return float( + "nan" + ) + + return ( + sum(values) + / len(values) + ) + + elapsed = ( + time.perf_counter() + - started + ) + + print( + f"step={step:04d} " + f"task={task:8s} " + f"lm={mean('lm'):.4f} " + f"semantic=" + f"{mean('semantic'):.4f} " + f"verifier=" + f"{mean('verifier'):.4f} " + f"grad=" + f"{float(gradient_norm):.4f} " + f"verifier_seen=" + f"{verifier_cursor}/" + f"{len(verifier_records)} " + f"elapsed=" + f"{elapsed:.1f}s" + ) + + for key in ( + accumulators + ): + accumulators[ + key + ].clear() + + if ( + step + % args.save_every + == 0 + ): + checkpoint_out = ( + output + / ( + "cortex-step-" + f"{step:06d}.pt" + ) + ) + + checkpoint_hash = ( + save_checkpoint( + checkpoint_out, + model=model, + optimizer=optimizer, + config=config, + tokenizer_path=( + tokenizer_path + ), + base_checkpoint_hash=( + base_hash + ), + condition=( + args.condition + ), + verifier_curriculum_hash=( + verifier_hash + ), + step=step, + ) + ) + + print( + "checkpoint:", + checkpoint_out, + ) + + print( + "checkpoint sha256:", + checkpoint_hash, + ) + + if ( + verifier_cursor + != len( + verifier_records + ) + ): + raise RuntimeError( + "Stage-1 verifier coverage " + "did not finish exactly one " + "curriculum epoch: " + f"{verifier_cursor}/" + f"{len(verifier_records)}" + ) + + if ( + len( + verifier_record_hashes_seen + ) + != len( + verifier_records + ) + ): + raise RuntimeError( + "verifier record coverage " + "was not unique: " + f"{len(verifier_record_hashes_seen)} " + f"unique of " + f"{len(verifier_records)}" + ) + + final_path = ( + output + / "cortex-final.pt" + ) + + final_hash = save_checkpoint( + final_path, + model=model, + optimizer=optimizer, + config=config, + tokenizer_path=( + tokenizer_path + ), + base_checkpoint_hash=( + base_hash + ), + condition=args.condition, + verifier_curriculum_hash=( + verifier_hash + ), + step=args.steps, + ) + + elapsed = ( + time.perf_counter() + - started + ) + + manifest = { + "format": ( + "mega-prime-verifier-" + "semantics-ab-training-v1" + ), + "condition": ( + args.condition + ), + "authority": "NONE", + "seed": args.seed, + "steps": args.steps, + "schedule": ( + "30% LM / 20% semantic / " + "50% verifier optimizer steps" + ), + "verifier_batch_size": ( + args.verifier_batch_size + ), + "base_checkpoint": str( + checkpoint_path + ), + "base_checkpoint_sha256": ( + base_hash + ), + "semantic_path": str( + semantic_path + ), + "semantic_sha256": ( + semantic_hash + ), + "lm_stream": str( + lm_path + ), + "lm_stream_sha256": ( + lm_hash + ), + "verifier_curriculum": str( + verifier_path + ), + "verifier_curriculum_sha256": ( + verifier_hash + ), + "verifier_records": len( + verifier_records + ), + "verifier_presentations": ( + verifier_cursor + ), + "unique_verifier_records_seen": ( + len( + verifier_record_hashes_seen + ) + ), + "verifier_label_presentations": ( + dict( + sorted( + verifier_label_presentations.items() + ) + ) + ), + "optimizer_task_counts": ( + dict( + sorted( + total_task_counts.items() + ) + ) + ), + "optimizer_state_continued": ( + True + ), + "learning_rate": ( + args.learning_rate + ), + "max_length": ( + args.max_length + ), + "final_checkpoint": str( + final_path + ), + "final_checkpoint_sha256": ( + final_hash + ), + "elapsed_seconds": ( + elapsed + ), + } + + manifest_path = ( + output + / "TRAINING_MANIFEST.json" + ) + + manifest_path.write_text( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ), + encoding="utf-8", + ) + + print() + print("=" * 92) + print( + "A/B CONDITION COMPLETE" + ) + print("=" * 92) + + print( + json.dumps( + manifest, + sort_keys=True, + indent=2, + ) + ) + + +if __name__ == "__main__": + main()