M4.1 defines the tier 2 record and who may act on it, and nothing else: no collapse transaction, no population advance, no materialization, no habitat geometry. Those are M4.2 to M4.4 and each needs its own decision. The named risk for this step is that population averages hide viable outliers, which is a property of the record rather than of the maths applied to it later, so it is answered here. Age classes each carry their own count and their own reserve. A count with a mean reserve cannot tell a provisioned cohort from one where half the members hold nothing, and nothing downstream can recover what that discarded. Within a class members are indistinguishable; that is the declared resolution and a stated loss. No accessor returns a mean, because an average that is easy to reach becomes the authority. Totals are summed from the classes rather than stored beside them, following the archive's rule that a second tally is a thing that can disagree. Lineage is not a field at all: ancestry is resolved from the genome through the archive, so a cohort cannot contradict it or invent parentage from membership. Residuals are integer numerators strictly below one member and are never added to a count. Ownership is enforced rather than described. One record per habitat and genome makes no-inventory-spendable-in-two-tiers unrepresentable instead of forbidden, and replacement is refused under a different worker or an older epoch. That is a single-process invariant; fencing between workers is M7 and M10. The approximation bound is carried and never computed, since carrying a bound is not meeting one. All nine guards were confirmed load-bearing by removing each and rerunning. An earlier sweep reporting none of them load-bearing was wrong and discarded: it wrote to /tmp, which Git Bash and PowerShell resolve differently, so nothing was ever mutated. Release 34/34, analysis, ASan 34/34 and clang-format all ran and passed here. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
322 lines
14 KiB
C++
322 lines
14 KiB
C++
#include "evo/biology/lineage.hpp"
|
|
#include "evo/ecology/cohort.hpp"
|
|
|
|
#include <expected>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
#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("cohort line " + std::to_string(location.line()));
|
|
}
|
|
}
|
|
// Variadic so a braced initializer containing a comma stays one argument.
|
|
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
|
|
|
// Asserting on .error() alone is undefined when the call unexpectedly succeeded,
|
|
// which would let a broken guard pass quietly. This checks the failure first.
|
|
template <typename T>
|
|
[[nodiscard]] bool refused(const std::expected<T, CohortError>& result, CohortError expected) {
|
|
return !result.has_value() && result.error() == expected;
|
|
}
|
|
|
|
Inventory held(std::uint64_t value) {
|
|
return {{value}, {Femtograms{value}, Femtograms{value}, Femtograms{value}, Femtograms{value}}};
|
|
}
|
|
CohortDraft draft() {
|
|
CohortDraft source;
|
|
source.representation_version = cohort_representation_version;
|
|
source.habitat = {7};
|
|
source.genome = 3;
|
|
source.owner = {11, 2};
|
|
source.last_tick = Tick{900};
|
|
source.conversion = 5;
|
|
source.classes = {{0, 100, 40, held(400), 0},
|
|
{100, 200, 25, held(900), 250'000},
|
|
{200, 300, 10, held(1'000), 999'999}};
|
|
source.bound = {2, held(30)};
|
|
return source;
|
|
}
|
|
Cohort valid() {
|
|
const auto cohort = Cohort::create(draft());
|
|
check(cohort.has_value());
|
|
return *cohort;
|
|
}
|
|
Cohort built(const CohortDraft& source) {
|
|
const auto cohort = Cohort::create(source);
|
|
check(cohort.has_value());
|
|
return *cohort;
|
|
}
|
|
|
|
void a_cohort_keeps_exactly_what_it_was_given() {
|
|
const auto cohort = valid();
|
|
CHECK(cohort.representation_version() == cohort_representation_version);
|
|
CHECK(cohort.habitat() == HabitatId{7});
|
|
CHECK(cohort.genome() == 3);
|
|
CHECK(cohort.owner() == Owner{11, 2});
|
|
CHECK(cohort.last_tick() == Tick{900});
|
|
CHECK(cohort.conversion() == 5);
|
|
CHECK(cohort.bound().count == 2);
|
|
CHECK(cohort.bound().inventory == held(30));
|
|
CHECK(cohort.classes().size() == 3);
|
|
// Totals are derived from the classes, so they cannot disagree with them.
|
|
CHECK(cohort.count() == 75);
|
|
CHECK(cohort.reserve() == held(2'300));
|
|
CHECK(cohort.residual() == 1'249'999);
|
|
std::uint64_t counted = 0;
|
|
Inventory reserved{};
|
|
for (const auto& age : cohort.classes()) {
|
|
counted += age.count;
|
|
reserved.energy.value += age.reserve.energy.value;
|
|
for (std::size_t channel = 0; channel < reserved.matter.size(); ++channel) {
|
|
reserved.matter[channel].value += age.reserve.matter[channel].value;
|
|
}
|
|
}
|
|
CHECK(counted == cohort.count());
|
|
CHECK(reserved == cohort.reserve());
|
|
// Summed across classes the residual may exceed a member; the per-class bound
|
|
// is what is invariant, and a fraction is never counted as a member.
|
|
CHECK(cohort.residual() > residual_scale);
|
|
CHECK(cohort.count() == 75);
|
|
}
|
|
|
|
void the_record_keeps_a_distribution_and_not_an_average() {
|
|
// Two cohorts with identical totals but different structure: one where every
|
|
// member is provisioned and one where a young class holds nothing at all. A
|
|
// record storing a count and a mean reserve could not tell these apart, which
|
|
// is exactly how an average hides whether anyone would survive.
|
|
auto spread = draft();
|
|
spread.classes = {{0, 100, 50, held(500), 0}, {100, 200, 50, held(500), 0}};
|
|
auto skewed = draft();
|
|
skewed.classes = {{0, 100, 50, held(0), 0}, {100, 200, 50, held(1'000), 0}};
|
|
const auto even = built(spread);
|
|
const auto uneven = built(skewed);
|
|
CHECK(even.count() == uneven.count());
|
|
CHECK(even.reserve() == uneven.reserve());
|
|
CHECK(even != uneven); // The totals agree; the records do not.
|
|
CHECK(even.classes()[0].reserve != uneven.classes()[0].reserve);
|
|
// A class with members but no reserve is a legitimate state, not an error:
|
|
// it is precisely the outlier an average would have dissolved.
|
|
CHECK(uneven.classes()[0].count == 50);
|
|
CHECK(uneven.classes()[0].reserve == Inventory{});
|
|
}
|
|
|
|
void every_invariant_is_rejected_by_name() {
|
|
auto wrong_version = draft();
|
|
wrong_version.representation_version = cohort_representation_version + 1;
|
|
CHECK(refused(Cohort::create(wrong_version), CohortError::unsupported_version));
|
|
// Each identity a cohort names has to name something, including its owner:
|
|
// a record nobody is responsible for integrating has no owner at all.
|
|
for (auto missing : {0U, 1U, 2U, 3U, 4U}) {
|
|
auto blank = draft();
|
|
if (missing == 0) {
|
|
blank.habitat = {};
|
|
} else if (missing == 1) {
|
|
blank.genome = 0;
|
|
} else if (missing == 2) {
|
|
blank.owner.worker = 0;
|
|
} else if (missing == 3) {
|
|
blank.owner.epoch = 0;
|
|
} else {
|
|
blank.conversion = 0;
|
|
}
|
|
CHECK(refused(Cohort::create(blank), CohortError::invalid_identity));
|
|
}
|
|
auto none = draft();
|
|
none.classes.clear();
|
|
CHECK(refused(Cohort::create(none), CohortError::no_age_classes));
|
|
auto too_many = draft();
|
|
too_many.classes.clear();
|
|
for (std::uint64_t index = 0; index <= max_age_classes; ++index) {
|
|
too_many.classes.push_back({index * 10, index * 10 + 10, 1, held(1), 0});
|
|
}
|
|
CHECK(refused(Cohort::create(too_many), CohortError::overflow));
|
|
// An empty range makes a member's class impossible, an inverted one likewise,
|
|
// and an overlap or a descending order makes it ambiguous.
|
|
auto empty_range = draft();
|
|
empty_range.classes[1].age_high = empty_range.classes[1].age_low;
|
|
CHECK(refused(Cohort::create(empty_range), CohortError::unordered_age_classes));
|
|
auto inverted = draft();
|
|
inverted.classes[1].age_high = inverted.classes[1].age_low - 1;
|
|
CHECK(refused(Cohort::create(inverted), CohortError::unordered_age_classes));
|
|
auto overlapping = draft();
|
|
overlapping.classes[1].age_low = overlapping.classes[0].age_high - 1;
|
|
CHECK(refused(Cohort::create(overlapping), CohortError::unordered_age_classes));
|
|
auto descending = draft();
|
|
std::swap(descending.classes[0], descending.classes[2]);
|
|
CHECK(refused(Cohort::create(descending), CohortError::unordered_age_classes));
|
|
// A class with neither members nor a fraction owed is a boundary, not a class.
|
|
auto hollow = draft();
|
|
hollow.classes[1].count = 0;
|
|
hollow.classes[1].residual = 0;
|
|
hollow.classes[1].reserve = {};
|
|
CHECK(refused(Cohort::create(hollow), CohortError::empty_age_class));
|
|
// Reserve belongs to members; with none it would be biomass owned by nobody.
|
|
auto orphaned = draft();
|
|
orphaned.classes[1].count = 0;
|
|
orphaned.classes[1].residual = 1;
|
|
CHECK(refused(Cohort::create(orphaned), CohortError::unowned_reserve));
|
|
// A class owed a fraction and holding nothing is valid: nothing is unowned.
|
|
auto owed = draft();
|
|
owed.classes[1].count = 0;
|
|
owed.classes[1].residual = 1;
|
|
owed.classes[1].reserve = {};
|
|
CHECK(Cohort::create(owed).has_value());
|
|
// At a whole member a fraction is a member, so the bound is strict.
|
|
auto whole = draft();
|
|
whole.classes[1].residual = residual_scale;
|
|
CHECK(refused(Cohort::create(whole), CohortError::residual_out_of_range));
|
|
auto just_under = draft();
|
|
just_under.classes[1].residual = residual_scale - 1;
|
|
CHECK(Cohort::create(just_under).has_value());
|
|
// Summation rejects rather than wrapping, on counts and on every channel.
|
|
constexpr auto most = std::numeric_limits<std::uint64_t>::max();
|
|
auto counts = draft();
|
|
counts.classes[0].count = most;
|
|
counts.classes[1].count = 1;
|
|
CHECK(refused(Cohort::create(counts), CohortError::overflow));
|
|
auto energy = draft();
|
|
energy.classes[0].reserve.energy.value = most;
|
|
energy.classes[1].reserve.energy.value = 1;
|
|
CHECK(refused(Cohort::create(energy), CohortError::overflow));
|
|
for (std::size_t channel = 0; channel < 4; ++channel) {
|
|
auto matter = draft();
|
|
matter.classes[0].reserve.matter[channel].value = most;
|
|
matter.classes[1].reserve.matter[channel].value = 1;
|
|
CHECK(refused(Cohort::create(matter), CohortError::overflow));
|
|
}
|
|
// No negative reserve is representable, because every quantity here is
|
|
// unsigned. What is rejected is a declared state that would require one.
|
|
static_assert(!std::is_signed_v<decltype(Femtograms{}.value)>);
|
|
static_assert(!std::is_signed_v<decltype(Picojoules{}.value)>);
|
|
static_assert(!std::is_signed_v<decltype(AgeClass{}.count)>);
|
|
}
|
|
|
|
void one_habitat_and_genome_holds_one_cohort() {
|
|
CohortRegistry registry;
|
|
CHECK(registry.install(valid()).has_value());
|
|
CHECK(registry.size() == 1);
|
|
// A second record of the same genome in the same habitat would be a second
|
|
// place the same biomass could be spent, whoever claims to own it.
|
|
CHECK(refused(registry.install(valid()), CohortError::duplicate_cohort));
|
|
auto differing_owner = draft();
|
|
differing_owner.owner = {99, 4};
|
|
CHECK(refused(registry.install(built(differing_owner)), CohortError::duplicate_cohort));
|
|
CHECK(registry.size() == 1);
|
|
// Another genome, or the same genome elsewhere, is a different record.
|
|
auto other_genome = draft();
|
|
other_genome.genome = 4;
|
|
auto other_habitat = draft();
|
|
other_habitat.habitat = {8};
|
|
CHECK(registry.install(built(other_genome)).has_value());
|
|
CHECK(registry.install(built(other_habitat)).has_value());
|
|
CHECK(registry.size() == 3);
|
|
// Every record stays findable whatever order they arrived in.
|
|
CHECK(registry.find(HabitatId{7}, 3)->owner() == Owner{11, 2});
|
|
CHECK(registry.find(HabitatId{7}, 4)->genome() == 4);
|
|
CHECK(registry.find(HabitatId{8}, 3)->habitat() == HabitatId{8});
|
|
CHECK(refused(registry.find(HabitatId{7}, 5), CohortError::unknown_cohort));
|
|
CHECK(refused(registry.find(HabitatId{9}, 3), CohortError::unknown_cohort));
|
|
}
|
|
|
|
void only_the_recorded_owner_may_replace_a_cohort() {
|
|
CohortRegistry registry;
|
|
CHECK(registry.install(valid()).has_value());
|
|
// A different worker is refused however current its epoch.
|
|
auto intruder = draft();
|
|
intruder.owner = {12, 99};
|
|
CHECK(refused(registry.replace(built(intruder)), CohortError::wrong_owner));
|
|
// A writer holding an older view of its own cohort is refused too.
|
|
auto stale = draft();
|
|
stale.owner = {11, 1};
|
|
CHECK(refused(registry.replace(built(stale)), CohortError::stale_epoch));
|
|
CHECK(registry.find(HabitatId{7}, 3)->last_tick() == Tick{900});
|
|
// The owner rewriting its own epoch, or advancing it, succeeds.
|
|
auto same = draft();
|
|
same.last_tick = Tick{1'000};
|
|
CHECK(registry.replace(built(same)).has_value());
|
|
CHECK(registry.find(HabitatId{7}, 3)->last_tick() == Tick{1'000});
|
|
auto advanced = draft();
|
|
advanced.owner = {11, 3};
|
|
advanced.last_tick = Tick{1'100};
|
|
CHECK(registry.replace(built(advanced)).has_value());
|
|
CHECK(registry.find(HabitatId{7}, 3)->owner() == Owner{11, 3});
|
|
// Having advanced, the previously current epoch is now the stale one.
|
|
CHECK(refused(registry.replace(built(same)), CohortError::stale_epoch));
|
|
CHECK(registry.find(HabitatId{7}, 3)->last_tick() == Tick{1'100});
|
|
// A record naming a different habitat or genome is not a newer view of this
|
|
// one, and replacing a cohort never installed is refused outright.
|
|
auto elsewhere = draft();
|
|
elsewhere.habitat = {8};
|
|
CHECK(refused(registry.replace(built(elsewhere)), CohortError::unknown_cohort));
|
|
auto another = draft();
|
|
another.genome = 4;
|
|
CHECK(refused(registry.replace(built(another)), CohortError::unknown_cohort));
|
|
CHECK(registry.size() == 1); // A refused replacement installs nothing.
|
|
}
|
|
|
|
void lineage_stays_the_archives_answer() {
|
|
// A cohort names a genome and never stores its ancestry, so it cannot claim a
|
|
// parentage the archive would contradict, and invents none from membership.
|
|
using namespace evo::biology;
|
|
GenomeDraft founder;
|
|
founder.id = 3;
|
|
founder.origin_event = 1;
|
|
founder.development_version = 1;
|
|
founder.capabilities = {{Capability::energy_conversion, 400, 0},
|
|
{Capability::membrane, 120, 0},
|
|
{Capability::target_size, 2'000, 0}};
|
|
const auto ancestor = Genome::create(founder);
|
|
CHECK(ancestor.has_value());
|
|
auto descended = founder;
|
|
descended.id = 9;
|
|
descended.origin_event = 2;
|
|
descended.parents = {3};
|
|
const auto child = Genome::create(descended);
|
|
CHECK(child.has_value());
|
|
LineageArchive archive;
|
|
CHECK(archive.admit(*ancestor).has_value());
|
|
CHECK(archive.admit(*child).has_value());
|
|
auto carrying = draft();
|
|
carrying.genome = 9;
|
|
const auto cohort = built(carrying);
|
|
// The cohort contributes the identity; the archive contributes the ancestry.
|
|
const auto line = archive.ancestry(cohort.genome());
|
|
CHECK(line.has_value());
|
|
CHECK(line->size() == 2);
|
|
CHECK(line->front() == 3);
|
|
CHECK(line->back() == 9);
|
|
CHECK(archive.find(cohort.genome()).has_value());
|
|
// Distinct genomes are never averaged into one, so each keeps its own record.
|
|
CohortRegistry registry;
|
|
CHECK(registry.install(cohort).has_value());
|
|
auto sibling = draft();
|
|
sibling.genome = 3;
|
|
CHECK(registry.install(built(sibling)).has_value());
|
|
CHECK(registry.size() == 2);
|
|
CHECK(registry.find(HabitatId{7}, 3)->genome() != registry.find(HabitatId{7}, 9)->genome());
|
|
}
|
|
} // namespace
|
|
int main() try {
|
|
a_cohort_keeps_exactly_what_it_was_given();
|
|
the_record_keeps_a_distribution_and_not_an_average();
|
|
every_invariant_is_rejected_by_name();
|
|
one_habitat_and_genome_holds_one_cohort();
|
|
only_the_recorded_owner_may_replace_a_cohort();
|
|
lineage_stays_the_archives_answer();
|
|
std::cout << "PASS cohort state, declared resolution and exclusive ownership\n";
|
|
return 0;
|
|
} catch (...) {
|
|
return 1;
|
|
}
|