मन्वंतर चक्र → Microbial Evolution Phases

# Manvantara Cycle: Genomic Adaptation Simulation
import numpy as np

class ManvantaraEvolution:
def __init__(self, population_size=1000, genome_length=100):
self.N = population_size
self.L = genome_length
# Initialize population with random binary genomes
self.population = np.random.randint(0, 2, (self.N, self.L))
self.fitness = np.zeros(self.N)
self.manu_template = None # Root genetic template

def calculate_fitness(self, environment_vector):
"""Fitness = genome-environment match"""
for i, genome in enumerate(self.population):
# Hamming distance as fitness metric
match = np.sum(genome == environment_vector)
self.fitness[i] = match / self.L
return self.fitness

def select_survivors(self, survival_rate=0.3):
"""मन्वंतर संक्रमण: फिटेस्ट जीनोम्स निवडणे"""
n_survive = int(self.N * survival_rate)
survivor_indices = np.argsort(self.fitness)[-n_survive:]
survivors = self.population[survivor_indices].copy()
# Update Manu template as best survivor
best_idx = np.argmax(self.fitness)
self.manu_template = self.population[best_idx].copy()
return survivors

def reproduce_with_mutation(self, survivors, mutation_rate=0.01):
"""पुनरुत्पादन + उत्परिवर्तन = नवीन पिढी"""
new_population = []
while len(new_population) < self.N:
# Random crossover between survivors
p1, p2 = np.random.choice(len(survivors), 2, replace=False)
crossover_point = np.random.randint(1, self.L)
child = np.concatenate([survivors[p1][:crossover_point],
survivors[p2][crossover_point:]])
# Apply mutation
mutation_mask = np.random.random(self.L) < mutation_rate
child[mutation_mask] = 1 - child[mutation_mask]
new_population.append(child)
return np.array(new_population)

evolution = ManvantaraEvolution(population_size=500, genome_length=50)
environment = np.random.randint(0, 2, 50) # New environmental pressure
fitness = evolution.calculate_fitness(environment)
survivors = evolution.select_survivors(survival_rate=0.25)
new_pop = evolution.reproduce_with_mutation(survivors, mutation_rate=0.02)
print(f"🧬 Manvantara Transition:")
print(f" Best fitness before: {np.max(fitness):.2f}")
print(f" Manu template saved: {np.sum(evolution.manu_template)} adaptive alleles")
print(f" New population generated: {len(new_pop)} individuals")

# Akriti-Vyakti: Template-Based Phenotype Generation
import numpy as np

class AkritiVyaktiModel:
def __init__(self, template_length=100):
self.L = template_length
# Akriti: conserved genetic template
self.akriti = np.random.choice([0, 1, None], template_length,
p=[0.4, 0.4, 0.2])

def instantiate_vyakti(self, environment_factor=1.0):
"""आकृती → व्यक्ती: टेम्प्लेटवरून इन्स्टन्स जनरेशन"""
vyakti = np.copy(self.akriti)
# Resolve None values based on environment
flexible_sites = np.where(vyakti == None)[0]
for site in flexible_sites:
# Environment influences phenotype expression
prob_1 = 0.5 + 0.3 * np.tanh(environment_factor - 0.5)
vyakti[site] = np.random.random() < prob_1
return vyakti.astype(int)

def compare_instances(self, n_instances=10, env_range=(0, 1)):
"""एका आकृतीपासून अनेक व्यक्ती: फिनोटाइपिक व्हेरिएशन"""
instances = []
for _ in range(n_instances):
env = np.random.uniform(*env_range)
instances.append(self.instantiate_vyakti(env))
# Calculate phenotypic diversity
diversity = np.mean([np.sum(instances[i] != instances[j])
for i in range(len(instances))
for j in range(i+1, len(instances))])
return {"template_conserved": np.sum(self.akriti != None),
"phenotypic_diversity": diversity / self.L}

model = AkritiVyaktiModel(template_length=100)
result = model.compare_instances(n_instances=20, env_range=(0, 2))
print(f"🧬 Akriti-Vyakti Analysis:")
print(f" Conserved template sites: {result['template_conserved']}/100")
print(f" Phenotypic diversity: {result['phenotypic_diversity']*100:.1f}%")

# Full Genetic Algorithm: Manvantara Evolution Engine
import numpy as np

class ManvantaraGeneticAlgorithm:
def __init__(self, pop_size=200, genome_len=64, n_generations=100):
self.pop_size = pop_size
self.genome_len = genome_len
self.n_gen = n_generations
self.population = np.random.randint(0, 2, (pop_size, genome_len))
self.best_fitness_history = []

def fitness_function(self, genome, target):
"""Fitness = similarity to adaptive target"""
return np.sum(genome == target) / self.genome_len

def tournament_selection(self, fitness, k=3):
"""Tournament selection for survival"""
indices = np.random.choice(len(fitness), k, replace=False)
return indices[np.argmax(fitness[indices])]

def crossover(self, p1, p2):
"""Single-point crossover"""
point = np.random.randint(1, self.genome_len - 1)
c1 = np.concatenate([p1[:point], p2[point:]])
c2 = np.concatenate([p2[:point], p1[point:]])
return c1, c2

def mutate(self, genome, rate=0.01):
"""Bit-flip mutation"""
mask = np.random.random(self.genome_len) < rate
genome[mask] = 1 - genome[mask]
return genome

def evolve(self, target_genome):
"""मन्वंतर इव्होल्यूशन: मुख्य लूप"""
for gen in range(self.n_gen):
# Evaluate fitness
fitness = np.array([self.fitness_function(g, target_genome)
for g in self.population])
self.best_fitness_history.append(np.max(fitness))

