Files
aevolution/include/evo/biology/development.hpp
T
dingoandClaude Opus 5 36ee71cfe9 Decide affordability where composition is known
A construction transition could require more of an element than was
available, because the check compared net mass. A step growing a body
from 13 to 14 femtograms nets one femtogram but acquires a carbon and a
nitrogen while freeing one of other, and released other pays for neither.
Matching totals let one element silently fund another.

Net mass was never the right question, and the layer asking it could not
ask a better one: plan_development has no composition. A single scalar
pool could not carry the answer either, since it cannot say that carbon
is plentiful while nitrogen is not. The environment now states what is
available per ledger channel.

plan_development keeps a total-mass bound, which is sound because net
never exceeds gross, but it is a proposal rather than an authority.
metabolic_budget narrows it to the largest step whose own intake fits
channel by channel, and reports the growth that step actually funds. That
revises ADR-0031 on this point, recorded in both ADRs.

The tests place a single femtogram in each channel in turn and require
that no step needing a different element is funded, that nothing is
acquired beyond what is present, and that the mass-only plan would have
admitted the step; a carbon and a nitrogen together then fund it exactly.
Across six target sizes by seven growth fractions by four stock levels,
every reported intake fits the availability channel by channel and never
exceeds the proposed step. Confirmed to fail with the check removed.

The releasing case moved to a target of 20 femtograms, where the step
occurs at the full rule step rather than depending on a scarce supply
that the corrected plan no longer bounds the same way.

Native Release, clang-tidy analysis, ASan and format checks pass 19/19.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-23 13:02:44 -04:00

74 lines
3.8 KiB
C++

#pragma once
#include "evo/accounting/ledger.hpp"
#include "evo/biology/genome.hpp"
namespace evo::biology {
// What an organism has actually built and lost. Runtime state, never written
// back into the genome: heredity must not carry acquired condition.
struct GrowthState {
std::uint32_t realized_per_thousand{};
std::uint32_t damage_per_thousand{};
auto operator<=>(const GrowthState&) const = default;
};
struct EnvironmentState {
std::uint32_t temperature_millikelvin{};
// What is there to build from, per ledger channel. A single pool could not
// say that carbon is plentiful while nitrogen is not, which is the whole
// question once a body has a composition. Nothing here is spent or reserved.
accounting::Inventory available{};
auto operator<=>(const EnvironmentState&) const = default;
};
// Chosen constants, reviewable as a unit and selected by the genome's
// development version. Declared model parameters, not balance.
struct DevelopmentRules {
std::uint64_t structure_density; // femtograms per cubic micrometre
std::uint64_t membrane_density; // femtograms per cubic micrometre
std::uint64_t maintenance_per_kilogram; // picojoules per tick per 1000 fg
std::uint64_t membrane_upkeep_per_kilo; // picojoules per tick per 1000 fg
std::uint64_t construction_per_kilogram; // picojoules per 1000 fg built
std::uint64_t reference_surface; // square micrometres
std::uint32_t reference_temperature; // millikelvin
std::uint32_t growth_step_per_thousand; // most one plan may advance
};
// Dimensioned parameters derived from a genome and its runtime state. A derived
// phenotype is not a viability claim and holds no fitness score.
struct Phenotype {
std::uint64_t structural_mass{}; // femtograms
std::uint64_t membrane_mass{}; // femtograms
std::uint64_t total_mass{}; // femtograms
std::uint32_t extent{}; // micrometres, the cube-model side length
std::uint64_t surface{}; // square micrometres
std::uint64_t maintenance{}; // picojoules per tick
std::uint32_t movement_speed{}; // micrometres per tick; zero without the capability
std::uint64_t ingestion_rate{}; // femtograms per tick; zero without the capability
std::uint32_t conversion_per_thousand{};
// Millikelvin beyond the genome's tolerance. A reported quantity, not a rule.
std::uint32_t thermal_shortfall{};
auto operator<=>(const Phenotype&) const = default;
};
// A proposal. It reserves nothing, pays for nothing and commits nothing; the
// matching transfer does not exist until M3.3.
struct DevelopmentPlan {
GrowthState after{};
std::uint64_t material_required{};
std::uint64_t energy_required{};
auto operator<=>(const DevelopmentPlan&) const = default;
};
enum class DevelopmentError : std::uint8_t { unsupported_rules, invalid_growth, overflow };
[[nodiscard]] std::expected<DevelopmentRules, DevelopmentError>
rules_for(std::uint32_t development_version);
// Pure: a phenotype is recomputed from retained inputs rather than cached, so a
// cached copy can always be checked against a recomputation.
[[nodiscard]] std::expected<Phenotype, DevelopmentError>
derive_phenotype(const Genome& genome, GrowthState growth, EnvironmentState environment);
// Advances realized growth toward the target by at most the rule step, reduced to
// the largest step the available mass and energy admit. This bounds by total mass
// only: it cannot see which elements a step consumes, so it is a proposal and not
// an affordability authority. `metabolic_budget` decides that, per channel, and
// can only narrow this further. Never repairs damage.
[[nodiscard]] std::expected<DevelopmentPlan, DevelopmentError>
plan_development(const Genome& genome, GrowthState growth, EnvironmentState environment);
} // namespace evo::biology