app_python_backup.py

"""

Atomic VSA Interactive Demo

A Gradio-based demonstration of Vector Symbolic Architecture for clinical triage.

"""

import gradio as gr
import numpy as np
from typing import Dict, List, Tuple

# ============================================================================
# VSA Core Implementation (Python port of Julia logic)
# ============================================================================

D = 2048  # Dimensionality for demo (production uses 10,048)
np.random.seed(42)

class AtomRegistry:
    """Registry of atomic vectors (symbols)."""
    def __init__(self, dim: int = D):
        self.dim = dim
        self.atoms: Dict[str, np.ndarray] = {}
    
    def get_or_create(self, name: str) -> np.ndarray:
        if name not in self.atoms:
            # Create bipolar random vector {-1, +1}^D
            self.atoms[name] = np.random.choice([-1, 1], size=self.dim).astype(np.float32)
        return self.atoms[name]
    
    def __getitem__(self, name: str) -> np.ndarray:
        return self.get_or_create(name)

# Global registry
registry = AtomRegistry()

def bind(a: np.ndarray, b: np.ndarray) -> np.ndarray:
    """BIND operation: Element-wise multiplication (⊗)."""
    return a * b

def bundle(vectors: List[np.ndarray]) -> np.ndarray:
    """BUNDLE operation: Element-wise addition (⊕)."""
    return np.sum(vectors, axis=0)

def similarity(a: np.ndarray, b: np.ndarray) -> float:
    """Cosine similarity between vectors."""
    norm_a = np.linalg.norm(a)
    norm_b = np.linalg.norm(b)
    if norm_a == 0 or norm_b == 0:
        return 0.0
    return float(np.dot(a, b) / (norm_a * norm_b))

def thermometer_encode(value: float, min_val: float, max_val: float, levels: int = 20) -> np.ndarray:
    """Thermometer encoding for continuous values."""
    level_atoms = [registry.get_or_create(f"_level_{i}") for i in range(levels)]
    active_levels = int((value - min_val) / (max_val - min_val) * levels)
    active_levels = max(0, min(levels, active_levels))
    if active_levels == 0:
        return np.zeros(D, dtype=np.float32)
    return bundle(level_atoms[:active_levels])

# ============================================================================
# Clinical Triage System
# ============================================================================

SYMPTOMS = [
    "chest_pain", "shortness_of_breath", "fever", "cough", 
    "headache", "fatigue", "nausea", "dizziness",
    "abdominal_pain", "back_pain", "joint_pain", "rash",
    "sore_throat", "runny_nose", "muscle_ache", "chills"
]

TRIAGE_CATEGORIES = {
    "Emergency - Cardiac": ["chest_pain", "shortness_of_breath", "dizziness"],
    "Urgent - Respiratory": ["shortness_of_breath", "cough", "fever", "chills"],
    "Urgent - Infection": ["fever", "chills", "fatigue", "muscle_ache"],
    "Standard - Flu-like": ["fever", "cough", "sore_throat", "runny_nose", "muscle_ache"],
    "Standard - GI": ["nausea", "abdominal_pain", "fever"],
    "Standard - Musculoskeletal": ["back_pain", "joint_pain", "muscle_ache"],
    "Low Priority - Minor": ["headache", "fatigue", "runny_nose"],
}

# Pre-build prototype vectors for each triage category
PROTOTYPES: Dict[str, np.ndarray] = {}
for category, symptom_list in TRIAGE_CATEGORIES.items():
    molecules = []
    for symptom in symptom_list:
        field_atom = registry[f"symptom_field"]
        value_atom = registry[symptom]
        molecules.append(bind(field_atom, value_atom))
    PROTOTYPES[category] = bundle(molecules)

