Measure aggregate cost and fidelity across scarcity scenarios

This commit is contained in:
dingo
2026-09-26 09:39:53 -04:00
parent 55a728acd4
commit c237e4da97
15 changed files with 1115 additions and 529 deletions
+12 -524
View File
@@ -1,5 +1,6 @@
#include "evo/ecology/materialize.hpp"
#include "evo/ecology/population.hpp"
#include "fixtures/resolution_model.hpp"
#include <algorithm>
#include <array>
@@ -23,513 +24,8 @@ void check(bool condition, std::source_location location = std::source_location:
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
// ---------------------------------------------------------------------------
// The rule. Written once, applied at both resolutions: the individual run gives
// it one member at a time and the aggregate run gives it a class average and
// multiplies by the count. It is a fixture constant, not a simulation contract:
// ADR-0038 deliberately declines to choose an ecology, and this does not choose
// one for it. Energy is the only scarce axis so that divergence is attributable.
// ---------------------------------------------------------------------------
namespace rule {
constexpr std::uint64_t environment_energy = 300; // per tick, shared by the living
constexpr std::uint64_t matter_intake = 4; // per member per tick, abundant
constexpr std::uint64_t upkeep_energy = 2;
constexpr std::uint64_t upkeep_matter = 1;
constexpr std::uint64_t lifespan = 400;
constexpr std::uint64_t maturity = 50;
constexpr std::uint64_t threshold_energy = 100;
constexpr std::uint64_t investment_energy = 40;
constexpr std::uint64_t investment_matter = 40;
constexpr std::uint64_t capacity = 200;
// A member that cannot pay its upkeep starves. At class resolution the average
// member is asked the same question, which is exactly where the resolution bites.
[[nodiscard]] constexpr bool starves(std::uint64_t energy) noexcept {
return energy < upkeep_energy;
}
[[nodiscard]] constexpr bool breeds(std::uint64_t age, std::uint64_t energy) noexcept {
return age >= maturity && energy >= threshold_energy;
}
[[nodiscard]] constexpr std::uint64_t per_capita(std::uint64_t living) noexcept {
return living == 0 ? 0 : environment_energy / living;
}
// Who breeds when there are fewer free slots than eligible parents. This has to be
// part of the rule rather than a consequence of how each run happens to iterate:
// allocating contested slots in different orders changes which parents reproduce
// independently of any averaging, and a divergence caused by that is not a
// divergence caused by resolution. Oldest first, which both resolutions can honour:
// classes partition ages, so the oldest class holds the oldest members. Ordering
// within a class is the one thing only the individual run can see, and that is a
// resolution effect rather than an implementation difference.
} // namespace rule
// Matter behaves identically in all four channels here, so one number is tracked
// and mirrored into the four. Stated rather than left for a reader to infer.
Inventory spread(std::uint64_t energy, std::uint64_t matter) {
return {{energy},
{Femtograms{matter}, Femtograms{matter}, Femtograms{matter}, Femtograms{matter}}};
}
struct Census {
std::uint64_t living{};
std::uint64_t energy{};
std::uint64_t matter{};
std::uint64_t births{};
std::uint64_t deaths{};
auto operator<=>(const Census&) const = default;
};
// ---------------------------------------------------------------------------
// Individual resolution. Inventory is tracked as plain values and conservation is
// asserted arithmetically: this is the reference fixture, not a contract, and a
// reservoir per member would exceed the ledger's per-transaction leg bound.
// ---------------------------------------------------------------------------
struct Member {
std::uint64_t age{};
std::uint64_t energy{};
std::uint64_t matter{};
bool alive{true};
};
struct IndividualRun {
std::vector<Member> members;
std::uint64_t environment{};
std::uint64_t detritus_energy{};
std::uint64_t detritus_matter{};
std::uint64_t matter_store{};
std::uint64_t births{};
std::uint64_t deaths{};
std::uint64_t capacity{rule::capacity};
[[nodiscard]] Census census() const {
Census now;
for (const auto& member : members) {
if (!member.alive) {
continue;
}
++now.living;
now.energy += member.energy;
now.matter += member.matter;
}
now.births = births;
now.deaths = deaths;
return now;
}
[[nodiscard]] std::uint64_t total_energy() const {
std::uint64_t total = environment + detritus_energy;
for (const auto& member : members) {
if (member.alive) {
total += member.energy;
}
}
return total;
}
[[nodiscard]] std::uint64_t total_matter() const {
std::uint64_t total = matter_store + detritus_matter;
for (const auto& member : members) {
if (member.alive) {
total += member.matter;
}
}
return total;
}
void step() {
std::uint64_t living = 0;
for (const auto& member : members) {
living += member.alive ? 1 : 0;
}
const auto share = rule::per_capita(living);
// Starvation first, then upkeep, then intake, then ageing, then breeding.
// The aggregate run applies the same five stages in the same order.
for (auto& member : members) {
if (!member.alive) {
continue;
}
if (rule::starves(member.energy)) {
member.alive = false;
detritus_energy += member.energy;
detritus_matter += member.matter;
member.energy = 0;
member.matter = 0;
++deaths;
}
}
for (auto& member : members) {
if (!member.alive) {
continue;
}
member.energy -= rule::upkeep_energy;
detritus_energy += rule::upkeep_energy;
const auto paid = std::min(member.matter, rule::upkeep_matter);
member.matter -= paid;
detritus_matter += paid;
}
for (auto& member : members) {
if (!member.alive) {
continue;
}
// Bounded by what is there, so the arithmetic is safe, but the fixture
// is sized so that it never binds: if it ever did, intake would depend
// on the order members are visited in, and a divergence caused by that
// would look like a divergence caused by resolution. Checked rather
// than assumed, on both sides.
check(environment >= share);
check(matter_store >= rule::matter_intake);
const auto taken = std::min(share, environment);
environment -= taken;
member.energy += taken;
const auto gathered = std::min(rule::matter_intake, matter_store);
matter_store -= gathered;
member.matter += gathered;
}
for (auto& member : members) {
if (!member.alive) {
continue;
}
++member.age;
if (member.age >= rule::lifespan) {
member.alive = false;
detritus_energy += member.energy;
detritus_matter += member.matter;
member.energy = 0;
member.matter = 0;
++deaths;
}
}
std::uint64_t population = 0;
for (const auto& member : members) {
population += member.alive ? 1 : 0;
}
// Oldest first, as the rule requires, with the index breaking ties so the
// order is total. Insertion order would have allocated contested slots to
// different parents than the aggregate run does, which would have shown up
// in the comparison as if resolution had caused it.
std::vector<std::size_t> eligible;
for (std::size_t index = 0; index < members.size(); ++index) {
const auto& member = members[index];
if (!member.alive || !rule::breeds(member.age, member.energy)) {
continue;
}
if (member.matter < rule::investment_matter) {
continue;
}
eligible.push_back(index);
}
std::ranges::sort(eligible, [&](std::size_t left, std::size_t right) {
if (members[left].age != members[right].age) {
return members[left].age > members[right].age;
}
return left < right;
});
for (const auto index : eligible) {
if (population >= capacity) {
break;
}
auto& member = members[index];
member.energy -= rule::investment_energy;
member.matter -= rule::investment_matter;
members.push_back({0, rule::investment_energy, rule::investment_matter, true});
++population;
++births;
}
}
};
IndividualRun founding_individuals(std::uint64_t count) {
IndividualRun run;
// Deliberately spread: variation is what averaging destroys, so a fixture
// where everyone is identical would measure nothing.
for (std::uint64_t index = 0; index < count; ++index) {
run.members.push_back({index % 60, 20 + index, 50 + index, true});
}
run.environment = 100'000'000;
run.matter_store = 100'000'000;
return run;
}
// ---------------------------------------------------------------------------
// Aggregate resolution. Real cohort records, real ledger, real conversions. The
// class state is advanced by the same five stages applied to a class average.
// ---------------------------------------------------------------------------
struct AggregateClass {
std::uint64_t age_low{};
std::uint64_t age_high{};
std::uint64_t count{};
std::uint64_t energy{}; // held by the class in total
std::uint64_t matter{};
};
struct AggregateRun {
std::vector<AggregateClass> classes;
std::uint64_t width{};
std::uint64_t environment{};
std::uint64_t matter_store{};
std::uint64_t detritus_energy{};
std::uint64_t detritus_matter{};
std::uint64_t births{};
std::uint64_t deaths{};
std::uint64_t capacity{rule::capacity};
[[nodiscard]] Census census() const {
Census now;
for (const auto& age : classes) {
now.living += age.count;
now.energy += age.energy;
now.matter += age.matter;
}
now.births = births;
now.deaths = deaths;
return now;
}
[[nodiscard]] std::uint64_t total_energy() const {
std::uint64_t total = environment + detritus_energy;
for (const auto& age : classes) {
total += age.energy;
}
return total;
}
[[nodiscard]] std::uint64_t total_matter() const {
std::uint64_t total = matter_store + detritus_matter;
for (const auto& age : classes) {
total += age.matter;
}
return total;
}
void step() {
std::uint64_t living = 0;
for (const auto& age : classes) {
living += age.count;
}
const auto share = rule::per_capita(living);
// Starvation, judged on the class average. This is the resolution error:
// the average pays for everyone until it cannot, and then the class goes
// together, where individuals would have starved one at a time.
for (auto& age : classes) {
if (age.count == 0) {
continue;
}
if (rule::starves(age.energy / age.count)) {
detritus_energy += age.energy;
detritus_matter += age.matter;
deaths += age.count;
age.count = 0;
age.energy = 0;
age.matter = 0;
}
}
std::erase_if(classes, [](const AggregateClass& age) { return age.count == 0; });
for (auto& age : classes) {
const auto owed = rule::upkeep_energy * age.count;
age.energy -= owed;
detritus_energy += owed;
const auto paid = std::min(age.matter, rule::upkeep_matter * age.count);
age.matter -= paid;
detritus_matter += paid;
}
for (auto& age : classes) {
const auto wanted = share * age.count;
// The same bound, and the same reason for checking it: a shared store
// that ran out would make intake depend on the order classes are
// visited in, which is not a resolution effect.
check(environment >= wanted);
check(matter_store >= rule::matter_intake * age.count);
const auto taken = std::min(wanted, environment);
environment -= taken;
age.energy += taken;
const auto gathered = std::min(rule::matter_intake * age.count, matter_store);
matter_store -= gathered;
age.matter += gathered;
}
// Ageing shifts the class bounds rather than moving members between
// classes, so no member ever has to be placed by an age the record cannot
// know. A class is a birth cohort and stays one.
for (auto& age : classes) {
++age.age_low;
++age.age_high;
}
for (auto& age : classes) {
if (age.age_low >= rule::lifespan) {
detritus_energy += age.energy;
detritus_matter += age.matter;
deaths += age.count;
age.count = 0;
age.energy = 0;
age.matter = 0;
}
}
std::erase_if(classes, [](const AggregateClass& age) { return age.count == 0; });
std::uint64_t population = 0;
for (const auto& age : classes) {
population += age.count;
}
std::uint64_t newborns = 0;
std::uint64_t taken_energy = 0;
std::uint64_t taken_matter = 0;
// Oldest class first, which is the same allocation rule the individual run
// follows. The classes are held youngest-first, so this walks them in
// reverse rather than relying on the storage order.
for (auto& age : std::ranges::reverse_view(classes)) {
if (age.count == 0 || population + newborns >= capacity) {
continue;
}
const auto average_energy = age.energy / age.count;
const auto average_matter = age.matter / age.count;
if (!rule::breeds(age.age_low, average_energy)) {
continue;
}
if (average_matter < rule::investment_matter) {
continue;
}
auto breeding = age.count;
if (population + newborns + breeding > capacity) {
breeding = capacity - population - newborns;
}
const auto energy_moved = rule::investment_energy * breeding;
const auto matter_moved = rule::investment_matter * breeding;
if (energy_moved > age.energy || matter_moved > age.matter) {
continue;
}
age.energy -= energy_moved;
age.matter -= matter_moved;
taken_energy += energy_moved;
taken_matter += matter_moved;
newborns += breeding;
}
if (newborns > 0) {
// Ageing shifted every class up by one, so nothing now starts at zero.
// The youngest class is extended down to cover the newborns while it is
// still narrower than the declared width, and otherwise a new one
// opens. That keeps the classes contiguous, ascending and never wider
// than the width, which is what makes the state a representable
// cohort: bounds that merely shift would overlap the moment a class
// was opened part way through an interval.
const auto at = std::ranges::min_element(
classes, {}, [](const AggregateClass& age) { return age.age_low; });
if (at != classes.end() && at->age_low == 1 && at->age_high - at->age_low < width) {
at->age_low = 0;
at->count += newborns;
at->energy += taken_energy;
at->matter += taken_matter;
} else {
classes.push_back({0, 1, newborns, taken_energy, taken_matter});
}
births += newborns;
} else {
// A class that opened and then had no births still has to grow to the
// declared width rather than staying one tick wide for ever, or the
// structure would drift towards one class per tick.
const auto at = std::ranges::min_element(
classes, {}, [](const AggregateClass& age) { return age.age_low; });
if (at != classes.end() && at->age_low == 1 && at->age_high - at->age_low < width) {
at->age_low = 0;
}
}
std::ranges::sort(classes, {}, [](const AggregateClass& age) { return age.age_low; });
}
};
AggregateRun founding_classes(const IndividualRun& source, std::uint64_t width) {
AggregateRun run;
run.width = width;
run.environment = source.environment;
run.matter_store = source.matter_store;
for (const auto& member : source.members) {
if (!member.alive) {
continue;
}
const auto low = member.age / width * width;
const auto at = std::ranges::find_if(
run.classes, [&](const AggregateClass& age) { return age.age_low == low; });
if (at == run.classes.end()) {
run.classes.push_back({low, low + width, 1, member.energy, member.matter});
} else {
++at->count;
at->energy += member.energy;
at->matter += member.matter;
}
}
std::ranges::sort(run.classes, {}, [](const AggregateClass& age) { return age.age_low; });
check(run.classes.size() <= max_age_classes);
return run;
}
// Whether the aggregate state is something a cohort record can actually hold. The
// experiment is worthless if it measures a model the library could not represent,
// so this is checked at every step rather than assumed.
[[nodiscard]] bool representable(const AggregateRun& run) {
if (run.classes.empty()) {
return true; // Vacancy is representable; ADR-0036 has a factory for it.
}
CohortDraft probe;
probe.representation_version = cohort_representation_version;
probe.habitat = {7};
probe.genome = 3;
probe.owner = {11, 1};
probe.last_tick = Tick{0};
probe.revision = 1;
probe.conversion = 1;
probe.reservoir = {1};
for (const auto& age : run.classes) {
probe.classes.push_back(
{age.age_low, age.age_high, age.count, spread(age.energy, age.matter), 0});
}
return Cohort::create(std::move(probe)).has_value();
}
// Every living member as (age, energy, matter), sorted. Comparing censuses is not
// enough to establish that the two runs allocate contested breeding slots to the
// same parents: whoever breeds hands the same investment to a child either way, so
// the totals agree while the distribution does not, and the disagreement only
// reaches a census many ticks later. The control therefore compares distributions.
using Portrait = std::vector<std::array<std::uint64_t, 3>>;
[[nodiscard]] Portrait portrait(const IndividualRun& run) {
Portrait rows;
for (const auto& member : run.members) {
if (member.alive) {
rows.push_back({member.age, member.energy, member.matter});
}
}
std::ranges::sort(rows);
return rows;
}
// Only meaningful at width one, where a class holds members of a single age. A
// class may still hold several of them, because several can be born in one tick, so
// each is expanded into its equal share; the division has to be exact or the
// expansion would not be the distribution it claims to be, and that is checked
// rather than assumed.
[[nodiscard]] Portrait portrait(const AggregateRun& run) {
Portrait rows;
for (const auto& age : run.classes) {
check(age.count > 0);
check(age.energy % age.count == 0);
check(age.matter % age.count == 0);
for (std::uint64_t index = 0; index < age.count; ++index) {
rows.push_back({age.age_low, age.energy / age.count, age.matter / age.count});
}
}
std::ranges::sort(rows);
return rows;
}
// Ages ascend with the index, so the oldest member is the last inserted and the
// youngest class is the first stored. Oldest-first therefore disagrees with both of
// the orders this fixture could have drifted into: allocating in insertion order
// would pick the first member, and walking the classes as stored would pick the
// youngest class. Each of those, introduced alone, makes the two runs choose
// different parents, which is what the control has to be able to see.
IndividualRun founding_contested(std::uint64_t count, std::uint64_t capacity) {
IndividualRun run;
for (std::uint64_t index = 0; index < count; ++index) {
run.members.push_back({rule::maturity + index, 100 + index, 60 + index, true});
}
run.environment = 100'000'000;
run.matter_store = 100'000'000;
run.capacity = capacity;
return run;
}
using namespace evo::fixture;
constexpr Rule rule{};
// ---------------------------------------------------------------------------
// The instrument check. With one member per class a class average is that member,
@@ -575,7 +71,7 @@ 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);
aggregate.capacity = individual.capacity;
CHECK(aggregate.rule.capacity == individual.rule.capacity);
CHECK(aggregate.classes.size() == count);
CHECK(portrait(individual) == portrait(aggregate));
bool contested = false;
@@ -589,12 +85,13 @@ void contested_breeding_slots_go_to_the_same_parents() {
continue;
}
++living;
if (rule::breeds(member.age + 1, member.energy) &&
member.matter >= rule::investment_matter) {
if (rule.breeds(member.age + 1, member.energy) &&
member.matter >= rule.investment_matter) {
++eligible;
}
}
const auto free_slots = individual.capacity > living ? individual.capacity - living : 0;
const auto free_slots =
individual.rule.capacity > living ? individual.rule.capacity - living : 0;
if (eligible > free_slots && free_slots > 0) {
contested = true;
}
@@ -610,7 +107,7 @@ void contested_breeding_slots_go_to_the_same_parents() {
// allocation and is just the first control again with fewer members.
CHECK(contested);
CHECK(individual.census().births > 0);
CHECK(individual.census().living == individual.capacity);
CHECK(individual.census().living == individual.rule.capacity);
}
// ---------------------------------------------------------------------------
@@ -626,15 +123,6 @@ struct Divergence {
std::uint64_t energy_gap_per_thousand{};
};
std::uint64_t gap_per_thousand(std::uint64_t left, std::uint64_t right) {
const auto high = std::max(left, right);
const auto low = std::min(left, right);
if (high == 0) {
return 0;
}
return (high - low) * 1000 / high;
}
Divergence measure(std::uint64_t width, std::uint64_t ticks) {
auto individual = founding_individuals(100);
auto aggregate = founding_classes(individual, width);
@@ -754,7 +242,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
// 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);
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) {
@@ -776,7 +264,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
gather.tick = Tick{0};
gather.revision = 1;
gather.destination = backing;
for (std::uint64_t low = 0; low < rule::lifespan; low += 50) {
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);
@@ -848,7 +336,7 @@ void the_full_scenario_conserves_and_keeps_its_genome() {
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) {
if (count == 0 || drawn + count > rule.capacity) {
continue;
}
draws.push_back({index, count});