use rand::Rng;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct GenomeFeature {
pub name: String,
pub dominance: f32,
pub origin: String,
}
#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct ConceptGenome {
pub id: String,
pub parent_ids: Vec<String>,
pub features: Vec<GenomeFeature>,
pub generation: u32,
pub mutation_rate: f32,
pub tick_born: u64,
pub fitness: f32,
}
impl ConceptGenome {
pub fn primordial(name: &str, tick: u64) -> Self {
let mut rng = rand::thread_rng();
let id = format!("genome-{}", rng.gen_range(1000..9999));
Self {
id,
parent_ids: vec![],
features: vec![GenomeFeature {
name: name.to_string(),
dominance: 1.0,
origin: "seed_garden".to_string(),
}],
generation: 0,
mutation_rate: 0.1,
tick_born: tick,
fitness: 0.5,
}
}
pub fn inherit(
parent_a: &ConceptGenome,
parent_b: &ConceptGenome,
_name: &str,
tick: u64,
) -> Self {
let mut rng = rand::thread_rng();
let id = format!("genome-{}", rng.gen_range(1000..9999));
let mut features = Vec::new();
for f in &parent_a.features {
features.push(GenomeFeature {
name: f.name.clone(),
dominance: f.dominance * 0.9,
origin: f.origin.clone(),
});
}
for f in &parent_b.features {
if !features.iter().any(|x| x.name == f.name) {
features.push(GenomeFeature {
name: f.name.clone(),
dominance: f.dominance * 0.7,
origin: f.origin.clone(),
});
}
}
let mut genome = Self {
id,
parent_ids: vec![parent_a.id.clone(), parent_b.id.clone()],
features,
generation: parent_a.generation.max(parent_b.generation) + 1,
mutation_rate: (parent_a.mutation_rate + parent_b.mutation_rate) / 2.0 + 0.01,
tick_born: tick,
fitness: (parent_a.fitness + parent_b.fitness) / 2.0,
};
genome.mutate(tick);
genome
}
pub fn mutate(&mut self, tick: u64) {
let mut rng = rand::thread_rng();
for f in &mut self.features {
if rng.gen_bool(self.mutation_rate as f64) {
f.dominance = (f.dominance + rng.gen_range(-0.3..0.3)).clamp(0.0, 1.0);
}
}
if rng.gen_bool((self.mutation_rate * 0.3) as f64) {
let new_feature = GenomeFeature {
name: format!("nova_{}", tick),
dominance: 0.3,
origin: "mutation".to_string(),
};
self.features.push(new_feature);
}
if self.features.len() > 1 && rng.gen_bool((self.mutation_rate * 0.2) as f64) {
let idx = rng.gen_range(0..self.features.len());
self.features.remove(idx);
}
self.fitness = (self.fitness + rng.gen_range(-0.05..0.05)).clamp(0.0, 1.0);
}
pub fn crispr_edit(&mut self, culprits: &[String], tick: u64) {
for culprit in culprits {
if let Some(f) = self.features.iter_mut().find(|f| f.name.contains(culprit)) {
f.dominance *= 0.7;
self.features.push(GenomeFeature {
name: format!("fix_{}_{}", culprit, tick),
dominance: 0.5,
origin: "crispr".to_string(),
});
}
}
self.fitness = (self.fitness - 0.05).max(0.0);
}
pub fn toggle_expression(&mut self, feature_name: &str, active: bool) -> bool {
if let Some(f) = self.features.iter_mut().find(|f| f.name == feature_name) {
f.dominance = if active { 1.0 } else { 0.1 };
true
} else {
false
}
}
pub fn active_features(&self) -> Vec<&GenomeFeature> {
self.features.iter().filter(|f| f.dominance > 0.5).collect()
}
pub fn feature_count(&self) -> usize {
self.features.len()
}
pub fn active_count(&self) -> usize {
self.active_features().len()
}
pub fn is_primordial(&self) -> bool {
self.parent_ids.is_empty()
}
pub fn adjust_fitness(&mut self, delta: f32) {
self.fitness = (self.fitness + delta).clamp(0.0, 1.0);
}
pub fn lineage(&self) -> String {
if self.parent_ids.is_empty() {
format!("gen{} (primordial)", self.generation)
} else if self.parent_ids.len() == 1 {
format!("gen{} ← {}", self.generation, self.parent_ids[0])
} else {
format!(
"gen{} ← {} + {}",
self.generation, self.parent_ids[0], self.parent_ids[1]
)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn primordial_has_no_parents() {
let g = ConceptGenome::primordial("test", 0);
assert!(g.is_primordial());
assert_eq!(g.generation, 0);
assert!(g.parent_ids.is_empty());
assert_eq!(g.features.len(), 1);
assert_eq!(g.features[0].name, "test");
assert_eq!(g.features[0].dominance, 1.0);
}
#[test]
fn inherit_produces_child_with_lineage() {
let a = ConceptGenome::primordial("a", 0);
let b = ConceptGenome::primordial("b", 0);
let child = ConceptGenome::inherit(&a, &b, "child", 1);
assert_eq!(child.generation, 1);
assert_eq!(child.parent_ids.len(), 2);
assert!(child.parent_ids.contains(&a.id));
assert!(child.parent_ids.contains(&b.id));
assert!(child.feature_count() >= 1);
}
#[test]
fn mutation_adds_or_removes_features() {
let mut g = ConceptGenome::primordial("test", 0);
g.mutation_rate = 1.0; let _before = g.feature_count();
g.mutate(42);
assert!(g.feature_count() >= 1);
assert!((0.0..=1.0).contains(&g.fitness));
}
#[test]
fn crispr_edits_targeted_features() {
let mut g = ConceptGenome::primordial("risky_concept", 0);
g.features.push(GenomeFeature {
name: "overcommit".to_string(),
dominance: 0.8,
origin: "learning".to_string(),
});
g.crispr_edit(&["overcommit".to_string()], 100);
let overcommit = g.features.iter().find(|f| f.name == "overcommit").unwrap();
assert!(overcommit.dominance < 0.8);
let has_fix = g.features.iter().any(|f| f.name.contains("fix_overcommit"));
assert!(has_fix);
assert!(g.fitness < 0.5);
}
#[test]
fn epigenetic_toggle_changes_expression() {
let mut g = ConceptGenome::primordial("test", 0);
let feat_name = g.features[0].name.clone();
assert!(g.toggle_expression(&feat_name, false));
assert_eq!(g.features[0].dominance, 0.1);
assert!(g.toggle_expression(&feat_name, true));
assert_eq!(g.features[0].dominance, 1.0);
assert!(!g.toggle_expression("nonexistent", true));
}
#[test]
fn active_features_filter_by_dominance() {
let mut g = ConceptGenome::primordial("test", 0);
g.features.push(GenomeFeature {
name: "recessive".to_string(),
dominance: 0.2,
origin: "mutation".to_string(),
});
let active = g.active_features();
assert_eq!(active.len(), 1); assert_eq!(g.active_count(), 1);
assert_eq!(g.feature_count(), 2);
}
#[test]
fn lineage_format() {
let g = ConceptGenome::primordial("test", 0);
assert!(g.lineage().contains("primordial"));
let a = ConceptGenome::primordial("a", 0);
let b = ConceptGenome::primordial("b", 0);
let child = ConceptGenome::inherit(&a, &b, "child", 1);
let lineage = child.lineage();
assert!(lineage.contains("gen1"));
assert!(lineage.contains(&a.id));
assert!(lineage.contains(&b.id));
}
#[test]
fn fitness_stays_in_range() {
let mut g = ConceptGenome::primordial("test", 0);
g.adjust_fitness(10.0);
assert_eq!(g.fitness, 1.0);
g.adjust_fitness(-20.0);
assert_eq!(g.fitness, 0.0);
}
#[test]
fn multiple_generations_accumulate() {
let g0 = ConceptGenome::primordial("root", 0);
let g1a = ConceptGenome::primordial("branch_a", 0);
let g1 = ConceptGenome::inherit(&g0, &g1a, "gen1", 1);
assert_eq!(g1.generation, 1);
let g2 = ConceptGenome::inherit(&g1, &g0, "gen2", 2);
assert_eq!(g2.generation, 2);
let g3 = ConceptGenome::inherit(&g2, &g1, "gen3", 3);
assert_eq!(g3.generation, 3);
assert!(g3.mutation_rate > g0.mutation_rate);
}
#[cfg(feature = "serde")]
#[test]
fn serde_roundtrip() {
let g = ConceptGenome::primordial("test", 42);
let json = serde_json::to_string(&g).unwrap();
let g2: ConceptGenome = serde_json::from_str(&json).unwrap();
assert_eq!(g.id, g2.id);
assert_eq!(g.generation, g2.generation);
assert_eq!(g.features.len(), g2.features.len());
}
}