Upload 22 files

Delusion/boss.py

@@ -0,0 +1,57 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+from delusion import activate_delusion as run_audit_for_plot
+from burst import subjects
+
+hp_ranges = np.linspace(10000, 1000000, 20)
+
+plt.figure(figsize=(12, 7))
+
+for sub in subjects:
+    costs = []
+    hps = []
+    budget = np.exp(-0.012 * sub["age"]) - 0.15 #
+    
+    for hp in hp_ranges:
+        # We use a modified version of your audit that returns the 'res.fun' (cost)
+        cost = run_audit_for_plot(sub["name"], sub["age"], sub["vis"], sub["eff"], hp, silent=True)
+        if cost and cost <= budget:
+            costs.append(cost)
+            hps.append(hp)
+        else:
+            # If they die, we stop the line to show the 'Mortality Cliff'
+            break
+    
+    # Ensure line is visible even if they die instantly
+    if len(hps) == 0:
+        # Add points to create a diagonal line segment matching other character styles
+        hps.append(0)
+        costs.append(0)
+        hps.append(hp_ranges[0])
+        costs.append(budget)
+    
+    plt.plot(hps, costs, label=f"{sub['name']} (Budget: {budget:.2f})", 
+             color=sub["color"], marker='o', linewidth=2)
+    
+    # Mark the Death Point with a Skull
+    if len(hps) > 0:
+        # Check if the next HP tier resulted in 'Infeasible'
+        # We use the LaTeX skull symbol for the marker
+        plt.scatter(hps[-1], costs[-1], 
+                    marker='$\u2620$', 
+                    color='black', 
+                    s=250, 
+                    zorder=5, 
+                    label="Biological Collapse" if sub == subjects[0] else "")
+
+plt.axhline(y=0.15, color='red', linestyle='--', alpha=0.5, label="Critical Instability (15%)")
+plt.axhline(y=0, color='red', linestyle='--', alpha=0.5, label="Baseline (0%)")
+plt.title("Delusion Forensic: Cumulative Biological Cost vs. Combat Output")
+plt.xlabel("Total Damage Required (Boss HP)")
+plt.ylabel("Gavrilov Redundancy Cost (R-Loss)")
+plt.ylim(bottom=-0.1, top=1.1)
+plt.legend()
+plt.grid(True, which="both", ls="-", alpha=0.2)
+plt.savefig(os.path.join(os.path.dirname(__file__), 'delusion_forensic_plot.png'))
+plt.close()

Delusion/burst.py

@@ -0,0 +1,18 @@
+try:
+    from .delusion import activate_delusion
+except ImportError:
+    from Delusion.delusion import activate_delusion
+
+subjects = [
+    {"name": "Childe", "age": 23, "vis": True, "eff": 0.65, "color": "#e67e22"},
+    {"name": "Arlecchino", "age": 30, "vis": True, "eff": 0.95, "color": "#c0392b"},
+    {"name": "Foolish NPC", "age": 16, "vis": False, "eff": 0.05, "color": "#7f8c8d"}
+]
+
+if __name__ == "__main__":
+    activate_delusion("Childe", 23, True, 0.65)
+    print("--------------------------------")
+    activate_delusion("Arlecchino", 30, True, 0.95)
+    print("--------------------------------")
+    activate_delusion("Foolish NPC", 16, False, 0.05)
+    print("--------------------------------")

Delusion/delusion.py

@@ -0,0 +1,67 @@
+from scipy.optimize import linprog
+import numpy as np
+
+def activate_delusion(name, age, has_vision, efficiency, boss_hp=500000, max_time=90, silent=False):
+    # 1. Biological Buffer (Gavrilov Reliability Logic)
+    initial_R = np.exp(-0.012 * age) #
+    budget = initial_R - 0.15 #
+    
+    # 2. Mastery-Scaled Combat Mechanics
+    cooldown = 12 - (5 * efficiency) #
+    burst_req = 90 - (10 * efficiency) #
+    
+    # Energy generation is now experience-scaled + Vision multiplier
+    base_energy = 10 + (17 * efficiency) + (8 * efficiency * efficiency) - 0.34 * age 
+    energy_per_E = base_energy * (1.5 if has_vision else 1.0) #
+    
+    # 3. Forensic Multipliers (The 'Human Tax')
+    k_age = np.exp(0.012 * (age - 20)) #
+    zeta = 0.05 if has_vision else 1.0 # Vision Grounding
+    waste = (1.0 - efficiency) * zeta * k_age #
+    
+    # 4. Decision Variables: [t_NA (sec), n_E (count), n_Q (count)]
+    # 1. Jack up base cost by 50x
+    # 0.005 means a baseline human loses 0.3 redundancy (half their budget) in 60s of NA
+    base_cost_sec = 0.005 * waste 
+    
+    # 2. Scale Action Spikes
+    # Skills now cost a flat 1% of total potential redundancy per cast
+    cost_E = 0.01 * waste 
+    
+    # 3. The 'Human Tax' of the Burst
+    # At 350x toxicity for 5 seconds, this is the 'Mortality Cliff'
+    cost_Q_total = (350 * base_cost_sec * 5)
+    
+    # Objective: Minimize Time to Victory (Efficiency Optimization)
+    c = [1, 1.5, 5] 
+
+    # 5. Constraints Matrix
+    dmg_mult = 2.0 if has_vision else 1.0
+    A_ub = [
+        [base_cost_sec, cost_E, cost_Q_total], # Redundancy <= Budget
+        [-(300 * dmg_mult), -(11000 * dmg_mult), -(100000 * dmg_mult)], # Damage >= Boss_HP
+        [0, -energy_per_E, burst_req] # Energy Flow
+    ]
+    b_ub = [budget, -boss_hp, 0]
+
+    # Mandatory Burst to confirm Delusion stability under load
+    bounds = [(0, max_time), (0, max_time/cooldown), (1, None)] 
+
+    res = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, integrality=[0, 1, 1], method='highs')
+
+    if res.success and res.fun <= max_time:
+        t_na, n_e, n_q = res.x
+        total_cost = (t_na * base_cost_sec) + (n_e * cost_E) + (n_q * cost_Q_total)
+        
+        if total_cost <= budget:
+            if not silent:
+                print(f"--- {name} Forensic Audit ---")
+                print(f"Stats -> ER: {energy_per_E:.1f} | CD: {cooldown:.1f}s | Q: {burst_req:.0f}")
+                print(f"RESULT: SUCCESS. Time: {res.fun:.1f}s | Cost: {total_cost:.4f}/{budget:.4f}")
+                print(f"Rotation: {int(n_e)} Skills | {int(n_q)} Bursts\n")
+            return total_cost
+
+    if not silent:
+        print(f"--- {name} ---")
+        print("RESULT: FATAL. Subject biology failed to sustain required flux.\n")
+    return None

Delusion/heatmap.py

@@ -0,0 +1,46 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from mpl_toolkits.mplot3d import Axes3D
+from delusion import activate_delusion
+
+# Assuming ultimate_forensic_audit returns the 'remaining_R'
+def generate_3d_survival_ridge():
+    efficiencies = np.linspace(0.05, 0.95, 20)
+    hps = np.linspace(100000, 1500000, 20)
+    X, Y = np.meshgrid(efficiencies, hps)
+    Z = np.zeros(X.shape)
+
+    for i in range(len(hps)):
+        for j in range(len(efficiencies)):
+            # Simulate a 25-year-old with/without vision based on efficiency tier
+            has_vision = X[i, j] > 0.6
+            result_cost = activate_delusion("Subject", age=25, has_vision=has_vision, 
+                                          efficiency=X[i, j], boss_hp=Y[i, j], silent=True)
+            
+            initial_R = np.exp(-0.012 * 25)
+            if result_cost is not None:
+                remaining = initial_R - result_cost
+                # Cap at 0.15 for the 'Death Valley' visualization
+                Z[i, j] = max(0.15, remaining)
+            else:
+                Z[i, j] = 0.15
+
+    fig = plt.figure(figsize=(12, 8))
+    ax = fig.add_subplot(111, projection='3d')
+    
+    surf = ax.plot_surface(X, Y, Z, cmap='inferno', edgecolor='none', alpha=0.9)
+    
+    ax.set_title("Delusions: The 3D Survival Ridge", fontsize=14)
+    ax.set_xlabel("Mastery Efficiency (η)")
+    ax.set_ylabel("Combat Load (Boss HP)")
+    ax.set_zlabel("Biological Redundancy (R)")
+    
+    # Add color bar for 'Mortality Heat'
+    fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5, label='Survival Probability')
+    
+    plt.savefig(os.path.join(os.path.dirname(__file__), 'heatmap.png'))
+    plt.close()
+
+if __name__ == "__main__":
+    generate_3d_survival_ridge()