def create_patient_vector(symptoms: List[str], vitals: Dict[str, float]) -> np.ndarray:
    """Create a patient record as a bundled molecule."""
    molecules = []
    
    # Encode symptoms
    for symptom in symptoms:
        if symptom in SYMPTOMS:
            field_atom = registry["symptom_field"]
            value_atom = registry[symptom]
            molecules.append(bind(field_atom, value_atom))
    
    # Encode vitals with thermometer encoding
    if "heart_rate" in vitals:
        hr_encoded = thermometer_encode(vitals["heart_rate"], 40, 180)
        molecules.append(bind(registry["heart_rate_field"], hr_encoded))
    
    if "temperature" in vitals:
        temp_encoded = thermometer_encode(vitals["temperature"], 35, 42)
        molecules.append(bind(registry["temperature_field"], temp_encoded))
    
    if "blood_pressure_sys" in vitals:
        bp_encoded = thermometer_encode(vitals["blood_pressure_sys"], 80, 200)
        molecules.append(bind(registry["bp_field"], bp_encoded))
    
    if not molecules:
        return np.zeros(D, dtype=np.float32)
    
    return bundle(molecules)

def triage_patient(patient_vector: np.ndarray) -> List[Tuple[str, float]]:
    """Classify patient against triage prototypes."""
    scores = []
    for category, prototype in PROTOTYPES.items():
        sim = similarity(patient_vector, prototype)
        scores.append((category, sim))
    
    # Sort by similarity descending
    scores.sort(key=lambda x: x[1], reverse=True)
    return scores

# ============================================================================
# Gradio Interface
# ============================================================================

def process_triage(

    chest_pain: bool, shortness_of_breath: bool, fever: bool, cough: bool,

    headache: bool, fatigue: bool, nausea: bool, dizziness: bool,

    abdominal_pain: bool, back_pain: bool, joint_pain: bool, rash: bool,

    sore_throat: bool, runny_nose: bool, muscle_ache: bool, chills: bool,

    heart_rate: float, temperature: float, blood_pressure: float

) -> Tuple[str, str, str]:
    """Process symptoms and return triage classification."""
    
    # Collect selected symptoms
    symptom_map = {
        "chest_pain": chest_pain, "shortness_of_breath": shortness_of_breath,
        "fever": fever, "cough": cough, "headache": headache, "fatigue": fatigue,
        "nausea": nausea, "dizziness": dizziness, "abdominal_pain": abdominal_pain,
        "back_pain": back_pain, "joint_pain": joint_pain, "rash": rash,
        "sore_throat": sore_throat, "runny_nose": runny_nose,
        "muscle_ache": muscle_ache, "chills": chills
    }
    
    selected_symptoms = [s for s, v in symptom_map.items() if v]
    
    if not selected_symptoms:
        return "No symptoms selected", "", ""
    
    # Create patient vector
    vitals = {
        "heart_rate": heart_rate,
        "temperature": temperature,
        "blood_pressure_sys": blood_pressure
    }
    
    patient_vec = create_patient_vector(selected_symptoms, vitals)
    
    # Get triage scores
    scores = triage_patient(patient_vec)
    
    # Format results
    primary = scores[0]
    primary_result = f"**{primary[0]}**\nSimilarity: {primary[1]:.4f}"
    
    # All scores
    all_scores = "\n".join([f"{cat}: {sim:.4f}" for cat, sim in scores])
    
    # Explanation
    explanation = f"""

**VSA Explanation:**

- Patient encoded as {D}-dimensional bipolar vector

- Symptoms: {', '.join(selected_symptoms)}

- Heart Rate: {heart_rate} bpm → Thermometer encoded

- Temperature: {temperature}°C → Thermometer encoded  

- Blood Pressure: {blood_pressure} mmHg → Thermometer encoded



**How it works:**

1. Each symptom is BOUND (⊗) with a field identifier

2. All bound pairs are BUNDLED (⊕) into a superposition

3. Cosine similarity computed against {len(PROTOTYPES)} prototypes

4. Classification is deterministic and fully explainable

"""
    
    return primary_result, all_scores, explanation

