ok

app.py

@@ -1,9 +1,16 @@
 import gradio as gr
-import spaces
 import torch
 import numpy as np
-from typing import Tuple, List
+import matplotlib.pyplot as plt
+from matplotlib import cm
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import random
+from typing import Tuple, List, Dict, Any, Optional
+import time
+import colorsys
+import math
+from PIL import Image, ImageDraw, ImageFilter
 
 # Try importing Stable Diffusion dependencies
 try:
@@ -13,6 +20,14 @@ except ImportError:
     print("Warning: diffusers package not available. Artistic visualization will be disabled.")
     STABLE_DIFFUSION_AVAILABLE = False
 
+# Try importing 3D visualization dependencies
+try:
+    import plotly.express as px
+    PLOTLY_3D_AVAILABLE = True
+except ImportError:
+    print("Warning: plotly.express not available. 3D visualization will be limited.")
+    PLOTLY_3D_AVAILABLE = False
+
 # Initialize Stable Diffusion only if available
 pipe = None
 if STABLE_DIFFUSION_AVAILABLE:
@@ -24,32 +39,269 @@ if STABLE_DIFFUSION_AVAILABLE:
         pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
         pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(model_repo_id, subfolder="scheduler", shift=5)
         pipe = pipe.to(device)
+        print(f"✅ Stable Diffusion initialized on {device}")
     except Exception as e:
-        print(f"Warning: Could not initialize Stable Diffusion: {e}")
+        print(f"⚠️ Could not initialize Stable Diffusion: {e}")
         STABLE_DIFFUSION_AVAILABLE = False
 
+# Constants
 MAX_SEED = np.iinfo(np.int32).max
+DEFAULT_GRID_SIZE = 64
+WAVE_TYPES = ["sine", "cosine", "gaussian", "square"]
+MEMORY_OPERATIONS = [
+    "wave_memory", 
+    "interference", 
+    "resonance", 
+    "hot_tub_mode", 
+    "emotional_resonance",
+    "pattern_completion"
+]
+
+# Color palettes for different emotional states
+COLOR_PALETTES = {
+    "positive": ["#FF5E5B", "#D8D8F6", "#E8AA14", "#32E875", "#3C91E6"],
+    "neutral": ["#FAFFFD", "#A1CDF4", "#7D83FF", "#3A3042", "#080708"],
+    "negative": ["#1B1B1E", "#373F51", "#58A4B0", "#A9BCD0", "#D8DBE2"]
+}
 
 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 __init__(self, device="cuda" if torch.cuda.is_available() else "cpu"):
+        self.device = device
+        self.valence = torch.zeros(1).to(device)  # -128 to 127: negative to positive
+        self.arousal = torch.zeros(1).to(device)  # 0 to 255: intensity level
+        self.context = torch.zeros(1).to(device)  # Contextual flags
+        self.safety = torch.ones(1).to(device) * 100  # Safety level (0-100)
+        
+        # Memory blanket parameters
+        self.resonance_freq = torch.tensor(1.0).to(device)
+        self.filter_strength = torch.tensor(0.5).to(device)
+        
+        # Hot tub mode parameters
+        self.hot_tub_active = False
+        self.hot_tub_temperature = torch.tensor(37.0).to(device)  # Default comfortable temperature
+        self.hot_tub_participants = []
+        
+    def update(self, valence: float, arousal: Optional[float] = None):
+        """Update emotional context based on valence and arousal"""
+        self.valence = torch.tensor([valence]).to(self.device)
+        
+        # If arousal not provided, calculate it based on valence intensity
+        if arousal is None:
+            self.arousal = torch.abs(torch.tensor([valence * 2])).to(self.device)
+        else:
+            self.arousal = torch.tensor([arousal]).to(self.device)
+            
+        # Update resonance frequency based on emotional state
+        self.resonance_freq = 1.0 + torch.sigmoid(self.valence/128)
+        
+        # Update filter strength based on arousal
+        self.filter_strength = torch.sigmoid(self.arousal/128)
+        
+        return self
+    
+    def get_color_palette(self):
+        """Get color palette based on emotional valence"""
+        if self.valence.item() > 20:
+            return COLOR_PALETTES["positive"]
+        elif self.valence.item() < -20:
+            return COLOR_PALETTES["negative"]
+        else:
+            return COLOR_PALETTES["neutral"]
+    
+    def activate_hot_tub(self, temperature: float = 37.0):
+        """Activate hot tub mode with specified temperature"""
+        self.hot_tub_active = True
+        self.hot_tub_temperature = torch.tensor(temperature).to(self.device)
+        return self
+    
+    def deactivate_hot_tub(self):
+        """Deactivate hot tub mode"""
+        self.hot_tub_active = False
+        self.hot_tub_participants = []
+        return self
+    
+    def add_hot_tub_participant(self, participant: str):
+        """Add participant to hot tub session"""
+        if self.hot_tub_active and participant not in self.hot_tub_participants:
+            self.hot_tub_participants.append(participant)
+        return self
+    
+    def get_state_dict(self) -> Dict[str, Any]:
+        """Get emotional context as dictionary for display"""
+        return {
+            "valence": self.valence.item(),
+            "arousal": self.arousal.item(),
+            "resonance_frequency": self.resonance_freq.item(),
+            "filter_strength": self.filter_strength.item(),
+            "hot_tub_active": self.hot_tub_active,
+            "hot_tub_temperature": self.hot_tub_temperature.item() if self.hot_tub_active else None,
+            "hot_tub_participants": self.hot_tub_participants if self.hot_tub_active else [],
+            "safety_level": self.safety.item()
+        }
 