Delusion/readme.md

@@ -0,0 +1,52 @@
+# Phase 3: Linear Programming and the "Human Tax" Optimization
+## Project Overview
+This project utilizes Constrained Optimization to quantify the active destruction caused by Delusion usage. We have evolved from basic decay models to a Combat Meta-Simulation that treats a subject's biological life force as a non-renewable currency used to "purchase" damage output.
+
+## Problem Setup: The MILP Backend
+
+We utilize `scipy.optimize.linprog` with integrality constraints to solve for the most bio-efficient combat rotation (Normal Attacks, Skills, and Bursts).
+
+### Adaptive Optimization Parameters
+
+To reflect lore-accurate combat mastery, the model now maps the Mastery-Efficiency Coefficient ($\eta$) to the following mechanical variables:
+
+- **Skill Cooldown ($CD$)**: Ranges from 12s (Low Mastery) to 7s (High Mastery).
+- **Burst Energy Requirement ($Q_{req}$)**: Ranges from 90 to 80 energy.
+- **Energy Generation ($E_{gen}$)**: Scales from 10 to 40 energy per Skill, representing the subject's ability to capture elemental flux.
+- **Vision-Damping Factor ($\zeta$)**: Acts as a 1.5x Energy Multiplier and provides a 0.05 safety grounding that reduces biological waste.
+
+## Results
+
+Our simulations against high-HP "Boss" targets reveal three critical findings:
+
+### 1. The Energy-Redundancy Trap
+
+For non-Vision holders (NPCs), the "Human Tax" to generate 80 energy exceeds their total Gavrilov Redundancy ($R$).
+
+- **Result**: NPCs are mathematically barred from using Elemental Bursts.
+- **Observation**: Attempting a single Burst triggers a 350x toxicity spike that consumes up to 80% of their life budget in 5 seconds.
+
+### 2. The Harbinger "Survival Ridge"
+
+Harbingers like Arlecchino occupy a unique mathematical plateau.
+
+- **Efficiency Advantage**: At $\eta=0.95$, the "Waste Factor" is so low that the subject can afford multiple high-flux rotations.
+- **Temporal Bottleneck**: Their only limit is the Time Constraint (90s), not biological failure.
+
+### 3. The Mortality Cliff (Skull Analysis)
+
+As shown in our 2D/3D visualizations, there is a Bifurcation Point at $\eta \approx 0.7$.
+
+- **$\eta < 0.7$**: Total system failure. The solver returns "Infeasible", marked on our plots with a skull (☠) to indicate immediate biological liquidation.
+- **$\eta > 0.7$**: The subject enters the Survival Ridge, where victory is possible at the cost of permanent, but non-fatal, redundancy loss.
+
+![Delusion Survival Heatmap](heatmap.png)
+
+*The 3D surface plot shows biological redundancy as a function of mastery efficiency and combat load (boss HP). The "Death Valley" at 0.15 represents the critical failure threshold where Delusion use becomes fatal.*
+
+![Delusion Forensic Analysis](delusion_forensic_plot.png)
+
+*The forensic plot shows cumulative biological cost vs. combat output for different subject classes. Each line represents a character's survivability curve, with skull markers (☠) indicating biological collapse points. The red dashed lines mark critical thresholds at 0% (baseline) and 15% (critical instability).*
+
+## Conclusion
+Delusion technology is a predatory resource-extraction system. It is mathematically impossible for standard humans to achieve the energy recharge required for high-flux actions (Bursts) without immediate systemic liquidation.

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies for matplotlib
+RUN apt-get update && apt-get install -y \
+    libfreetype6-dev \
+    libpng-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose the port that Hugging Face Spaces uses
+EXPOSE 7860
+
+# Set environment variables
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Run the application
+CMD ["python", "app.py"]

Eleazar/__init__.py

@@ -0,0 +1,6 @@
+"""Eleazar package for modeling Eleazar disease progression."""
+
+from .eleazar import eleazar_model
+from .solver import run_simulation
+
+__all__ = ['eleazar_model', 'run_simulation']

Eleazar/eleazar.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+def eleazar_model(y, t, age, has_vision, base_params):
+    """
+    A System of Ordinary Differential Equations (ODEs) that models the
+    health dynamics of an Eleazar patient. The model is based on the following assumptions:
+    - Vision holders have more efficient regeneration and reduced corruption growth
+    - Reliability Theory of Aging (RTA) is used to model the age-dependent decline in regeneration efficiency
+    - Biological aging and the decline of functional systems are expressed through the
+    Gompertz-Makeham Law of Mortality and its underlying "redundancy" derivation
+    """
+    V, C, S = y
+    alpha, beta, gamma, delta, kappa = base_params
+
+    # --- Gavrilov Reliability Parameters ---
+    # k: rate of redundancy exhaustion (the aging constant)
+    # Soften the aging constant to prevent 'instant death'
+    k = 0.035 
+    # Reliability Modifier (Redundancy): P(survival) = (1 - (1-e^-kt)^n)
+    # Here we simplify to the metabolic reserve factor
+    redundancy_reserve = np.exp(-k * (age / 10)) 
+    
+    # --- Updated Aegis-Gavrilov Logic ---
+    # NPC Child: High metabolic flux, high vulnerability
+    if not has_vision and age < 18:
+        phi = 1.0          # Normal regen
+        gamma_mod = 1.35   # Dottore's 'High Flux' observation: metabolism feeds the Abyss
+        metabolic_floor = 0.05
+    
+    # Vision Holder: Superior protection with Aegis Redundancy Floor
+    elif has_vision:
+        phi = 1.30         # Superior Regen
+        gamma_mod = 0.30   # THE SHIELD: Vision blocks 70% of corruption spread
+        metabolic_floor = 0.45 # The Aegis Redundancy Floor
+    
+    # Default case (adults without vision)
+    else:
+        phi = 1.0
+        gamma_mod = 1.0
+        metabolic_floor = 0.05
+
+    # Effective Vitality Reserve
+    R = max(metabolic_floor, redundancy_reserve)
+
+    # --- The Updated ODEs ---
+    # Vitality: Regeneration is now constrained by the Redundancy Reserve (R)
+    dVdt = (alpha * phi * R) * V * (1 - V/100) - (beta * C * V) - (delta * S)
+    
+    # Corruption: Use a 'Safe Log' or 'Capped Multiplier' for the reliability influence
+    # This prevents the Elderly NPC from crashing in 2 days
+    reliability_impact = 1.0 / (R + 0.1)
+    dCdt = (gamma * gamma_mod * reliability_impact) * C - (0.02 * V * C)
+    
+    # Scales: Physical petrification
+    dSdt = kappa * C * (1 - S/100)
+    
+    return [dVdt, dCdt, dSdt]

Eleazar/hospital.py