def demo_bind_operation(concept_a: str, concept_b: str) -> str:
    """Demonstrate BIND operation."""
    if not concept_a or not concept_b:
        return "Enter two concepts"
    
    vec_a = registry[concept_a]
    vec_b = registry[concept_b]
    bound = bind(vec_a, vec_b)
    
    # Verify self-inverse property
    unbound = bind(bound, vec_b)
    recovery_sim = similarity(unbound, vec_a)
    
    return f"""

**BIND Operation: {concept_a} ⊗ {concept_b}**



Vector A (first 10 dims): {vec_a[:10].astype(int).tolist()}

Vector B (first 10 dims): {vec_b[:10].astype(int).tolist()}

Bound (first 10 dims): {bound[:10].astype(int).tolist()}



**Self-Inverse Property:**

(A ⊗ B) ⊗ B = A

Recovery similarity: {recovery_sim:.6f} (should be 1.0)



**Orthogonality:**

Sim(A, B): {similarity(vec_a, vec_b):.4f} (random vectors ≈ 0)

Sim(A, Bound): {similarity(vec_a, bound):.4f} (bound dissimilar to inputs)

"""

def demo_bundle_operation(concepts: str) -> str:
    """Demonstrate BUNDLE operation."""
    if not concepts:
        return "Enter comma-separated concepts"
    
    concept_list = [c.strip() for c in concepts.split(",") if c.strip()]
    if len(concept_list) < 2:
        return "Enter at least 2 concepts"
    
    vectors = [registry[c] for c in concept_list]
    bundled = bundle(vectors)
    
    # Show similarity to each component
    sims = [(c, similarity(bundled, registry[c])) for c in concept_list]
    
    sim_report = "\n".join([f"  Sim(Bundle, {c}): {s:.4f}" for c, s in sims])
    
    return f"""

**BUNDLE Operation: {' ⊕ '.join(concept_list)}**



Bundled {len(concept_list)} vectors into superposition.



**Holographic Property - Bundle is similar to ALL inputs:**

{sim_report}



Unlike classical storage, the bundle simultaneously represents 

all {len(concept_list)} concepts in the same {D}-dimensional space!

"""

