#include "evo/ecology/materialize.hpp" #include "evo/ecology/population.hpp" #include "fixtures/resolution_model.hpp" #include #include #include #include #include #include #include #include #include #include namespace { using namespace evo::ecology; using namespace evo::accounting; using evo::Tick; void check(bool condition, std::source_location location = std::source_location::current()) { if (!condition) { throw std::runtime_error("equivalence line " + std::to_string(location.line())); } } #define CHECK(...) check(static_cast(__VA_ARGS__)) using namespace evo::fixture; constexpr Rule rule{}; // --------------------------------------------------------------------------- // The instrument check. With one member per class a class average is that member, // so the two runs must agree exactly. Without this a measured divergence could be // aggregation error or a transcription mistake, and nothing would tell them apart. // --------------------------------------------------------------------------- void one_member_per_class_agrees_exactly() { auto individual = founding_individuals(20); // Distinct ages so every class holds exactly one member at width one. for (std::size_t index = 0; index < individual.members.size(); ++index) { individual.members[index].age = index; } auto aggregate = founding_classes(individual, 1); CHECK(aggregate.classes.size() == individual.members.size()); CHECK(individual.census() == aggregate.census()); for (std::uint64_t tick = 0; tick < 40; ++tick) { individual.step(); aggregate.step(); // Every tick, not only at the end: a divergence that cancelled would // otherwise pass. CHECK(individual.census() == aggregate.census()); CHECK(individual.total_energy() == aggregate.total_energy()); CHECK(individual.total_matter() == aggregate.total_matter()); CHECK(aggregate.classes.size() <= max_age_classes); CHECK(representable(aggregate)); // Distributions, not just totals: a census agrees even when the two runs // have given the same investment to different parents. CHECK(portrait(individual) == portrait(aggregate)); } // The control has to have exercised something, or it proves nothing. CHECK(individual.census().births > 0); CHECK(individual.census().living > 20); } // The capacity boundary, which the control above never reaches. With fewer free // slots than eligible parents the allocation order decides which parents reproduce, // and that is an implementation choice rather than a consequence of resolution: if // the two runs order differently, the published divergence cannot be attributed to // averaging at all. One member per class again, so the two must agree exactly, and // distributions rather than censuses because a different parent breeding leaves // every total unchanged. void contested_breeding_slots_go_to_the_same_parents() { constexpr std::uint64_t count = 12; auto individual = founding_contested(count, count + 1); auto aggregate = founding_classes(individual, 1); CHECK(aggregate.rule.capacity == individual.rule.capacity); CHECK(aggregate.classes.size() == count); CHECK(portrait(individual) == portrait(aggregate)); bool contested = false; for (std::uint64_t tick = 0; tick < 40; ++tick) { // Before the step, count how many parents are eligible against how many // slots are free, so the test can prove it actually reached the boundary. std::uint64_t living = 0; std::uint64_t eligible = 0; for (const auto& member : individual.members) { if (!member.alive) { continue; } ++living; if (rule.breeds(member.age + 1, member.energy) && member.matter >= rule.investment_matter) { ++eligible; } } const auto free_slots = individual.rule.capacity > living ? individual.rule.capacity - living : 0; if (eligible > free_slots && free_slots > 0) { contested = true; } individual.step(); aggregate.step(); CHECK(portrait(individual) == portrait(aggregate)); CHECK(individual.census() == aggregate.census()); CHECK(individual.total_energy() == aggregate.total_energy()); CHECK(individual.total_matter() == aggregate.total_matter()); CHECK(representable(aggregate)); } // The boundary has to have been reached, or this control proves nothing about // allocation and is just the first control again with fewer members. CHECK(contested); CHECK(individual.census().births > 0); CHECK(individual.census().living == individual.rule.capacity); } // --------------------------------------------------------------------------- // The scenario ECOLOGY_MODEL asks for, through the real conversions. // --------------------------------------------------------------------------- struct Divergence { std::uint64_t width{}; std::uint64_t individual_living{}; std::uint64_t aggregate_living{}; std::uint64_t individual_energy{}; std::uint64_t aggregate_energy{}; std::uint64_t living_gap_per_thousand{}; std::uint64_t energy_gap_per_thousand{}; }; Divergence measure(std::uint64_t width, std::uint64_t ticks) { auto individual = founding_individuals(100); auto aggregate = founding_classes(individual, width); const auto opening_energy = individual.total_energy(); const auto opening_matter = individual.total_matter(); CHECK(aggregate.total_energy() == opening_energy); CHECK(aggregate.total_matter() == opening_matter); for (std::uint64_t tick = 0; tick < ticks; ++tick) { individual.step(); aggregate.step(); // Conservation is exact on both sides at every tick, whatever the two // populations do to each other. CHECK(individual.total_energy() == opening_energy); CHECK(individual.total_matter() == opening_matter); CHECK(aggregate.total_energy() == opening_energy); CHECK(aggregate.total_matter() == opening_matter); CHECK(aggregate.classes.size() <= max_age_classes); // Every step of the aggregate run is a state a cohort could hold, so the // envelope describes this library and not a model it cannot represent. CHECK(representable(aggregate)); } const auto left = individual.census(); const auto right = aggregate.census(); return {width, left.living, right.living, left.energy, right.energy, gap_per_thousand(left.living, right.living), gap_per_thousand(left.energy, right.energy)}; } std::vector envelope; void aggregation_costs_something_and_coarse_classes_destroy_the_population() { // Ten thousand ticks, a hundred funded individuals, five declared resolutions. // Nothing here asserts the runs agree, and nothing tunes a bound to fit. for (const std::uint64_t width : {10U, 25U, 50U, 100U, 200U}) { const auto measured = measure(width, 10'000); envelope.push_back(measured); std::cout << "{\"class_width\":" << measured.width << ",\"individual_living\":" << measured.individual_living << ",\"aggregate_living\":" << measured.aggregate_living << ",\"individual_energy\":" << measured.individual_energy << ",\"aggregate_energy\":" << measured.aggregate_energy << ",\"living_gap_per_thousand\":" << measured.living_gap_per_thousand << ",\"energy_gap_per_thousand\":" << measured.energy_gap_per_thousand << "}\n"; } // The individual run is the reference and must survive in every case, or the // comparison is against a corpse and every gap below is meaningless. for (const auto& measured : envelope) { CHECK(measured.individual_living > 0); } // The measured result, reported rather than smoothed. Below a width the // aggregate tracks the individuals; above it the aggregate population dies out // entirely while the individuals persist. That is a false extinction caused by // resolution alone: a whole class starves together the moment its average // cannot pay upkeep, where individuals would have starved a few at a time and // the survivors would have kept the per-capita share up. std::uint64_t usable = 0; std::uint64_t destroyed = 0; for (const auto& measured : envelope) { if (measured.aggregate_living == 0) { ++destroyed; // A false extinction, since the reference population is alive. CHECK(measured.individual_living > 0); CHECK(measured.living_gap_per_thousand == 1000); } else { ++usable; // Where the aggregate survives, this is the envelope. The bounds are // chosen above the measurement with room for platform variation; they // are a regression guard, not a theoretical limit. See ADR-0040. CHECK(measured.living_gap_per_thousand <= 600); CHECK(measured.energy_gap_per_thousand <= 600); } } // Both regimes have to appear, or this measured one thing and reported two. CHECK(usable > 0); CHECK(destroyed > 0); // And the collapse is not monotone in class width. A narrower class is not // reliably safer: the measurement finds a width that destroys the population // while a coarser one sustains it. Whether a whole class dips below upkeep // together depends on how the width lands against the population cycle that // the shared per-capita intake drives, and this fixture does not characterise // that further. The consequence for a tier policy is the point: a resolution // cannot be chosen by assuming degradation worsens smoothly with coarseness. // Asserted because it is surprising: if a change ever made it monotone, the // warning written around this number would have become wrong. bool out_of_order = false; for (std::size_t index = 1; index < envelope.size(); ++index) { if (envelope[index - 1].aggregate_living == 0 && envelope[index].aggregate_living > 0) { out_of_order = true; } } CHECK(out_of_order); // And the runs must not agree anywhere. A change that quietly made them match // would mean the fixture stopped exercising aggregation or the comparison // stopped comparing, and either should fail rather than look like progress. for (const auto& measured : envelope) { CHECK(measured.living_gap_per_thousand > 0 || measured.energy_gap_per_thousand > 0); } } // --------------------------------------------------------------------------- // The same hundred individuals through the real conversions, end to end. // --------------------------------------------------------------------------- void the_full_scenario_conserves_and_keeps_its_genome() { constexpr ReservoirId backing{1}; constexpr ReservoirId detritus{2}; constexpr ReservoirId escrow{3}; constexpr std::uint32_t first_member_store = 4; auto individual = founding_individuals(100); // One ledger reservoir per founder, plus the cohort, detritus and the escrow // that stands for the environment. The escrow is seeded with what the // environment holds, because inventory arriving with immigration has to come // out of a store that already held it: a late transfer is not new production. // Sized for the capacity rather than the founders: the population grows, and a // draw of more members than there were founders would otherwise run off the // end of the ledger and be reported as a stale plan. std::vector opening(first_member_store + rule.capacity); opening[escrow.value - 1] = spread(individual.environment, individual.matter_store); std::vector members; for (std::size_t index = 0; index < individual.members.size(); ++index) { const auto& source = individual.members[index]; const ReservoirId store{static_cast(first_member_store + index)}; const auto reserve = spread(source.energy, source.matter); opening[store.value - 1] = reserve; members.push_back({index + 1, 3, {7}, source.age, store, reserve, MemberState::active}); } auto ledger = Ledger::create(opening); CHECK(ledger.has_value()); const auto total = ledger->conserved_totals(); CollapseRequest gather; gather.conversion = 1; gather.owner = {11, 1}; gather.habitat = {7}; gather.genome = 3; gather.tick = Tick{0}; gather.revision = 1; gather.destination = backing; for (std::uint64_t low = 0; low < rule.lifespan; low += 50) { gather.bounds.push_back({low, low + 50}); } const auto folded = plan_collapse(members, gather); CHECK(folded.has_value()); CohortRegistry registry; const auto installed = commit_collapse(*ledger, registry, *folded); CHECK(installed.has_value()); CHECK(ledger->conserved_totals() == total); CHECK(installed->count() == 100); CHECK(installed->genome() == 3); // Ten thousand ticks, advanced through M4.3 in intervals of fifty. The model // sub-steps internally; the interval reports the net flux it produced. auto aggregate = founding_classes(individual, 50); auto cohort = *installed; std::uint64_t revision = 1; std::uint64_t tick = 0; for (std::uint64_t interval = 0; interval < 200; ++interval) { const auto before = aggregate.census(); const auto before_detritus_energy = aggregate.detritus_energy; const auto before_detritus_matter = aggregate.detritus_matter; const auto before_environment = aggregate.environment; const auto before_store = aggregate.matter_store; for (std::uint64_t step = 0; step < 50; ++step) { aggregate.step(); } tick += 50; const auto after = aggregate.census(); if (after.living == 0) { break; } AdvanceRequest proposal; proposal.to = Tick{tick}; proposal.owner = cohort.owner(); proposal.revision = ++revision + 1; proposal.detritus = detritus; proposal.predators = detritus; proposal.elsewhere = escrow; proposal.bound = cohort.bound(); // The cohort's classes are the aggregate model's classes, and its fluxes // are the net change the model produced over the interval. for (const auto& age : aggregate.classes) { proposal.after.push_back( {age.age_low, age.age_high, age.count, spread(age.energy, age.matter), 0}); } const auto grew = after.living > before.living; proposal.flux.births = grew ? (after.living - before.living) * residual_scale : 0; proposal.flux.deaths = grew ? 0 : (before.living - after.living) * residual_scale; const auto shed_energy = aggregate.detritus_energy - before_detritus_energy; const auto shed_matter = aggregate.detritus_matter - before_detritus_matter; const auto drawn_energy = before_environment - aggregate.environment; const auto drawn_matter = before_store - aggregate.matter_store; proposal.flux.to_detritus = spread(shed_energy, shed_matter); proposal.flux.from_elsewhere = spread(drawn_energy, drawn_matter); const auto plan = plan_advance(cohort, proposal); CHECK(plan.has_value()); const auto committed = commit_advance(*ledger, registry, *plan); CHECK(committed.has_value()); cohort = *committed; CHECK(ledger->conserved_totals() == total); CHECK(ledger->balances()[backing.value - 1] == cohort.reserve()); CHECK(cohort.genome() == 3); } CHECK(tick == 10'000); CHECK(!cohort.is_vacant()); // Materialize the survivors, which is the other end of the round trip. std::vector draws; std::uint64_t drawn = 0; for (std::size_t index = 0; index < cohort.classes().size(); ++index) { const auto count = cohort.classes()[index].count; if (count == 0 || drawn + count > rule.capacity) { continue; } draws.push_back({index, count}); drawn += count; } CHECK(!draws.empty()); MaterializeRequest unfold; unfold.owner = cohort.owner(); unfold.revision = cohort.revision() + 1; unfold.draws = draws; unfold.first_identity = 100'000; for (std::uint64_t index = 0; index < drawn; ++index) { unfold.reservoirs.push_back({static_cast(first_member_store + index)}); } unfold.bound = cohort.bound(); // Those founder stores are empty now, because the collapse emptied them. const auto spread_out = plan_materialize(cohort, unfold); CHECK(spread_out.has_value()); const auto representatives = commit_materialize(*ledger, registry, *spread_out); CHECK(representatives.has_value()); CHECK(ledger->conserved_totals() == total); CHECK(representatives->size() == drawn); // Genome identity survives the whole round trip, and nothing invented one. for (const auto& member : *representatives) { CHECK(member.genome == 3); CHECK(member.habitat == HabitatId{7}); CHECK(member.state == MemberState::active); } CHECK(registry.size() == 1); CHECK(registry.find(HabitatId{7}, 3)->genome() == 3); } } // namespace int main() try { // The instrument check runs first: a failing control voids every number below. one_member_per_class_agrees_exactly(); contested_breeding_slots_go_to_the_same_parents(); aggregation_costs_something_and_coarse_classes_destroy_the_population(); the_full_scenario_conserves_and_keeps_its_genome(); std::cout << "PASS resolution comparison, exact control and a published envelope\n"; return 0; } catch (...) { return 1; }