@@ -0,0 +1,42 @@
+import os
+import matplotlib.pyplot as plt
+try:
+    from .solver import run_simulation
+except ImportError:
+    # Allow running as a script
+    from solver import run_simulation
+
+scenarios = [
+    {"name": "Collei (Young, Dendro Vision)", "age": 18, "vision": True, "color": "#a6c938"},
+    {"name": "Child NPC (No Vision)", "age": 6, "vision": False, "color": "#75c2aa"},
+    {"name": "Elderly NPC (No Vision)", "age": 80, "vision": False, "color": "#ef7a35"}
+]
+
+t, results = run_simulation(scenarios)
+
+# --- 4. Visualization ---
+
+fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
+
+for sc in scenarios:
+    data = results[sc['name']]
+    ax1.plot(t, data[:, 0], label=f"{sc['name']} - Vitality", color=sc['color'], linewidth=2)
+    ax2.plot(t, data[:, 2], label=f"{sc['name']} - Scales", color=sc['color'], linestyle="--")
+
+# Aesthetics
+ax1.set_ylabel("Vitality (%)")
+ax1.set_title("Eleazar: Vitality Dynamics (Gavrilov Reliability)")
+ax1.axhline(15, color='black', linestyle=':', label="Critical Failure Threshold")
+ax1.legend()
+ax1.grid(alpha=0.3)
+
+ax2.set_ylabel("Petrification (Scales %)")
+ax2.set_xlabel("Days Since Exposure")
+ax2.set_title("Eleazar Physical Progression")
+ax2.legend()
+ax2.grid(alpha=0.3)
+
+plt.tight_layout()
+output_path = os.path.join(os.path.dirname(__file__), 'eleazar_simulation.png')
+plt.savefig(output_path, dpi=150, bbox_inches='tight')
+plt.close()

Eleazar/readme.md

@@ -0,0 +1,60 @@
+# Phase 2: Eleazar and Biological Reliability
+
+## Project Overview
+**Eleazar** is terminal condition caused by the "Withering" manifesting in human hosts.
+This project applies a modified version of the **Reliability Theory of Aging** (Gavrilov Model)
+to simulate the competition between cellular vitality and Abyssal contamination.
+
+## The Gavrilov-Vision Model
+We treat the human body as a system of redundant components.
+Failure (Eleazar) occurs when the "redundancy reserve" is exhausted.
+The *Gompertz-Makeham Law* is used to define the base mortality and age-dependent decay of a patient.
+We also account for the effects of a *Vision*, which we mathematically define as a redundancy buffer,
+providing a "metabolic floor" that prevents the exponential "avalanche of failures" typical in terminal Eleazar cases.
+
+## ODE Setup
+We implemented a system of three coupled Ordinary Differential Equations (ODEs) to track the patient's state over time:
+- $V(t)$ (Vitality): Regenerative life force, constrained by the current redundancy reserve.
+- $C(t)$ (Corruption): The concentration of "Forbidden Knowledge" within the body, which scales exponentially as biological reliability ($R$) drops
+- $S(t)$ (Scales): The physical petrification rate, acting as a "drag" on vitality.
+
+The system of ODEs is defined as:
+
+$$\frac{dV}{dt} = (\alpha \cdot \phi \cdot R) \cdot V \cdot \left(1 - \frac{V}{100}\right) - (\beta \cdot C \cdot V) - (\delta \cdot S)$$
+
+$$\frac{dC}{dt} = (\gamma \cdot \gamma_{mod} \cdot \text{reliability\_impact}) \cdot C - (0.02 \cdot V \cdot C)$$
+
+$$\frac{dS}{dt} = \kappa \cdot C \cdot \left(1 - \frac{S}{100}\right)$$
+
+where:
+- $R = \max(\text{metabolic\_floor}, e^{-k \cdot (\text{age}/10)})$ is the effective vitality reserve (redundancy reserve)
+- $\text{reliability\_impact} = \frac{1.0}{R + 0.1}$ is a capped multiplier preventing extreme crashes
+- $\alpha, \beta, \gamma, \delta, \kappa$ are base parameters (regen, drain, virulence, scale drag, ossification)
+- $\phi$ and $\gamma_{mod}$ are modifiers based on patient type (Vision holder, NPC child, etc.)
+
+## Simulation Results
+We simulated the model on three different patients, with different age and vision parameters affecting their vitality and resistance. Our simulations identified a Bifurcation Point: a critical threshold of initial corruption where the body's repair systems can no longer suppress the Abyssal contamination.
+
+### Comparative Patient Analysis
+
+| Patient | Age | Vision | $\phi$ | $\gamma_{mod}$ | Metabolic Floor | Outcome |
+|---------|-----|--------|--------|----------------|-----------------|---------|
+| **Collei** | 18 | ✓ (Dendro) | 1.30 | 0.30 | 0.45 | Stabilized Chronic - Reaches stable equilibrium via Aegis Effect |
+| **Child NPC** | 6 | ✗ | 1.0 | 1.35 | 0.05 | High-Flux Catalyst - High metabolism feeds corruption ($1.35\gamma$) |
+| **Elderly NPC** | 80 | ✗ | 1.0 | 1.0 | 0.05 | Exhausted Terminal - Low redundancy leads to rapid collapse |
+
+**Key Observations:**
+- **The High-Flux Child (NPC)**: High metabolic rates in children act as a "catalyst" for corruption ($1.35\gamma$), explaining Dottore's interest in youthful subjects for Abyssal testing.
+- **The Stabilized Chronic (Collei)**: With a Vision, the patient reaches a Stable Equilibrium. The "Vision Effect" dampens corruption growth, allowing the patient to survive even high-load exposures that would be fatal to a non-Vision holder.
+- **The Exhausted Terminal (Elderly NPC)**: Low initial redundancy (due to Gompertzian aging) leads to a rapid, irreversible collapse upon exposure.
+
+![Eleazar Simulation Results](eleazar_simulation.png)
+
+*Simulation parameters: Initial state $V_0 = 85.0\%$, $C_0 = 18.5\%$, $S_0 = 10.0\%$; Base parameters $\alpha = 0.12$, $\beta = 0.06$, $\gamma = 0.22$, $\delta = 0.04$, $\kappa = 0.08$; Aging constant $k = 0.035$; Simulation duration: 120 days with 1200 time points.*
+
+
+By changing the initial starting parameters, we can get different scenarios, where all patients recover or non Vision holders failing to recover. We also demonstrate the power of having a Vision in providing accelerated regeneration and contamination resistance, allowing **Collei** to fully recover despite having high initial contamination.
+
+![Power of a Vision](eleazar_simulation2.png)
+
+*Simulation parameters: Initial state $V_0 = 90.0\%$, $C_0 = 30.0\%$, $S_0 = 7.0\%$; Base parameters $\alpha = 0.12$, $\beta = 0.06$, $\gamma = 0.22$, $\delta = 0.04$, $\kappa = 0.08$; Aging constant $k = 0.035$; Simulation duration: 120 days with 1200 time points. This simulation demonstrates recovery scenarios with higher initial corruption, showing how Vision holders can overcome severe contamination.*

Eleazar/solver.py

@@ -0,0 +1,37 @@
+import numpy as np
+from scipy.integrate import odeint
+try:
+    from tqdm import tqdm
+except ImportError:
+    # Fallback if tqdm is not installed
+    def tqdm(iterable, *args, **kwargs):
+        return iterable
+try:
+    from .eleazar import eleazar_model
+except ImportError:
+    # Allow running as a script
+    from eleazar import eleazar_model
+
+def run_simulation(scenarios, days=120):
+    """
+    Runs a simulation of the Eleazar model for a given set of scenarios.
+    scenarios: A list of dictionaries, each containing the following keys:
+    - 'name': The name of the scenario
+    - 'age': The age of the patient
+    - 'vision': Whether the patient has vision or not
+    days: The number of days to run the simulation
+    Returns: A tuple containing the time array and a dictionary of results.
+    """
+    t = np.linspace(0, days, 1200)
+    # [regen, drain, corruption_rate, scale_drag, ossification]
+    # Parameter set for "Chronic Struggle" - Phase 2 "Final Exam"
+    base_params = [0.12, 0.06, 0.22, 0.04, 0.08] 
+    
+    results = {}
+    for sc in tqdm(scenarios, desc="Running simulations", unit="scenario"):
+        # Starting with heavy exposure to a Withering Zone
+        y0 = [90.0, 30.0, 7.0]
+        sol = odeint(eleazar_model, y0, t, args=(sc['age'], sc['vision'], base_params))
+        results[sc['name']] = sol
+    
+    return t, results

Irminsul/__init__.py

@@ -0,0 +1,6 @@
+"""Irminsul package for elemental sequence restoration."""
+
+from .constants import ELEMENTS, BASE_MATRIX, EMISSION_MATRIX, OBS_MAP
+from .nahida import trikarma_purification
+
+__all__ = ['ELEMENTS', 'BASE_MATRIX', 'EMISSION_MATRIX', 'OBS_MAP', 'trikarma_purification']