-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)
+class WaveProcessor:
+    """Processes wave-based memory patterns"""
+    def __init__(self, device="cuda" if torch.cuda.is_available() else "cpu"):
+        self.device = device
+        
+    def create_wave_pattern(self, 
+                           size: int, 
+                           frequency: float, 
+                           amplitude: float, 
+                           wave_type: str = "sine") -> torch.Tensor:
+        """Create a wave pattern as described in Mem|8 paper"""
+        t = torch.linspace(0, 2*np.pi, size).to(self.device)
+        x = torch.linspace(0, 2*np.pi, size).to(self.device)
+        T, X = torch.meshgrid(t, x, indexing='ij')
+        
+        if wave_type == "sine":
+            return amplitude * torch.sin(frequency * T + X)
+        elif wave_type == "cosine":
+            return amplitude * torch.cos(frequency * T + X)
+        elif wave_type == "gaussian":
+            # Create a Gaussian wave pattern
+            sigma = size / (4 * frequency)
+            mu_t = size / 2
+            mu_x = size / 2
+            gauss_t = torch.exp(-((t - mu_t) ** 2) / (2 * sigma ** 2))
+            gauss_x = torch.exp(-((x - mu_x) ** 2) / (2 * sigma ** 2))
+            G_T, G_X = torch.meshgrid(gauss_t, gauss_x, indexing='ij')
+            return amplitude * G_T * G_X
+        elif wave_type == "square":
+            # Create a square wave pattern
+            square_t = torch.sign(torch.sin(frequency * t))
+            square_x = torch.sign(torch.sin(frequency * x))
+            S_T, S_X = torch.meshgrid(square_t, square_x, indexing='ij')
+            return amplitude * S_T * S_X
+        else:
+            # Default to sine wave
+            return amplitude * torch.sin(frequency * T + X)
+    
+    def apply_emotional_modulation(self, 
+                                  wave: torch.Tensor, 
+                                  emotion: EmotionalContext) -> torch.Tensor:
+        """Apply emotional modulation to wave pattern"""
+        # Modulate wave based on emotional valence
+        emotional_mod = torch.exp(emotion.valence/128 * wave)
+        return wave * emotional_mod
+    
+    def create_interference_pattern(self, 
+                                   wave1: torch.Tensor, 
+                                   wave2: torch.Tensor, 
+                                   emotion: EmotionalContext) -> torch.Tensor:
+        """Create interference between two wave patterns"""
+        interference = wave1 + wave2
+        # Weight by emotional valence
+        emotional_weight = torch.sigmoid(emotion.valence/128) * interference
+        return emotional_weight
+    
+    def create_resonance_pattern(self, 
+                                base_wave: torch.Tensor, 
+                                emotion: EmotionalContext) -> torch.Tensor:
+        """Create resonance pattern based on emotional state"""
+        resonant_wave = self.create_wave_pattern(
+            base_wave.shape[0], 
+            emotion.resonance_freq.item(), 
+            1.0
+        )
+        resonance = base_wave * resonant_wave
+        return resonance
+    
+    def apply_memory_blanket(self, 
+                            wave: torch.Tensor, 
+                            emotion: EmotionalContext) -> torch.Tensor:
+        """Apply memory blanket filtering as described in the paper"""
+        # Create a filter based on wave amplitude and emotional state
+        wave_amplitude = torch.abs(wave)
+        importance_threshold = emotion.filter_strength * wave_amplitude.mean()
+        
+        # Apply the filter - keep only significant waves
+        filtered_wave = wave * (wave_amplitude > importance_threshold).float()
+        return filtered_wave
+    
+    def create_hot_tub_pattern(self, 
+                              size: int, 
+                              emotion: EmotionalContext) -> torch.Tensor:
+        """Create a hot tub pattern for safe exploration"""
+        if not emotion.hot_tub_active:
+            return torch.zeros((size, size)).to(self.device)
+        
+        # Create base wave pattern
+        base_wave = self.create_wave_pattern(size, 1.0, 1.0, "sine")
+        
+        # Modulate based on hot tub temperature
+        temp_factor = emotion.hot_tub_temperature / 50.0  # Normalize to 0-1 range
+        temp_wave = self.create_wave_pattern(size, temp_factor.item(), 0.5, "gaussian")
+        
+        # Add ripples for each participant
+        participant_count = len(emotion.hot_tub_participants)
+        if participant_count > 0:
+            ripple_wave = self.create_wave_pattern(
+                size, 
+                2.0 + participant_count * 0.5, 
+                0.3, 
+                "gaussian"
+            )
+            hot_tub_pattern = base_wave + temp_wave + ripple_wave
+        else:
+            hot_tub_pattern = base_wave + temp_wave
+        
+        # Apply safety modulation
+        safety_factor = emotion.safety / 100.0
+        return hot_tub_pattern * safety_factor
+    
+    def create_pattern_completion(self, 
+                                 size: int, 
+                                 emotion: EmotionalContext, 
+                                 completion_ratio: float = 0.5) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Create a pattern completion demonstration"""
+        # Create original pattern
+        original = self.create_wave_pattern(size, 2.0, 1.0)
+        
+        # Create mask for incomplete pattern (randomly remove portions)
+        mask = torch.rand(size, size).to(self.device) > completion_ratio
+        incomplete = original * mask
+        
+        # Apply emotional context to reconstruction
+        emotional_weight = torch.sigmoid(emotion.valence/128)
+        
+        # Simple reconstruction algorithm (in real system would be more sophisticated)
+        # Here we're just doing a simple interpolation
+        kernel_size = 3
+        padding = kernel_size // 2
+        
+        # Create a kernel for interpolation
+        kernel = torch.ones(1, 1, kernel_size, kernel_size).to(self.device) / (kernel_size ** 2)
+        
+        # Reshape for convolution
+        incomplete_reshaped = incomplete.reshape(1, 1, size, size)
+        
+        # Apply convolution for interpolation
+        with torch.no_grad():
+            reconstructed = torch.nn.functional.conv2d(
+                incomplete_reshaped, 
+                kernel, 
+                padding=padding
+            ).reshape(size, size)
+        
+        # Blend original where mask exists
+        reconstructed = torch.where(mask, reconstructed, original)
+        
+        # Apply emotional modulation
+        reconstructed = reconstructed * (0.5 + emotional_weight * 0.5)
+        
+        return incomplete, reconstructed
 
 def generate_memory_prompt(operation: str, emotion_valence: float) -> str:
     """Generate artistic prompts based on memory operation and emotional state"""
     base_prompts = {
         "wave_memory": "memories flowing like waves in an infinite ocean, ",
         "interference": "two waves of memory intersecting and creating patterns, ",
-        "resonance": "resonating waves of consciousness forming harmonious patterns, "
+        "resonance": "resonating waves of consciousness forming harmonious patterns, ",
+        "hot_tub_mode": "a safe space for exploring memories, like a warm therapeutic pool, ",
+        "emotional_resonance": "emotions as colorful waves interacting with memory patterns, ",
+        "pattern_completion": "fragmented memories being reconstructed into complete patterns, "
     }
     
     emotion_desc = "serene and peaceful" if -20 <= emotion_valence <= 20 else \
@@ -57,73 +309,125 @@ def generate_memory_prompt(operation: str, emotion_valence: float) -> str:
                   "dark and introspective"
     
     style = "digital art, abstract, flowing, wave patterns, "
+    
+    # Add more specific styling based on operation
+    if operation == "hot_tub_mode":
+        style += "warm colors, therapeutic atmosphere, "
+    elif operation == "emotional_resonance":
+        style += "vibrant colors, emotional energy visualization, "
+    elif operation == "pattern_completion":
+        style += "fragmented to whole transition, reconstruction, "
+    
     prompt = f"{base_prompts[operation]}{emotion_desc}, {style} ethereal, dreamlike quality"
     return prompt
 
-@spaces.GPU(duration=65)
-def quantum_memory_ops(
-    input_size: int, 
-    operation: str, 
-    emotion_valence: float,
-    generate_art: bool = True,
-    seed: int = 42
-) -> Tuple[str, np.ndarray, 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()
+def create_wave_visualization(wave_data: np.ndarray, emotion: EmotionalContext) -> go.Figure:
+    """Create an interactive 3D visualization of wave data"""
+    # Get dimensions
+    n, m = wave_data.shape
     
-    results = []
-    wave_viz = None
-    art_viz = None
+    # Create coordinate grids
+    x = np.linspace(0, 1, m)
+    y = np.linspace(0, 1, n)
+    X, Y = np.meshgrid(x, y)
     
-    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}")
-        wave_viz = 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}")
-        wave_viz = 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}")
-        wave_viz = resonance.cpu().numpy()
+    # Get color palette based on emotional state
+    colors = emotion.get_color_palette()
+    colorscale = [[0, colors[0]], 
+                 [0.25, colors[1]], 
+                 [0.5, colors[2]], 
+                 [0.75, colors[3]], 
+                 [1, colors[4]]]
+    
+    # Create 3D surface plot
+    fig = go.Figure(data=[go.Surface(
+        z=wave_data,
+        x=X,
+        y=Y,
+        colorscale=colorscale,
+        lighting=dict(
+            ambient=0.6,
+            diffuse=0.8,
+            fresnel=0.2,
+            roughness=0.5,
+            specular=1.0
+        ),
+        contours={
+            "z": {"show": True, "start": -2, "end": 2, "size": 0.1, "color":"white"}
+        }
+    )])
+    
+    # Update layout
+    fig.update_layout(
+        title=dict(
+            text="Memory Wave Visualization",
+            font=dict(size=24, color="#333333")
+        ),
+        scene=dict(
+            xaxis_title="Space",
+            yaxis_title="Time",
+            zaxis_title="Amplitude",
+            aspectratio=dict(x=1, y=1, z=0.8),
+            camera=dict(
+                eye=dict(x=1.5, y=1.5, z=1.2)
+            )
+        ),
+        margin=dict(l=0, r=0, b=0, t=30),
+        template="plotly_white"
+    )
+    
+    return fig
+
+def create_2d_comparison(wave1: np.ndarray, wave2: np.ndarray, 
+                         title1: str, title2: str, 
+                         emotion: EmotionalContext) -> go.Figure:
+    """Create a side-by-side comparison of two wave patterns"""
+    # Get color palette
+    colors = emotion.get_color_palette()
+    
+    # Create subplots
+    fig = make_subplots(
+        rows=1, cols=2,
+        subplot_titles=(title1, title2),
+        specs=[[{"type": "heatmap"}, {"type": "heatmap"}]]
+    )
+    
+    # Add heatmaps
+    fig.add_trace(
+        go.Heatmap(
+            z=wave1,
+            colorscale=[[0, colors[0]], [1, colors[-1]]],
+            showscale=False
+        ),
+        row=1, col=1
+    )
+    
+    fig.add_trace(
+        go.Heatmap(
+            z=wave2,
+            colorscale=[[0, colors[0]], [1, colors[-1]]],
+            showscale=True
+        ),
+        row=1, col=2
+    )
+    
+    # Update layout
+    fig.update_layout(
+        title_text="Memory Pattern Comparison",
+        height=500,
+        template="plotly_white"
+    )
     
-    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 fig
+
+def create_artistic_visualization(prompt: str, seed: int) -> Optional[Image.Image]:
+    """Create artistic visualization using Stable Diffusion"""
+    if not STABLE_DIFFUSION_AVAILABLE or pipe is None:
+        return None
     
-    # Generate artistic visualization if requested
-    if generate_art and STABLE_DIFFUSION_AVAILABLE and pipe is not None:
-        prompt = generate_memory_prompt(operation, emotion_valence)
+    try:
         generator = torch.Generator().manual_seed(seed)
-        art_viz = pipe(
+        image = pipe(
             prompt=prompt,
             negative_prompt="text, watermark, signature, blurry, distorted",
             guidance_scale=1.5,
@@ -133,91 +437,95 @@ def quantum_memory_ops(
             generator=generator,
         ).images[0]
         
-        results.append(f"\nArtistic Visualization:")
-        results.append(f"Prompt: {prompt}")
-        results.append(f"Seed: {seed}")
-    elif generate_art:
-        results.append(f"\nArtistic Visualization:")
-        results.append(f"Not available - Stable Diffusion could not be initialized")
-    
-    return "\n".join(results), wave_viz, art_viz
+        return image
+    except Exception as e:
+        print(f"Error generating artistic visualization: {e}")
+        return None
 
-# 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 memory ocean 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)"
-            )
-            
-            with gr.Accordion("Advanced Settings", open=False):
-                generate_art = gr.Checkbox(
-                    label="Generate Artistic Visualization", 
-                    value=True,
-                    info="Use Stable Diffusion to create artistic representations"
-                )
-                seed = gr.Slider(
-                    label="Art Generation Seed",
-                    minimum=0,
-                    maximum=MAX_SEED,
-                    step=1,
-                    value=42
-                )
-            
-            run_btn = gr.Button("Generate Memory Wave", variant="primary")
-        
-        with gr.Column():
-            output_text = gr.Textbox(label="Wave Analysis", lines=8)
-            with gr.Row():
-                wave_plot = gr.Plot(label="Wave Pattern")
-                art_output = gr.Image(label="Artistic Visualization")
-            
-    run_btn.click(
-        quantum_memory_ops,
-        inputs=[size_input, operation_input, emotion_input, generate_art, seed],
-        outputs=[output_text, wave_plot, art_output]
-    )
+def create_emotional_wave_animation(size: int, emotion: EmotionalContext) -> Image.Image:
+    """Create an animated-like visualization of emotional waves"""
+    # Create a blank image
+    width, height = size * 10, size * 10
+    image = Image.new('RGBA', (width, height), (255, 255, 255, 0))
+    draw = ImageDraw.Draw(image)
+    
+    # Get color palette
+    colors = emotion.get_color_palette()
+    
+    # Calculate wave parameters based on emotional state
+    valence = emotion.valence.item()
+    arousal = emotion.arousal.item()
     
-    gr.Markdown("""
-    ### 🧠 Understanding Wave Memory
+    # Normalize to 0-1 range
+    valence_norm = (valence + 128) / 255
+    arousal_norm = arousal / 255
     
