app.py

import gradio as gr
import spaces
import torch
import numpy as np
from typing import Tuple, List

class EmotionalContext:
    """Implements Mem|8's emotional context structure"""
    def __init__(self):
        self.valence = torch.zeros(1).cuda()  # -128 to 127: negative to positive
        self.arousal = torch.zeros(1).cuda()  # 0 to 255: intensity level
        self.context = torch.zeros(1).cuda()  # Contextual flags

def create_wave_pattern(size: int, frequency: float, amplitude: float) -> torch.Tensor:
    """Create a wave pattern as described in Mem|8 paper"""
    t = torch.linspace(0, 2*np.pi, size).cuda()
    x = torch.linspace(0, 2*np.pi, size).cuda()
    T, X = torch.meshgrid(t, x, indexing='ij')
    return amplitude * torch.sin(frequency * T + X)

@spaces.GPU(duration=30)
def quantum_memory_ops(input_size: int, operation: str, emotion_valence: float) -> Tuple[str, np.ndarray]:
    """Perform quantum-inspired memory operations using Mem|8 concepts."""
    # Initialize emotional context
    emotion = EmotionalContext()
    emotion.valence = torch.tensor([emotion_valence]).cuda()
    emotion.arousal = torch.abs(torch.tensor([emotion_valence * 2])).cuda()
    
    results = []
    visualization = None
    
    if operation == "wave_memory":
        # Create memory wave pattern (M = A·exp(iωt-kx)·D·E)
        wave = create_wave_pattern(input_size, 2.0, 1.0)
        emotional_mod = torch.exp(emotion.valence/128 * wave)
        memory_state = wave * emotional_mod
        
        results.append(f"Wave Memory Pattern Created:")
        results.append(f"Shape: {memory_state.shape}")
        results.append(f"Emotional Modulation: {emotional_mod.mean().item():.4f}")
        results.append(f"Memory Coherence: {torch.linalg.norm(memory_state).item():.4f}")
        visualization = memory_state.cpu().numpy()
        
    elif operation == "interference":
        # Create interference between two memory waves
        wave1 = create_wave_pattern(input_size, 2.0, 1.0)
        wave2 = create_wave_pattern(input_size, 3.0, 0.5)
        interference = wave1 + wave2
        emotional_weight = torch.sigmoid(emotion.valence/128) * interference
        
        results.append(f"Memory Interference Pattern:")
        results.append(f"Pattern Strength: {torch.max(emotional_weight).item():.4f}")
        results.append(f"Emotional Weight: {emotion.valence.item()/128:.4f}")
        visualization = emotional_weight.cpu().numpy()
        
    elif operation == "resonance":
        # Demonstrate emotional resonance patterns
        base_wave = create_wave_pattern(input_size, 2.0, 1.0)
        resonance_freq = 1.0 + torch.sigmoid(emotion.valence/128)
        resonant_wave = create_wave_pattern(input_size, resonance_freq.item(), 1.0)
        resonance = base_wave * resonant_wave
        
        results.append(f"Emotional Resonance Pattern:")
        results.append(f"Resonance Frequency: {resonance_freq.item():.4f}")
        results.append(f"Pattern Energy: {torch.sum(resonance**2).item():.4f}")
        visualization = resonance.cpu().numpy()
    
    results.append(f"\nEmotional Context:")
    results.append(f"Valence: {emotion.valence.item():.2f}")
    results.append(f"Arousal: {emotion.arousal.item():.2f}")
    results.append(f"Device: {wave.device}")
    
    return "\n".join(results), visualization

# Create a beautiful interface inspired by Mem|8's wave concepts
with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple", secondary_hue="blue")) as demo:
    gr.Markdown("""
    # 🌊 Mem|8 Wave Memory Explorer
    
    Welcome to 8b.is's quantum memory demonstration! This showcase implements concepts from our Mem|8 
    wave-based memory architecture paper, visualizing how memories propagate and interact like waves 
    in an ocean of consciousness.
    
    > "Memory is not a storage unit, but a living ocean of waves" - Mem|8 Paper
    """)
    
    with gr.Row():
        with gr.Column():
            size_input = gr.Slider(
                minimum=16, 
                maximum=128, 
                value=32, 
                step=16, 
                label="Memory Grid Size"
            )
            operation_input = gr.Radio(
                ["wave_memory", "interference", "resonance"],
                label="Memory Wave Operation",
                value="wave_memory",
                info="Select the type of wave-based memory operation to visualize"
            )
            emotion_input = gr.Slider(
                minimum=-128,
                maximum=127,
                value=0,
                step=1,
                label="Emotional Valence",
                info="Emotional context from negative to positive (-128 to 127)"
            )
            run_btn = gr.Button("Generate Memory Wave", variant="primary")
        
        with gr.Column():
            output_text = gr.Textbox(label="Wave Analysis", lines=8)
            output_plot = gr.Plot(label="Wave Visualization")
            
    run_btn.click(
        quantum_memory_ops,
        inputs=[size_input, operation_input, emotion_input],
        outputs=[output_text, output_plot]
    )
    
    gr.Markdown("""
    ### 🧠 Understanding Wave Memory
    
    This demo visualizes three key concepts from our Mem|8 paper:
    1. **Wave Memory**: Memories as propagating waves with emotional modulation
    2. **Interference**: How different memories interact and combine
    3. **Resonance**: Emotional resonance patterns in memory formation
    
    The visualization shows how emotional context (valence) affects memory wave patterns,
    demonstrating the dynamic, interconnected nature of our quantum memory architecture.
    
    All computations are accelerated using Hugging Face's Zero GPU technology! 
    """)

demo.launch()