# Selection + Crossover + Mutation
new_pop = []
while len(new_pop) < self.pop_size:
p1_idx = self.tournament_selection(fitness)
p2_idx = self.tournament_selection(fitness)
c1, c2 = self.crossover(self.population[p1_idx],
self.population[p2_idx])
new_pop.extend([self.mutate(c1), self.mutate(c2)])
self.population = np.array(new_pop[:self.pop_size])
return {"best_fitness": np.max(fitness),
"best_genome": self.population[np.argmax(fitness)],
"history": self.best_fitness_history}

ga = ManvantaraGeneticAlgorithm(pop_size=100, genome_len=32, n_generations=50)
target = np.random.randint(0, 2, 32) # Adaptive target genome
result = ga.evolve(target_genome=target)
print(f"🧬 Manvantara GA Results:")
print(f" Final best fitness: {result['best_fitness']:.2f}")
print(f" Convergence: {result['history'][-1] - result['history'][0]:.2f} improvement")

# Population Genetics: Hardy-Weinberg + Selection + Drift
import numpy as np

class ManvantaraPopulationGenetics:
def __init__(self, N_effective=1000, initial_p=0.5):
self.Ne = N_effective # Effective population size
self.p = initial_p # Frequency of allele A
self.q = 1 - self.p # Frequency of allele a

def hardy_weinberg_expectation(self):
"""H-W equilibrium genotype frequencies"""
return {"AA": self.p**2, "Aa": 2*self.p*self.q, "aa": self.q**2}

def apply_selection(self, s_AA=0.1, s_Aa=0.05, s_aa=0.0):
"""Selection coefficients alter allele frequencies"""
w_bar = (self.p**2 * (1-s_AA) +
2*self.p*self.q * (1-s_Aa) +
self.q**2 * (1-s_aa))
new_p = (self.p**2*(1-s_AA) + self.p*self.q*(1-s_Aa)) / w_bar
self.p = new_p
self.q = 1 - self.p
return {"p": self.p, "q": self.q, "w_bar": w_bar}

def apply_genetic_drift(self):
"""Random drift: binomial sampling"""
# Sample 2Ne alleles from current frequency
A_count = np.random.binomial(2*self.Ne, self.p)
self.p = A_count / (2*self.Ne)
self.q = 1 - self.p
return {"p": self.p, "drift_variance": self.p*self.q/(2*self.Ne)}

def check_manvantara_transition(self, threshold=0.15):
"""मन्वंतर संक्रमण: मोठा जनुकीय बदल"""
delta_p = abs(self.p - 0.5) # Deviation from initial
if delta_p > threshold:
return f"✅ Manvantara transition triggered (Δp={delta_p:.2f})"
return f"🔄 Stable epoch (Δp={delta_p:.2f} < {threshold})"

pop_gen = ManvantaraPopulationGenetics(N_effective=500, initial_p=0.5)
print(f"📐 Initial H-W: {pop_gen.hardy_weinberg_expectation()}")
for _ in range(10):
pop_gen.apply_selection(s_AA=0.08, s_Aa=0.04)
pop_gen.apply_genetic_drift()
print(f"🧬 After 10 generations: p={pop_gen.p:.2f}, q={pop_gen.q:.2f}")
print(pop_gen.check_manvantara_transition(threshold=0.15))

# Information Conservation: Manvantara Data Persistence Model
import numpy as np

class ManvantaraInformationModel:
def __init__(self, total_info_capacity=1000):
self.C_total = total_info_capacity
self.I_manifest = 0.7 * self.C_total # Active expressed info
self.I_subtle = 0.25 * self.C_total # Compressed/latent info
self.I_potential = 0.05 * self.C_total # Unused capacity

def pralaya_compression(self, compression_ratio=0.1):
"""प्रलय: मॅनिफेस्ट → सब्टल (डेटा कॉम्प्रेशन)"""
# Compress manifest info into subtle storage
compressed = self.I_manifest * compression_ratio
lost = self.I_manifest * (1 - compression_ratio)
self.I_subtle += compressed
self.I_manifest = 0
return {"compressed": compressed, "lost": lost,
"subtle_total": self.I_subtle}

def srishti_decompression(self, expansion_factor=3.0):
"""सृष्टि: सब्टल → मॅनिफेस्ट (डेटा एक्सपान्शन)"""
# Expand subtle info into new manifest forms
expanded = min(self.I_subtle * expansion_factor,
self.C_total - self.I_potential)
self.I_manifest = expanded
self.I_subtle -= expanded / expansion_factor
return {"manifest_new": self.I_manifest,
"subtle_remaining": self.I_subtle}

def extract_manu_template(self):
"""मनु टेम्प्लेट: सब्टलमधील सर्वात महत्त्वाची माहिती"""
# Assume top 10% of subtle info is the Manu template
manu_info = 0.1 * self.I_subtle
return {"manu_template_size": manu_info,
"conservation_efficiency": (self.I_manifest + self.I_subtle)/self.C_total}

info_model = ManvantaraInformationModel(total_info_capacity=1000)
print(f"💾 Initial State: Manifest={info_model.I_manifest}, Subtle={info_model.I_subtle}")
pralaya = info_model.pralaya_compression(compression_ratio=0.15)
print(f"🌑 Pralaya: Compressed={pralaya['compressed']:.1f}, Lost={pralaya['lost']:.1f}")
srishti = info_model.srishti_decompression(expansion_factor=2.5)
print(f"🌅 Srishti: New Manifest={srishti['manifest_new']:.1f}")
manu = info_model.extract_manu_template()
print(f"👤 Manu Template: {manu['manu_template_size']:.1f} units ({manu['conservation_efficiency']*100:.1f}% conserved)")