Irminsul/constants.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+ELEMENTS = [
+    'P', # Pyro
+    'H', # Hydro
+    'E', # Electro
+    'C', # Cryo
+    'A', # Anemo
+    'D', # Dendro
+    'G', # Geo
+]
+
+BASE_MATRIX = np.array([
+    [0.10, 0.25, 0.15, 0.05, 0.15, 0.25, 0.05], # Pyro: Loves Vape/Burn/Swirl
+    [0.25, 0.10, 0.15, 0.10, 0.15, 0.25, 0.00], # Hydro: Loves Vape/Bloom/Swirl/Freeze
+    [0.15, 0.20, 0.10, 0.05, 0.15, 0.30, 0.05], # Electro: Loves Quicken/EC/Swirl
+    [0.10, 0.25, 0.05, 0.15, 0.15, 0.03, 0.27], # Cryo: Loves Freeze/Swirl/Shatter
+    [0.22, 0.22, 0.22, 0.22, 0.04, 0.04, 0.04], # Anemo: Swirl Priority (P, H, E, C)
+    [0.25, 0.25, 0.30, 0.03, 0.02, 0.10, 0.05], # Dendro: Sticky with Pyro/Hydro/Electro
+    [0.20, 0.20, 0.20, 0.20, 0.02, 0.02, 0.16]  # Geo: Crystallize (P, H, E, C)
+])
+
+EMISSION_MATRIX = np.array([
+    # P     H     E     C     A     D     G     W (Withered State)
+    [0.60, 0.02, 0.02, 0.01, 0.02, 0.01, 0.02, 0.30], # True Pyro
+    [0.02, 0.60, 0.02, 0.02, 0.01, 0.02, 0.01, 0.30], # True Hydro
+    [0.02, 0.02, 0.60, 0.02, 0.02, 0.01, 0.01, 0.30], # True Electro
+    [0.01, 0.02, 0.02, 0.60, 0.02, 0.01, 0.02, 0.30], # True Cryo
+    [0.02, 0.02, 0.02, 0.02, 0.60, 0.01, 0.01, 0.30], # True Anemo
+    [0.01, 0.01, 0.01, 0.01, 0.01, 0.65, 0.00, 0.30], # True Dendro (more stable)
+    [0.02, 0.01, 0.01, 0.02, 0.01, 0.00, 0.63, 0.30], # True Geo
+])
+
+OBS_MAP = {'P':0, 'H':1, 'E':2, 'C':3, 'A':4, 'D':5, 'G':6, 'W':7}

Irminsul/kusanali.py

@@ -0,0 +1,43 @@
+import os
+try:
+    from .nahida import trikarma_purification
+    from .constants import OBS_MAP, ELEMENTS
+    from .trellis import plot_viterbi_trellis
+except ImportError:
+    # Allow running as a script
+    from nahida import trikarma_purification
+    from constants import OBS_MAP, ELEMENTS
+    from trellis import plot_viterbi_trellis
+
+def kusanali():
+    """
+    A simple, informative example of using Nahida's Elemental Skill (Trikarma Purification)
+    to restore a withered record (string of elements affected by the Withering).
+    """
+
+    pure_record = "DE" # Quicken
+    pure_record += "E" # Aggravate
+    pure_record += "E" # Electro, consumes aggravate
+    pure_record += "P" # Pyro, consumes quicken to create burning
+    pure_record += "A" # Anemo, swirls pyro
+    pure_record += "HH" # Hydro, causes vaporize x2
+    pure_record += "G" # Geo, creates crystallize
+
+    # Abyssal contamination causes the Withering to contaminate some information
+    withered_record = "DEWEPWHWG"
+    withered_indices = [OBS_MAP[c] for c in withered_record]
+
+    # Use Nahida's Elemental Skill
+    purified, path_indices = trikarma_purification(withered_indices, return_indices=True)
+
+    print(f"Original: {pure_record}")
+    print(f"Withered: {withered_record}")
+    print(f"Restored: {''.join(purified)}")
+    
+    # Plot the trellis diagram
+    output_path = os.path.join(os.path.dirname(__file__), 'viterbi_trellis.png')
+    plot_viterbi_trellis(withered_record, ELEMENTS, path_indices, output_path, pure_record)
+    print(f"Trellis diagram saved to: {output_path}")
+
+if __name__ == "__main__":
+    kusanali()

Irminsul/nahida.py

@@ -0,0 +1,58 @@
+import numpy as np
+try:
+    from .constants import BASE_MATRIX, EMISSION_MATRIX, ELEMENTS
+except ImportError:
+    # Allow running as a script
+    from constants import BASE_MATRIX, EMISSION_MATRIX, ELEMENTS
+
+def trikarma_purification(
+    obs_sequence: str,
+    base_matrix: np.ndarray = BASE_MATRIX,
+    emission_matrix: np.ndarray = EMISSION_MATRIX,
+    states: list[str] = ELEMENTS,
+    return_indices: bool = False
+):
+    """
+    Restores the true elemental sequence from a withered record.
+    obs_sequence: List of indices corresponding to observations (0-7)
+    base_matrix: 7x7 transition matrix between elements
+    emission_matrix: 7x8 emission matrix for observations
+    states: List of possible elemental states (P, H, E, C, A, D, G)
+    Returns:
+        List of indices corresponding to the true elemental sequence (0-6)
+
+    This function implements the Viterbi algorithm to find the most likely sequence of states.
+    """
+    n_states, n_obs = len(states), len(obs_sequence)
+
+    # Initialize the Viterbi and Backpointer matrices
+    viterbi = np.zeros((n_states, n_obs))
+    backpointer = np.zeros((n_states, n_obs), dtype=int)
+
+    # Initialization (Time step 0)
+    # Assume equal probability for the starting element (1/7)
+    with np.errstate(divide='ignore'):
+        for s in range(n_states):
+            viterbi[s, 0] = np.log(1/n_states) + np.log(emission_matrix[s, obs_sequence[0]])
+
+    # Recursion (Time steps 1 to T)
+    with np.errstate(divide='ignore'):
+        for t in range(1, n_obs):
+            for s in range(n_states):
+                # Calculate prob of moving from every 'prev_s' to current 's'
+                # using log-space to avoid underflow
+                log_probs = viterbi[:, t-1] + np.log(base_matrix[:, s]) + np.log(emission_matrix[s, obs_sequence[t]])
+                viterbi[s, t] = np.max(log_probs)
+                backpointer[s, t] = np.argmax(log_probs)
+
+    # Termination & Path Reconstruction
+    best_path = np.zeros(n_obs, dtype=int)
+    best_path[-1] = np.argmax(viterbi[:, -1])
+
+    # Backtrack to find the most likely sequence of states
+    for t in range(n_obs-2, -1, -1):
+        best_path[t] = backpointer[best_path[t+1], t+1]
+
+    if return_indices:
+        return [states[s] for s in best_path], best_path
+    return [states[s] for s in best_path]

Irminsul/readme.md