# Build the Gradio app
with gr.Blocks(title="Atomic VSA Demo", theme=gr.themes.Soft()) as demo:
    gr.Markdown("""

    # ⚛️ Atomic VSA: Interactive Demo

    

    **Physics-Inspired Hyperdimensional Computing for Explainable Clinical AI**

    

    [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18650281.svg)](https://doi.org/10.5281/zenodo.18650281)

    [![GitHub](https://img.shields.io/badge/GitHub-atomic--vsa--research-blue)](https://github.com/muhammadarshad/atomic-vsa-research)

    

    This demo showcases the Atomic Vector Symbolic Architecture (Atomic VSA) — 

    a deterministic, interpretable AI framework achieving **92.5% F1** on clinical triage.

    """)
    
    with gr.Tabs():
        # Tab 1: Clinical Triage Demo
        with gr.TabItem("🏥 Clinical Triage"):
            gr.Markdown("### Enter Patient Symptoms & Vitals")
            
            with gr.Row():
                with gr.Column():
                    gr.Markdown("**Symptoms:**")
                    chest_pain = gr.Checkbox(label="Chest Pain")
                    shortness_of_breath = gr.Checkbox(label="Shortness of Breath")
                    fever = gr.Checkbox(label="Fever")
                    cough = gr.Checkbox(label="Cough")
                    headache = gr.Checkbox(label="Headache")
                    fatigue = gr.Checkbox(label="Fatigue")
                    nausea = gr.Checkbox(label="Nausea")
                    dizziness = gr.Checkbox(label="Dizziness")
                
                with gr.Column():
                    gr.Markdown("**More Symptoms:**")
                    abdominal_pain = gr.Checkbox(label="Abdominal Pain")
                    back_pain = gr.Checkbox(label="Back Pain")
                    joint_pain = gr.Checkbox(label="Joint Pain")
                    rash = gr.Checkbox(label="Rash")
                    sore_throat = gr.Checkbox(label="Sore Throat")
                    runny_nose = gr.Checkbox(label="Runny Nose")
                    muscle_ache = gr.Checkbox(label="Muscle Ache")
                    chills = gr.Checkbox(label="Chills")
                
                with gr.Column():
                    gr.Markdown("**Vitals:**")
                    heart_rate = gr.Slider(40, 180, value=75, label="Heart Rate (bpm)")
                    temperature = gr.Slider(35.0, 42.0, value=37.0, step=0.1, label="Temperature (°C)")
                    blood_pressure = gr.Slider(80, 200, value=120, label="Systolic BP (mmHg)")
            
            triage_btn = gr.Button("🔬 Run Triage", variant="primary")
            
            with gr.Row():
                primary_output = gr.Markdown(label="Primary Classification")
                scores_output = gr.Textbox(label="All Scores", lines=7)
            
            explanation_output = gr.Markdown(label="VSA Explanation")
            
            triage_btn.click(
                process_triage,
                inputs=[
                    chest_pain, shortness_of_breath, fever, cough,
                    headache, fatigue, nausea, dizziness,
                    abdominal_pain, back_pain, joint_pain, rash,
                    sore_throat, runny_nose, muscle_ache, chills,
                    heart_rate, temperature, blood_pressure
                ],
                outputs=[primary_output, scores_output, explanation_output]
            )
        
        # Tab 2: VSA Operations
        with gr.TabItem("🧮 VSA Operations"):
            gr.Markdown("""

            ### Explore the Algebraic Operations

            

            Atomic VSA uses two fundamental operations:

            - **BIND (⊗)**: Creates relational structures (self-inverse)

            - **BUNDLE (⊕)**: Creates holographic superpositions

            """)
            
            with gr.Row():
                with gr.Column():
                    gr.Markdown("#### BIND Operation")
                    bind_a = gr.Textbox(label="Concept A", value="HeartRate")
                    bind_b = gr.Textbox(label="Concept B", value="115bpm")
                    bind_btn = gr.Button("Compute BIND")
                    bind_output = gr.Markdown()
                    
                    bind_btn.click(demo_bind_operation, [bind_a, bind_b], bind_output)
                
                with gr.Column():
                    gr.Markdown("#### BUNDLE Operation")
                    bundle_input = gr.Textbox(
                        label="Concepts (comma-separated)", 
                        value="fever, cough, fatigue"
                    )
                    bundle_btn = gr.Button("Compute BUNDLE")
                    bundle_output = gr.Markdown()
                    
                    bundle_btn.click(demo_bundle_operation, [bundle_input], bundle_output)
        
        # Tab 3: About
        with gr.TabItem("📄 About"):
            gr.Markdown("""

            ## Atomic Vector Symbolic Architecture

            

            ### Key Innovation

            

            Atomic VSA applies **physics-inspired principles** to hyperdimensional computing:

            

            | Physics | Computing (AVSA) | Clinical Medicine |

            |---------|------------------|-------------------|

            | Atom | 10,048-dim vector | Semantic concept |

            | Proton (+) | Positive evidence | Finding FOR diagnosis |

            | Electron (−) | Negative evidence | Finding AGAINST diagnosis |

            | Molecule | BIND(a ⊗ b) | Clinical fact pair |

            | Superposition | BUNDLE(⊕) | Patient record |

            

            ### Performance

            

            | Metric | Result |

            |--------|--------|

            | F1 Score | 92.5% (25-category ICD-11) |

            | Label Recall | 91.9% (comorbidity) |

            | Latency | 11.97ms (p50) |

            | Power | 15W (edge) |

            

            ### Why VSA?

            

            - ✅ **Deterministic**: Same input → same output, always

            - ✅ **Interpretable**: Algebraic operations are transparent

            - ✅ **Efficient**: No training, no GPU required

            - ✅ **Green AI**: 160× lower power than neural networks

            

            ### Links

            

            - **Paper (DOI)**: [10.5281/zenodo.18650281](https://doi.org/10.5281/zenodo.18650281)

            - **Code**: [GitHub](https://github.com/muhammadarshad/atomic-vsa-research)

            - **Author**: Muhammad Arshad (marshad.dev@gmail.com)

            """)

if __name__ == "__main__":
    demo.launch()