viva_aion - v1.0.0

viva_aion/dream

Dream - DRE Scoring for memory consolidation

Theory

During “sleep” (consolidation phase), VIVA reviews memories and decides which to keep. The DRE score determines survival:

DRE = D × R × E

D = Distinctiveness (how unique/novel)
R = Recency (temporal decay)
E = Emotionality (intensity)

Big Bounce Application

Before death, memories are scored. High DRE memories transcend the Big Bounce and shape the next life.

Low DRE memories are “forgotten” - released back to entropy.

References

Types

DreConfig

</>

Configuration for DRE calculation

pub type DreConfig {
  DreConfig(
    recency_half_life: Int,
    weight_d: Float,
    weight_r: Float,
    weight_e: Float,
    access_bonus: Float,
    importance_multiplier: Float,
    transcendence_bonus: Float,
  )
}

Constructors 

  • DreConfig(
  recency_half_life: Int,
  weight_d: Float,
  weight_r: Float,
  weight_e: Float,
  access_bonus: Float,
  importance_multiplier: Float,
  transcendence_bonus: Float,
)

    Arguments

    recency_half_life

    Recency half-life in ticks (default 1000)

    weight_d

    Weight for distinctiveness (default 0.3)

    weight_r

    Weight for recency (default 0.3)

    weight_e

    Weight for emotionality (default 0.4)

    access_bonus

    Bonus for access count (per access, default 0.02)

    importance_multiplier

    Bonus for importance (multiplier, default 1.5)

    transcendence_bonus

    Bonus for past-life memories (default 0.1)

DreScore

</>

DRE Score result

pub type DreScore {
  DreScore(
    total: Float,
    distinctiveness: Float,
    recency: Float,
    emotionality: Float,
  )
}

Constructors 

  • DreScore(
  total: Float,
  distinctiveness: Float,
  recency: Float,
  emotionality: Float,
)

    Arguments

    total

    Total DRE score [0, 1]

    distinctiveness

    Distinctiveness component [0, 1]

    recency

    Recency component [0, 1]

    emotionality

    Emotionality component [0, 1]

Values

consolidate_for_bounce

</> 
pub fn consolidate_for_bounce(
  bank: memory.MemoryBank,
  max_survivors: Int,
  min_threshold: Float,
) -> memory.MemoryBank

Perform full Big Bounce consolidation

default_config

</> 
pub fn default_config() -> DreConfig

Default DRE configuration

memories_above_threshold

</> 
pub fn memories_above_threshold(
  bank: memory.MemoryBank,
  threshold: Float,
  config: DreConfig,
) -> List(#(memory.Memory, DreScore))

Get memories above threshold

score

</> 
pub fn score(
  mem: memory.Memory,
  all_memories: List(memory.Memory),
  current_tick: Int,
  current_life: Int,
  config: DreConfig,
) -> DreScore

Calculate DRE score for a single memory

score_all

</> 
pub fn score_all(
  bank: memory.MemoryBank,
  config: DreConfig,
) -> List(#(memory.Memory, DreScore))

Score all memories in a bank

score_all_default

</> 
pub fn score_all_default(
  bank: memory.MemoryBank,
) -> List(#(memory.Memory, DreScore))

Score all with default config

score_default

</> 
pub fn score_default(
  mem: memory.Memory,
  all_memories: List(memory.Memory),
  current_tick: Int,
  current_life: Int,
) -> DreScore

Calculate DRE with default config

score_to_string

</> 
pub fn score_to_string(s: DreScore) -> String

Get DRE breakdown as string

select_for_bounce

</> 
pub fn select_for_bounce(
  bank: memory.MemoryBank,
  max_survivors: Int,
  min_threshold: Float,
  config: DreConfig,
) -> List(Int)

Select memories to protect during Big Bounce Returns IDs of memories that should survive

top_memories

</> 
pub fn top_memories(
  bank: memory.MemoryBank,
  n: Int,
  config: DreConfig,
) -> List(#(memory.Memory, DreScore))

Get top N memories by DRE score

✨ Search Document