-    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
+    # Create multiple wave layers
+    for i in range(5):
+        # Calculate wave parameters
+        amplitude = 50 + i * 20 * arousal_norm
+        frequency = 0.01 + i * 0.005 * (1 + valence_norm)
+        phase = i * math.pi / 5
+        
+        # Select color
+        color = colors[i % len(colors)]
+        
+        # Draw wave
+        points = []
+        for x in range(width):
+            # Calculate y position with multiple sine waves
+            y = height/2 + amplitude * math.sin(frequency * x + phase)
+            y += amplitude/2 * math.sin(frequency * 2 * x + phase)
+            points.append((x, y))
+        
+        # Draw wave with varying thickness
+        for j in range(3):
+            thickness = 5 - j
+            draw.line(points, fill=color, width=thickness)
     
-    The visualization shows both the mathematical wave patterns and artistic interpretations,
-    demonstrating how emotional context affects memory formation and recall.
+    # Apply blur for smoother appearance
+    image = image.filter(ImageFilter.GaussianBlur(radius=3))
     
-    All computations are accelerated using Hugging Face's Zero GPU technology! 
-    """)
+    return image
 
-demo.launch()
+def quantum_memory_ops(
+    input_size: int, 
+    operation: str, 
+    emotion_valence: float,
+    emotion_arousal: float = None,
+    wave_type: str = "sine",
+    hot_tub_temp: float = 37.0,
+    hot_tub_participants: str = "",
+    generate_art: bool = True,
+    seed: int = 42
+) -> Tuple[str, go.Figure, go.Figure, Image.Image]:
+    """Perform quantum-inspired memory operations using Mem|8 concepts."""
+    # Initialize components
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    emotion = EmotionalContext(device)
+    emotion.update(emotion_valence, emotion_arousal)
+    
+    wave_processor = WaveProcessor(device)
+    
+    # Process hot tub participants if provided
+    if hot_tub_participants:
+        participants = [p.strip() for p in hot_tub_participants.split(',')]
+        emotion.activate_hot_tub(hot_tub_temp)
+        for participant in participants:
+            emotion.add_hot_tub_participant(participant)
+    
+    results = []
+    wave_viz = None
+    comparison_viz = None
+    art_viz = None
+    
+    # Add header with emotional context
+    results.append(f"🌊 Mem|8 Wave Memory Analysis 🌊")
+    results.append(f"Operation: {operation}")
+    results.append(f"Wave Type: {wave_type}")
+    results.append(f"Grid Size: {input_size}x{input_size}")
+    results.append("")
+    
+    if operation == "wave_memory":
+        # Create memory wave pattern (M = A·exp(iωt-kx)·D·E)
+        wave = wave_processor.create_wave_pattern(input_size, 2.0, 1.0, wave_type)