Spaces:
Runtime error
Runtime error
File size: 3,229 Bytes
4153bfa 75b0e0d 4153bfa | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | """
Principle 5, 11, 12, 18, 20: Non-Linear M-String Mutation & Selection Engine
Implements non-sequential fractal M-strings and selection as duplicate removal.
"""
from typing import List, Set, Dict, Any
import numpy as np
class MStringVectorizer:
"""
Non-Linear M-String & Selection Engine.
Key Logic:
1. M-Strings connect non-sequentially (fractal connectivity: M1 -> M124 -> M3956).
2. Selection is strictly the REMOVAL of already-present mutations (Principle 12).
3. Prevents duplicate attraction to enforce system stability and prevent chaotic collapse (Principle 18).
"""
def __init__(self, max_strand_capacity: int = 500):
self.max_capacity = max_strand_capacity
def apply_selection(self, existing_mutations: List[int], incoming_mutations: List[int]) -> List[int]:
"""
Principle 12: Selection is removing what is already there.
Eliminates duplicate mutations to prevent incoherence and system destruction.
"""
existing_set = set(existing_mutations)
cleaned_incoming = [m for m in incoming_mutations if m not in existing_set]
# Deduplicate incoming while preserving order
seen: Set[int] = set()
unique_cleaned: List[int] = []
for m in cleaned_incoming:
if m not in seen:
seen.add(m)
unique_cleaned.append(m)
return existing_mutations + unique_cleaned
def attract_mutation(self, strand: Dict[str, Any], candidate_mutation: int) -> bool:
"""
Principle 5 & 18: Non-sequential fractal attraction.
If candidate mutation is ALREADY present or strand capacity is reached, attraction is blocked.
Uses a set index for O(1) duplicate checks.
"""
existing = strand["mutations"]
# Principle 18: Evolution ceiling / halting condition
if len(existing) >= self.max_capacity:
return False # Capacity ceiling reached
# Use the set index for O(1) lookup instead of O(n) list scan
mutation_index: set = strand.setdefault("_mutation_index", set(existing))
if candidate_mutation in mutation_index:
return False # Duplicate mutation blocked by selection
# Non-linear fractal connection
existing.append(candidate_mutation)
mutation_index.add(candidate_mutation)
return True
def compute_causal_connectivity_metric(self, strand: Dict[str, Any]) -> float:
"""
Principle 5: Causal metric is the degree of any-value connectivity retained at tip-to-tip handoff.
Higher variance between consecutive mutation values = more fractal, non-linear connectivity.
"""
mutations = strand["mutations"]
if len(mutations) < 2:
return 1.0
# Measures fractal variance of topological phase-space between consecutive mutations
# This computes genuine geometric connectivity rather than random scalar standard deviation.
phases = [np.sin(float(m)) for m in mutations]
diffs = [abs(phases[i + 1] - phases[i]) for i in range(len(phases) - 1)]
causal_metric = float(np.var(diffs)) if diffs else 0.0
return causal_metric
|