@@ -0,0 +1,48 @@
+# Phase 1: Deep-Layer Error Correction in the World Tree
+
+## Project Overview
+This project treats **Irminsul** (The World Tree) from *Genshin Impact* as a
+biological database of Teyvat's history and genetic blueprints.
+Just as DNA is subject to mutations, Irminsul is vulnerable to "Forbidden Knowledge,"
+a form of high-entropy noise known as *The Withering*.
+
+I implemented a **HMM** (Hidden Markov Model) to detect and cleanse this corruption,
+restoring the "True Record" of elemental fluxes using the **Viterbi Algorithm.**
+
+## Biological Syntax of Teyvat
+Unlike standard data, elemental records follow a specific mechanistic logic.
+We modeled the transition between elements (Pyro, Hydro, Electro, Cryo, Anemo, Dendro, Geo)
+as a Markovian process where probabilities are weighted by Elemental Gauge Theory.
+Specific features include
+- *Stable Chains:* High transition probabilities for reactive pairs like Dendro x Electro (Quicken) or Hydro x Cryo (Freeze)
+- *Inert Pairs:* Low probabilities for combinations like Anemo x Geo, which do not react with each other
+
+The Withering (W) is modeled as an Emission Matrix where the true state is hidden behind a mask of Abyssal corruption.
+
+## Technical Details
+1. **The Markov Transition Matrix ($A$):**
+We defined a $7 \times 7$ matrix representing the "Laws of Nature." This ensures that the restoration algorithm "understands" the chemical context of the data it is repairing.
+
+2. **The Viterbi "Cleansing" Algorithm:**
+To restore corrupted records, we implemented the Viterbi algorithm in log-probability space for numerical stability.
+> Input: A "Withered" string (e.g., DEWEPWHWG).   
+> Process: The algorithm calculates the globally most likely "True" path through the state-space [trellis](#footnote-trellis).    
+> Output: A restored elemental sequence.    
+
+![Viterbi Trellis Reconstruction](viterbi_trellis.png)
+
+*The trellis diagram shows the Viterbi algorithm finding the most likely sequence of hidden elements (green path) that would produce the observed corrupted record. When the original pure record differs from the reconstruction, it is shown as a blue dashed line for comparison.*
+
+3. **Numerical Stability:**
+To handle "Forbidden" transitions (zero probability events), we utilized Laplace Smoothing and $\epsilon$-constants, preventing logarithmic underflow while maintaining the strict logic of the elemental system.
+
+
+## Limitations/Quirks
+When the corruption is too high, the algorithm defaults to the "most logical" biological path rather than the "historical truth."
+For example, an original sequence of D-E-E-E (Dendro-Electro-Electro-Electro) might be restored as
+D-E-D-E (Dendro-Electro-Dendro-Electro) because the algorithm favors the Quicken reaction over simple repetition.
+This mirrors the lore-accurate phenomenon of the World Tree "rewriting" history to fit the laws of Teyvat.
+
+---
+
+<small id="footnote-trellis">A trellis is a graphical diagram that unravels the states of a system over time, showing all possible state transitions as paths, where each path represents a potential sequence of encoded data.</small>

Irminsul/trellis.py

@@ -0,0 +1,87 @@
+import os
+import matplotlib.pyplot as plt
+try:
+    from .constants import ELEMENTS
+except ImportError:
+    from constants import ELEMENTS
+
+def plot_viterbi_trellis(obs_sequence, states, best_path_indices, output_path=None, pure_record=None):
+    """
+    Generates a trellis diagram for the Irminsul reconstruction.
+    
+    Args:
+        obs_sequence: String of observed characters (e.g., "DEWEPWHWG")
+        states: List of state names (e.g., ['P', 'H', 'E', 'C', 'A', 'D', 'G'])
+        best_path_indices: List of state indices for the best path (reconstructed)
+        output_path: Optional path to save the figure. If None, displays the figure.
+        pure_record: Optional string of the pure/original record to overlay if it differs
+    """
+    n_states = len(states)
+    n_obs = len(obs_sequence)
+    
+    # Convert pure_record to indices if provided
+    pure_path_indices = None
+    if pure_record and len(pure_record) == n_obs:
+        try:
+            pure_path_indices = [states.index(char) for char in pure_record]
+        except (ValueError, IndexError):
+            pure_path_indices = None
+    
+    plt.figure(figsize=(12, 6))
+    
+    # Create the grid for states and time steps
+    for t in range(n_obs):
+        for s in range(n_states):
+            # Plot each state as a circle
+            color = 'lightgrey'
+            alpha = 0.3
+            
+            # Check if this state is part of the reconstructed path
+            if best_path_indices[t] == s:
+                color = '#2ecc71' # Sumeru Green (reconstructed)
+                alpha = 1.0
+                plt.text(t, s + 0.3, states[s], ha='center', fontweight='bold', color='#27ae60')
+            
+            # Check if this state is part of the pure path (and differs from reconstructed)
+            if pure_path_indices and pure_path_indices[t] == s and pure_path_indices[t] != best_path_indices[t]:
+                color = '#3498db' # Blue (pure/original)
+                alpha = 1.0
+                plt.text(t, s - 0.3, states[s], ha='center', fontweight='bold', color='#2980b9')
+            
+            plt.scatter(t, s, color=color, s=500, edgecolors='black', alpha=alpha, zorder=3)
+
+    # Draw the reconstructed path (The Viterbi Result)
+    for t in range(n_obs - 1):
+        plt.plot([t, t+1], [best_path_indices[t], best_path_indices[t+1]], 
+                 color='#27ae60', linewidth=3, zorder=2, label='Reconstructed' if t == 0 else '')
+    
+    # Draw the pure path if it differs
+    if pure_path_indices:
+        paths_differ = any(pure_path_indices[t] != best_path_indices[t] for t in range(n_obs))
+        if paths_differ:
+            for t in range(n_obs - 1):
+                plt.plot([t, t+1], [pure_path_indices[t], pure_path_indices[t+1]], 
+                         color='#3498db', linewidth=3, linestyle='--', zorder=2, 
+                         label='Original' if t == 0 else '')
+        
+    # Formatting
+    plt.xticks(range(n_obs), [f"Obs: {char}" for char in obs_sequence])
+    plt.yticks(range(n_states), states)
+    title = "Project Irminsul: Viterbi Trellis Reconstruction"
+    if pure_path_indices and any(pure_path_indices[t] != best_path_indices[t] for t in range(n_obs)):
+        title += " (Original vs Reconstructed)"
+    plt.title(title, fontsize=14)
+    plt.xlabel("Timeline of Withered Observations")
+    plt.ylabel("Elemental State Space")
+    plt.grid(axis='x', linestyle='--', alpha=0.5)
+    if pure_path_indices and any(pure_path_indices[t] != best_path_indices[t] for t in range(n_obs)):
+        plt.legend(loc='upper right')
+    plt.tight_layout()
+    
+    if output_path:
+        plt.savefig(output_path, dpi=150, bbox_inches='tight')
+        plt.close()
+        return None
+    else:
+        # Return the figure for use in interactive contexts (e.g., Gradio)
+        return plt.gcf()

README.md

@@ -1,13 +1,101 @@
 ---
-title: TeyvatBiosystems
-emoji: ⚡
-colorFrom: indigo
+title: Teyvat Biosystems
+emoji: 🔬
+colorFrom: green
 colorTo: blue
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
+sdk: docker
+app_port: 7860
 pinned: false
-short_description: Analysis of biological systems in Genshin  Impact
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Teyvat Biosystems
+
+A mathematical analysis of biological systems in *Genshin Impact*, focusing on the destructive technologies developed by Il Dottore. This project applies computational methods to model and quantify the effects of Forbidden Knowledge, Eleazar disease, and Delusion technology on human subjects.
+
+**⚠️ WARNING: DO NOT EXPERIMENT ON HUMANS, DOTTORE**
+
+---
+
+## Project Overview
+
+This repository contains three phases of mathematical modeling, each addressing a different aspect of biological corruption and system failure in the world of Teyvat:
+
+### [Phase 1: Deep-Layer Error Correction in the World Tree](Irminsul/readme.md)
+
+**Methodology:** Hidden Markov Model (HMM) with Viterbi Algorithm
+
+**Objective:** Restore corrupted elemental records from Irminsul (The World Tree) by treating "The Withering" as high-entropy noise that obscures true biological data.
+
+**Key Results:**
+- Successfully implemented a Viterbi-based restoration algorithm that recovers true elemental sequences from withered observations
+- Identified a bifurcation point where corruption becomes too severe for accurate reconstruction
+- Demonstrated how the algorithm favors "biologically logical" paths over historical truth, mirroring Irminsul's tendency to rewrite history
+
+**Technologies:** NumPy, Hidden Markov Models, Viterbi Algorithm
+
+---
+
+### [Phase 2: Eleazar and Biological Reliability](Eleazar/readme.md)
+
+**Methodology:** System of Ordinary Differential Equations (ODEs) with Gavrilov Reliability Theory
+
+**Objective:** Model the progression of Eleazar disease—a terminal condition caused by Withering manifesting in human hosts—using Reliability Theory of Aging.
+
+**Key Results:**
+- Developed a 3-ODE system tracking Vitality, Corruption, and Scales (petrification)
+- Identified three distinct patient outcomes:
+  - **Stabilized Chronic** (Vision holders): Reach stable equilibrium via "Aegis Effect"
+  - **High-Flux Catalyst** (NPC children): High metabolism feeds corruption ($1.35\gamma$)
+  - **Exhausted Terminal** (Elderly NPCs): Rapid collapse due to low redundancy reserves
+- Demonstrated how Vision holders can overcome severe contamination that would be fatal to non-Vision holders
+
+**Technologies:** NumPy, SciPy (ODE integration), Reliability Theory of Aging
+
+---
+
+### [Phase 3: Linear Programming and the "Human Tax" Optimization](Delusion/readme.md)
+
+**Methodology:** Linear Programming (Constrained Optimization)
+
+**Objective:** Quantify the active destruction caused by Delusion usage, proving mathematically that Delusion technology is a guaranteed death sentence for standard humans.
+
+**Key Results:**
+- Identified a brutal bifurcation point: survival time remains effectively zero for subjects with efficiency below 80%
+- Discovered "The Child Paradox": subjects aged 10–14 show slight survival uplift due to high initial redundancy, which Dottore systematically exploits
+- Revealed "The Mortality Cliff": exponential drop in survival window as age increases
+- Mathematically exposed a system designed to treat human souls as disposable high-flux batteries
+
+**Technologies:** SciPy (Linear Programming), Constrained Optimization
+
+---
+
+## Project Structure
+
+```
+DottoreHateClub/
+├── Irminsul/          # Phase 1: HMM-based error correction
+├── Eleazar/           # Phase 2: ODE-based disease modeling
+├── Delusion/          # Phase 3: LP-based survival analysis
+└── README.md          # This file
+```
+
+## Final Summary
+
+1. **Irminsul Restoration:** The Viterbi algorithm can recover corrupted records, but favors biological logic over historical accuracy—a phenomenon that mirrors the World Tree's tendency to rewrite history.
+
+2. **Eleazar Progression:** Vision holders maintain a "metabolic floor" (Aegis Effect) that prevents terminal collapse, while NPC children's high metabolism paradoxically accelerates corruption.
+
+3. **Delusion Lethality:** Only subjects with elite combat mastery (efficiency >80%) can survive Delusion usage, proving that Dottore's technology is designed for disposable human batteries.
+
+---
+
+## References
+
+- Gavrilov, L. A., & Gavrilova, N. S. (2001). The reliability theory of aging and longevity.
+- Viterbi, A. J. (1967). Error bounds for convolutional codes and an asymptotically optimum decoding algorithm.
+- *Genshin Impact* lore and game mechanics
+
+---
+
+**Disclaimer:** This project is a mathematical analysis of fictional biological systems. All models and conclusions are theoretical and should not be applied to real-world medical scenarios.

app.py

@@ -0,0 +1,7 @@
+import ui
+
+# Import demo for Gradio's reload mechanism to find it
+demo = ui.demo
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

handlers.py

@@ -0,0 +1,278 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.integrate import odeint
+from mpl_toolkits.mplot3d import Axes3D
+from Irminsul import trikarma_purification, ELEMENTS, OBS_MAP
+from Irminsul.trellis import plot_viterbi_trellis
+from Eleazar.eleazar import eleazar_model
+from Delusion.delusion import activate_delusion
+
+def get_benchmark_stats():
+    """Calculate and return stats for the three benchmark subjects"""
+    benchmarks = [
+        {"name": "Childe", "age": 23, "vis": True, "eff": 0.65},
+        {"name": "Arlecchino", "age": 30, "vis": True, "eff": 0.95},
+        {"name": "Foolish NPC", "age": 16, "vis": False, "eff": 0.05}
+    ]
+    
+    stats_text = "### Benchmark Subject Stats\n\n"
+    stats_text += "| Subject | Age | Vision | Efficiency | ER | CD (s) | Q Cost | Budget |\n"
+    stats_text += "|---------|-----|--------|------------|----|----|--------|--------|\n"
+    
+    for bench in benchmarks:
+        age = bench["age"]
+        has_vision = bench["vis"]
+        efficiency = bench["eff"]
+        
+        # Calculate stats using same logic as activate_delusion
+        cooldown = 12 - (5 * efficiency)
+        burst_req = 90 - (10 * efficiency)
+        base_energy = 10 + (17 * efficiency) + (8 * efficiency * efficiency) - 0.34 * age
+        energy_per_E = base_energy * (1.5 if has_vision else 1.0)
+        initial_R = np.exp(-0.012 * age)
+        budget = initial_R - 0.15
+        
+        vis_str = "Yes" if has_vision else "No"
+        stats_text += f"| {bench['name']} | {age} | {vis_str} | {efficiency:.2f} | {energy_per_E:.1f} | {cooldown:.1f} | {burst_req:.0f} | {budget:.3f} |\n"
+    
+    return stats_text
+
+def reconstruct_irminsul(pure_input, withered_input):
+    # 1. Validation & Truncation for pure sequence
+    valid_elements = ELEMENTS
+    clean_pure = "".join([c.upper() for c in pure_input if c.upper() in valid_elements])
+    pure_str = clean_pure[:16]
+    
+    # 2. Validation & Truncation for withered sequence
+    valid_chars = ELEMENTS + ['W']
+    clean_withered = "".join([c.upper() for c in withered_input if c.upper() in valid_chars])
+    withered_str = clean_withered[:16]
+    
+    if not withered_str:
+        return "Please enter valid Elemental symbols (P, H, E, C, A, D, G) or 'W' for Withering.", None
+    
+    # 3. Convert withered string to observation indices
+    try:
+        withered_indices = [OBS_MAP[c] for c in withered_str]
+    except KeyError:
+        return "Invalid character in withered input. Please use only P, H, E, C, A, D, G, or W.", None
+
+    # 4. Use actual Viterbi algorithm
+    reconstructed, path_indices = trikarma_purification(withered_indices, return_indices=True)
+    reconstructed_str = "".join(reconstructed)
+    
+    # 5. Calculate accuracy if pure sequence is provided
+    accuracy_info = ""
+    pure_record_for_plot = None
+    if pure_str:
+        # Truncate or pad pure_str to match reconstructed length
+        if len(pure_str) != len(reconstructed_str):
+            if len(pure_str) > len(reconstructed_str):
+                pure_str = pure_str[:len(reconstructed_str)]
+            else:
+                # Pad with empty or use what we have
+                pass
+        
+        if len(pure_str) == len(reconstructed_str):
+            mismatches = sum(1 for i in range(len(reconstructed_str)) if reconstructed_str[i] != pure_str[i])
+            total = len(reconstructed_str)
+            accuracy = ((total - mismatches) / total * 100) if total > 0 else 0
+            accuracy_info = f"\nAccuracy: {accuracy:.1f}% ({total - mismatches}/{total} correct, {mismatches} mismatches)"
+            pure_record_for_plot = pure_str
+    
+    # 6. Use the actual trellis plotting function
+    fig = plot_viterbi_trellis(withered_str, ELEMENTS, path_indices, output_path=None, pure_record=pure_record_for_plot)
+    
+    output_text = reconstructed_str + accuracy_info
+    return output_text, fig
+
+def simulate_triple_comparison(u_name, u_age, u_vision, initial_scenario):
+    """
+    Compare custom character against Collei and Dunyarzad using the actual Eleazar model.
+    Uses the real eleazar_model function from the Eleazar package.
+    """
+    # Initial condition scenarios
+    initial_conditions = {
+        "Heavy": [84.0, 20.0, 12.0],  # V_0, C_0, S_0
+        "Medium": [86.0, 12.0, 8.0],
+        "Light": [90.0, 5.0, 2.0]
+    }
+    
+    y0 = initial_conditions[initial_scenario]
+    
+    # Define benchmark scenarios
+    scenarios = [
+        {"name": "Collei (Young, Dendro Vision)", "age": 18, "vision": True, "color": "#a6c938"},
+        {"name": "Dunyarzad (Elderly, No Vision)", "age": 65, "vision": False, "color": "#ef7a35"},
+        {"name": f"{u_name} (Custom)", "age": int(u_age), "vision": bool(u_vision), "color": "#3498db"}
+    ]
+    
+    # Base parameters from Eleazar solver
+    base_params = [0.12, 0.06, 0.22, 0.04, 0.08]  # [regen, drain, corruption_rate, scale_drag, ossification]
+    t = np.linspace(0, 120, 1200)
+    
+    # Run simulation for each scenario using actual Eleazar model
+    results = {}
+    for sc in scenarios:
+        sol = odeint(eleazar_model, y0, t, args=(sc['age'], sc['vision'], base_params))
+        results[sc['name']] = sol
+    
+    # Create visualization
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True)
+    
+    for sc in scenarios:
+        data = results[sc['name']]
+        ax1.plot(t, data[:, 0], label=f"{sc['name']} - Vitality", color=sc['color'], linewidth=2)
+        ax2.plot(t, data[:, 2], label=f"{sc['name']} - Scales", color=sc['color'], linewidth=2)
+        # Also show corruption for custom character
+        if sc['name'] == f"{u_name} (Custom)":
+            ax1.plot(t, data[:, 1], label=f"{sc['name']} - Corruption", color=sc['color'], linestyle="--", alpha=0.6)
+    
+    # Aesthetics
+    ax1.set_ylabel("Vitality (%)")
+    ax1.set_title(f"Eleazar: Vitality Dynamics (Gavrilov Reliability) - Comparison\nInitial: {initial_scenario} (V={y0[0]:.1f}%, C={y0[1]:.1f}%, S={y0[2]:.1f}%)")
+    ax1.axhline(15, color='black', linestyle=':', label="Critical Failure Threshold", alpha=0.5)
+    ax1.legend()
+    ax1.grid(alpha=0.3)
+    
+    ax2.set_ylabel("Petrification (Scales %)")
+    ax2.set_xlabel("Days Since Exposure")
+    ax2.set_title("Eleazar Physical Progression")
+    ax2.legend()
+    ax2.grid(alpha=0.3)
+    
+    plt.tight_layout()
+    return fig
+
+def generate_phase3_plots(name, age, has_vision, efficiency, boss_hp):
+    """
+    Generate 2D comparison plot and 3D survival ridge for Phase 3: Delusion Toxicity
+    """
+    age = int(age)
+    efficiency = float(efficiency)
+    boss_hp = float(boss_hp)
+    
+    # --- 1. Generate 2D Comparison Plot ---
+    fig2d, ax2d = plt.subplots(figsize=(10, 6))
+    hp_range = np.linspace(10000, boss_hp * 1.5, 20)
+    
+    # Benchmark subjects: Childe, Arlecchino, and NPC
+    benchmarks = [
+        {"name": "Childe", "age": 23, "vis": True, "eff": 0.65, "color": "#e67e22"},
+        {"name": "Arlecchino", "age": 30, "vis": True, "eff": 0.95, "color": "#c0392b"},
+        {"name": "Foolish NPC", "age": 16, "vis": False, "eff": 0.05, "color": "#7f8c8d"}
+    ]
+    
+    # Plot benchmarks
+    for bench in benchmarks:
+        costs = []
+        hps = []
+        budget = np.exp(-0.012 * bench["age"]) - 0.15
+        
+        for hp in hp_range:
+            cost = activate_delusion(bench["name"], bench["age"], bench["vis"], bench["eff"], hp, silent=True)
+            if cost and cost <= budget:
+                costs.append(cost)
+                hps.append(hp)
+            else:
+                break
+        
+        # Ensure line is visible even if they die instantly
+        if len(hps) == 0:
+            hps.append(0)
+            costs.append(0)
+            hps.append(hp_range[0])
+            costs.append(budget)
+        
+        if len(hps) > 0:
+            ax2d.plot(hps, costs, label=f"{bench['name']} (Budget: {budget:.2f})", 
+                     color=bench["color"], marker='o', linewidth=2)
+            # Mark death point with skull
+            ax2d.scatter(hps[-1], costs[-1], marker='$\u2620$', color='black', s=250, zorder=5)
+    
+    # Plot custom subject
+    costs = []
+    hps = []
+    budget = np.exp(-0.012 * age) - 0.15
+    
+    for hp in hp_range:
+        cost = activate_delusion(name, age, has_vision, efficiency, hp, silent=True)
+        if cost and cost <= budget:
+            costs.append(cost)
+            hps.append(hp)
+        else:
+            break
+    
+    # Ensure line is visible even if they die instantly
+    if len(hps) == 0:
+        hps.append(0)
+        costs.append(0)
+        hps.append(hp_range[0])
+        costs.append(budget)
+    
+    ax2d.plot(hps, costs, label=f"{name} (Budget: {budget:.2f})", 
+             color="#3498db", marker='o', linewidth=2)
+    
+    if len(hps) > 0:
+        ax2d.scatter(hps[-1], costs[-1], marker='$\u2620$', color='black', s=250, zorder=5)
+    
+    ax2d.axhline(y=0.15, color='red', linestyle='--', alpha=0.5, label="Critical Instability (15%)")
+    ax2d.axhline(y=0, color='red', linestyle='--', alpha=0.5, label="Baseline (0%)")
+    ax2d.set_title(f"Forensic Damage Scaling for {name}")
+    
+    # Use appropriate scaling for HP values
+    if boss_hp >= 1000000:
+        # Scale to millions
+        ax2d.set_xlabel("Total Damage Required (Boss HP, millions)")
+        ax2d.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x/1e6:.1f}M'))
+    elif boss_hp >= 1000:
+        # Scale to thousands
+        ax2d.set_xlabel("Total Damage Required (Boss HP, thousands)")
+        ax2d.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x/1e3:.0f}K'))
+    else:
+        ax2d.set_xlabel("Total Damage Required (Boss HP)")
+    
+    ax2d.set_ylabel("Gavrilov Redundancy Cost (R-Loss)")
+    ax2d.set_ylim(bottom=-0.1, top=1.1)
+    ax2d.legend()
+    ax2d.grid(True, which="both", ls="-", alpha=0.2)
+    
+    # --- 2. Generate 3D Survival Ridge ---
+    fig3d = plt.figure(figsize=(10, 7))
+    ax3d = fig3d.add_subplot(111, projection='3d')
+    
+    efficiencies = np.linspace(0.05, 0.95, 15)
+    hps_3d = np.linspace(100000, int(boss_hp * 1.2), 15)
+    X, Y = np.meshgrid(efficiencies, hps_3d)
+    Z = np.zeros(X.shape)
+    
+    for i in range(len(hps_3d)):
+        for j in range(len(efficiencies)):
+            has_vis = X[i, j] > 0.6
+            result_cost = activate_delusion("Subject", age=25, has_vision=has_vis, 
+                                          efficiency=X[i, j], boss_hp=Y[i, j], silent=True)
+            initial_R = np.exp(-0.012 * 25)
+            if result_cost is not None:
+                remaining = initial_R - result_cost
+                Z[i, j] = max(0.15, remaining)
+            else:
+                Z[i, j] = 0.15
+    
+    surf = ax3d.plot_surface(X, Y, Z, cmap='inferno', edgecolor='none', alpha=0.9)
+    ax3d.set_title("Delusions: The 3D Survival Ridge", fontsize=14)
+    ax3d.set_xlabel("Mastery Efficiency (η)")
+    
+    # Use appropriate scaling for HP values in 3D plot
+    if boss_hp >= 1000000:
+        ax3d.set_ylabel("Combat Load (Boss HP, millions)")
+        ax3d.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x/1e6:.1f}M'))
+    elif boss_hp >= 1000:
+        ax3d.set_ylabel("Combat Load (Boss HP, thousands)")
+        ax3d.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x/1e3:.0f}K'))
+    else:
+        ax3d.set_ylabel("Combat Load (Boss HP)")
+    
+    ax3d.set_zlabel("Biological Redundancy (R)")
+    fig3d.colorbar(surf, ax=ax3d, shrink=0.5, aspect=5, label='Survival Probability')
+    
+    return fig2d, fig3d

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.0.0
+numpy>=1.24.0
+scipy>=1.10.0
+matplotlib>=3.7.0

