384 lines
18 KiB
C++
384 lines
18 KiB
C++
#include "evo/ecology/materialize.hpp"
|
|
#include "evo/ecology/population.hpp"
|
|
#include "fixtures/resolution_model.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cstdio>
|
|
#include <expected>
|
|
#include <iostream>
|
|
#include <ranges>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
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<bool>(__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<Divergence> 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<Inventory> opening(first_member_store + rule.capacity);
|
|
opening[escrow.value - 1] = spread(individual.environment, individual.matter_store);
|
|
std::vector<ActiveMember> members;
|
|
for (std::size_t index = 0; index < individual.members.size(); ++index) {
|
|
const auto& source = individual.members[index];
|
|
const ReservoirId store{static_cast<std::uint32_t>(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<ClassDraw> 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<std::uint32_t>(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;
|
|
}
|