ui.py

@@ -0,0 +1,129 @@
+import gradio as gr # type: ignore
+from handlers import reconstruct_irminsul, simulate_triple_comparison, generate_phase3_plots, get_benchmark_stats
+
+# Use darker Collei green (#6b8a26) for theme
+custom_theme = gr.themes.Soft(
+    primary_hue=gr.themes.Color(
+        c50="#e8f5e9",
+        c100="#c8e6c9",
+        c200="#a5d6a7",
+        c300="#81c784",
+        c400="#66bb6a",
+        c500="#6b8a26",
+        c600="#5a7a1f",
+        c700="#4a6a18",
+        c800="#3a5a11",
+        c900="#2a4a0a",
+        c950="#1a3a03",
+    )
+)
+
+with gr.Blocks(theme=custom_theme) as demo:
+    gr.Markdown("# A mathematical analysis of biological systems in *Genshin Impact*")
+    
+    with gr.Tab("Phase 1: Irminsul Recovery"):
+        gr.Markdown("## Project Overview")
+        gr.Markdown(
+            "This project treats **Irminsul** (The World Tree) from *Genshin Impact* as a biological database of Teyvat's history and genetic blueprints. "
+            "Just as DNA is subject to mutations, Irminsul is vulnerable to \"Forbidden Knowledge,\" a form of high-entropy noise known as *The Withering*. "
+            "This project utilizes a **HMM** (Hidden Markov Model) to detect and cleanse this corruption, restoring the \"True Record\" of elemental fluxes using the **Viterbi Algorithm.**"
+        )
+        gr.Markdown("### Forensic Signal Reconstruction")
+        gr.Markdown("Input a pure sequence (optional) and a 'Withered' elemental sequence to attempt recovery.")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                txt_pure = gr.Textbox(label="Pure Sequence (Optional, Max 16 chars)", placeholder="e.g. DEEEPAHHG")
+                txt_withered = gr.Textbox(label="Withered Sequence (Max 16 chars)", placeholder="e.g. DEWEPWHWG")
+                btn_run = gr.Button("Decode Record", variant="primary")
+                txt_output = gr.Textbox(label="Reconstructed Pure Record", lines=3)
+            
+            with gr.Column(scale=4):
+                plot_output = gr.Plot(label="Viterbi Trellis Visualization")
+                plot_caption = gr.Markdown("*The trellis diagram shows the Viterbi algorithm finding the most likely sequence of hidden elements (green path) that would produce the observed corrupted record. When the original pure record differs from the reconstruction, it is shown as a blue dashed line for comparison.*")
+                with gr.Accordion("Explain Accuracy", open=False):
+                    gr.Markdown(
+                        "When the corruption is too high, the algorithm defaults to the \"most logical\" biological path rather than the \"historical truth.\" "
+                        "For example, an original sequence of D-E-E-E (Dendro-Electro-Electro-Electro) might be restored as "
+                        "D-E-D-E (Dendro-Electro-Dendro-Electro) because the algorithm favors the Quicken reaction over simple repetition. "
+                        "This mirrors the lore-accurate phenomenon of the World Tree \"rewriting\" history to fit the laws of Teyvat."
+                    )
+        btn_run.click(fn=reconstruct_irminsul, inputs=[txt_pure, txt_withered], outputs=[txt_output, plot_output])
+
+    with gr.Tab("Phase 2: Eleazar Kinetics"):
+        gr.Markdown("## Project Overview")
+        gr.Markdown(
+            "**Eleazar** is a terminal condition caused by the *Withering* manifesting in human hosts. "
+            "This project applies a modified version of the **Reliability Theory of Aging** (Gavrilov Model) "
+            "to simulate the competition between cellular vitality and Abyssal contamination.\n\n"
+            "We treat the human body as a system of redundant components. "
+            "Failure (Eleazar) occurs when the \"redundancy reserve\" is exhausted. "
+            "The *Gompertz-Makeham Law* is used to define the base mortality and age-dependent decay of a patient. "
+            "We also account for the effects of a *Vision*, which we mathematically define as a redundancy buffer, "
+            "providing a \"metabolic floor\" that prevents the exponential \"avalanche of failures\" typical in terminal Eleazar cases.\n\n"
+            "You can compare your custom character against two canonical Eleazar patients: Collei (young Vision holder) and Dunyarzad "
+            "(elderly non-Vision holder) using the Gavrilov Reliability ODE model."
+        )
+        
+        with gr.Row():
+            with gr.Column():
+                char_name = gr.Textbox(label="Character Name", value="Traveler")
+                age_slide = gr.Slider(10, 90, value=20, step=1, label="Subject Age")
+                vis_check = gr.Checkbox(label="Possesses Vision", value=False)
+                initial_scenario = gr.Radio(
+                    choices=["Heavy", "Medium", "Light"],
+                    value="Heavy",
+                    label="Initial Contamination"
+                )
+                run_btn = gr.Button("Analyze Reliability", variant="primary")
+                
+            with gr.Column():
+                plot_out = gr.Plot()
+                plot_caption_eleazar = gr.Markdown(
+                    "*Note: by changing the initial starting parameters, we can get different scenarios, "
+                    "where all patients recover or non Vision holders failing to recover. By selecting Scenario 1, we demonstrate "
+                    "the power of having a Vision in providing accelerated regeneration and contamination resistance, "
+                    "allowing **Collei** to fully recover despite having high initial contamination.*"
+                )
+
+        run_btn.click(simulate_triple_comparison, 
+                     inputs=[char_name, age_slide, vis_check, initial_scenario], 
+                     outputs=plot_out)
+
+    with gr.Tab("Phase 3: Delusion Toxicity"):
+        gr.Markdown("## Project Overview")
+        gr.Markdown(
+            "We use Constrained Optimization (MILP) to quantify the active destruction caused by Delusion usage. "
+            "We treat a subject's biological life force as a non-renewable currency used to \"purchase\" damage output. "
+            "The model uses `scipy.optimize.linprog` with integrality constraints to solve for the most bio-efficient combat rotation.\n\n"
+            "To reflect lore-accurate combat mastery, the model now maps the Mastery-Efficiency Coefficient (η) to the following mechanical variables:\n\n"
+            "- **Skill Cooldown (CD)**: Ranges from 12s (Low Mastery) to 7s (High Mastery).\n"
+            "- **Burst Energy Requirement (Q)**: Ranges from 90 to 80 energy.\n"
+            "- **Energy Generation (E)**: Scales from 10 to 40 energy per Skill, representing the subject's ability to capture elemental flux.\n"
+            "- **Vision-Damping Factor (ζ)**: Acts as a 1.5x Energy Multiplier and provides a 0.05 safety grounding that reduces biological waste."
+        )
+        gr.Markdown("You can compare your character against benchmark Harbingers (Childe, Arlecchino) and a FoolishNPC to assess survivability under Delusion load.")
+        
+        with gr.Row():
+            gr.Markdown(get_benchmark_stats())
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                age_in = gr.Slider(15, 70, value=25, step=1, label="Age")
+                eff_in = gr.Slider(0.01, 0.8, value=0.5, step=0.01, label="Mastery Efficiency (η)")
+                vis_in = gr.Checkbox(label="Vision", value=False)
+                hp_in = gr.Slider(0, 1500000, value=500000, step=50000, label="Boss HP")
+                btn_phase3 = gr.Button("Run Simulation", variant="primary")
+                
+            with gr.Column(scale=2):
+                with gr.Tabs():
+                    with gr.Tab("2D Analysis"):
+                        plot_2d = gr.Plot(label="Cumulative Cost vs. Damage")
+                        gr.Markdown("*The 2D plot shows cumulative biological cost vs. combat output. **Skull markers (☠) indicate biological collapse points** where the subject's redundancy budget is exhausted and the solver returns 'Infeasible', marking immediate biological liquidation. Red dashed lines mark critical thresholds at 0% (baseline) and 15% (critical instability).*")
+                    with gr.Tab("3D Survival Ridge"):
+                        plot_3d = gr.Plot(label="Topographic Mortality Mapping")
+                        gr.Markdown("*The 3D surface shows biological redundancy as a function of mastery efficiency and combat load. The \"Death Valley\" at 0.15 represents the critical failure threshold where Delusion use becomes fatal.*")
+                        
+        btn_phase3.click(lambda age, vis, eff, hp: generate_phase3_plots("Traveler", age, vis, eff, hp),
+                        inputs=[age_in, vis_in, eff_in, hp_in], 
+                        outputs=[plot_2d, plot_3d])