class WorkingMemory:
    def __init__(self, capacity=100):
        self.memory_items = []
        self.capacity = capacity
        self.timestamps = {}
    
    def store(self, key, value, duration=60):
        """Store item with expiration time (seconds)"""
        if len(self.memory_items) >= self.capacity:
            # Remove oldest item if at capacity
            oldest_key = min(self.timestamps.keys(), 
                           key=lambda k: self.timestamps[k])
            self.forget(oldest_key)
        
        self.memory_items.append((key, value))
        self.timestamps[key] = time.time() + duration
    
    def retrieve(self, key):
        """Retrieve item if still valid"""
        if key in self.timestamps and time.time() < self.timestamps[key]:
            for k, v in self.memory_items:
                if k == key:
                    return v
        return None
    
    def forget(self, key):
        """Explicitly remove an item"""
        self.memory_items = [(k, v) for k, v in self.memory_items if k != key]
        if key in self.timestamps:
            del self.timestamps[key]

class EpisodicMemory:
    def __init__(self):
        self.episodes = []
        self.index = defaultdict(list)
    
    def record_episode(self, episode_data):
        """Record a complete episode of experience"""
        episode = {
            'timestamp': datetime.now(),
            'context': episode_data.get('context', {}),
            'actions': episode_data.get('actions', []),
            'outcomes': episode_data.get('outcomes', []),
            'rewards': episode_data.get('rewards', []),
            'tags': episode_data.get('tags', [])
        }
        
        self.episodes.append(episode)
        
        # Index by tags for efficient retrieval
        for tag in episode['tags']:
            self.index[tag].append(len(self.episodes) - 1)
    
    def retrieve_by_similarity(self, query_context, k=5):
        """Find similar past episodes using cosine similarity"""
        similarities = []
        query_vector = self._context_to_vector(query_context)
        
        for i, episode in enumerate(self.episodes):
            episode_vector = self._context_to_vector(episode['context'])
            similarity = cosine_similarity(query_vector, episode_vector)
            similarities.append((similarity, i))
        
        # Return top-k most similar episodes
        similarities.sort(reverse=True)
        return [self.episodes[i] for _, i in similarities[:k]]
    
    def _context_to_vector(self, context):
        """Convert context dictionary to numerical vector"""
        # Simple bag-of-words implementation
        vector = []
        for key, value in sorted(context.items()):
            if isinstance(value, str):
                # Hash string values to numerical representations
                vector.append(hash(value) % 1000000)
            elif isinstance(value, (int, float)):
                vector.append(value)
            else:
                vector.append(0)
        return np.array(vector)

class SemanticMemory:
    def __init__(self):
        self.knowledge_graph = nx.DiGraph()
        self.embeddings = {}
    
    def add_concept(self, concept, attributes=None, relations=None):
        """Add a concept to semantic memory"""
        self.knowledge_graph.add_node(concept, attributes=attributes or {})
        
        if relations:
            for relation, target in relations.items():
                self.knowledge_graph.add_edge(concept, target, 
                                            relation=relation)
    
    def add_fact(self, subject, predicate, object):
        """Add a factual relationship"""
        self.knowledge_graph.add_edge(subject, object, relation=predicate)
    
    def query(self, query_pattern):
        """Query semantic memory for matching concepts or relationships"""
        # Simple pattern matching implementation
        matches = []
        for node in self.knowledge_graph.nodes():
            if self._matches_pattern(node, query_pattern):
                matches.append(node)
        return matches
    
    def get_related_concepts(self, concept, max_depth=2):
        """Get concepts related to a given concept within max_depth"""
        related = set()
        frontier = {concept}
        
        for depth in range(max_depth):
            next_frontier = set()
            for node in frontier:
                # Get neighbors in knowledge graph
                neighbors = list(self.knowledge_graph.neighbors(node))
                neighbors.extend(list(self.knowledge_graph.predecessors(node)))
                next_frontier.update(neighbors)
            
            related.update(next_frontier)
            frontier = next_frontier
        
        related.discard(concept)  # Remove the original concept
        return list(related)
    
    def _matches_pattern(self, node, pattern):
        """Check if node matches query pattern"""
        if isinstance(pattern, str):
            return pattern.lower() in node.lower()
        return False

class ProceduralMemory:
    def __init__(self):
        self.skills = {}
        self.habit_sequences = {}
        self.performance_metrics = {}
    
    def store_skill(self, skill_name, procedure, performance_data=None):
        """Store a learned skill or procedure"""
        self.skills[skill_name] = {
            'procedure': procedure,
            'created_at': datetime.now(),
            'performance_data': performance_data or {},
            'execution_count': 0
        }
    
    def store_habit_sequence(self, habit_name, sequence, frequency_stats=None):
        """Store a habitual sequence of actions"""
        self.habit_sequences[habit_name] = {
            'sequence': sequence,
            'frequency_stats': frequency_stats or {},
            'last_executed': None
        }
    
    def execute_skill(self, skill_name, context=None):
        """Execute a stored skill, tracking performance"""
        if skill_name not in self.skills:
            raise ValueError(f"Skill {skill_name} not found")
        
        skill = self.skills[skill_name]
        skill['execution_count'] += 1
        skill['last_executed'] = datetime.now()
        
        # Execute procedure with context
        return skill['procedure'](context) if context else skill['procedure']()
    
    def get_optimized_procedure(self, task_description):
        """Retrieve the most suitable procedure for a task"""
        # Find skills with similar descriptions or tags
        best_match = None
        best_score = 0
        
        for skill_name, skill_data in self.skills.items():
            score = self._similarity_score(task_description, skill_name)
            if score > best_score:
                best_score = score
                best_match = skill_name
        
        return self.skills.get(best_match)
    
    def _similarity_score(self, text1, text2):
        """Calculate similarity between two texts"""
        # Simple word overlap implementation
        words1 = set(text1.lower().split())
        words2 = set(text2.lower().split())
        intersection = words1.intersection(words2)
        union = words1.union(words2)
        return len(intersection) / len(union) if union else 0

class HierarchicalMemorySystem:
    def __init__(self):
        self.sensory_memory = SensoryMemory(duration=1.0)  # ~1 second
        self.working_memory = WorkingMemory(capacity=100)
        self.episodic_memory = EpisodicMemory()
        self.semantic_memory = SemanticMemory()
        self.procedural_memory = ProceduralMemory()
    
    def process_experience(self, experience):
        """Process incoming experience through memory hierarchy"""
        # 1. Brief sensory registration
        self.sensory_memory.register(experience['sensory_data'])
        
        # 2. Working memory processing
        if self._is_attention_worthy(experience):
            wm_key = f"experience_{hash(str(experience))}"
            self.working_memory.store(wm_key, experience, duration=300)  # 5 minutes
            
            # 3. Potential consolidation to long-term memory
            consolidation_score = self._compute_consolidation_score(experience)
            if consolidation_score > 0.7:  # Threshold for consolidation
                self.episodic_memory.record_episode({
                    'context': experience.get('context', {}),
                    'actions': experience.get('actions', []),
                    'outcomes': experience.get('outcomes', []),
                    'rewards': experience.get('rewards', []),
                    'tags': self._extract_tags(experience)
                })
    
    def retrieve_relevant_memories(self, query_context, time_constraint=None):
        """Retrieve relevant memories for current context"""
        # Query working memory first (most immediate relevance)
        wm_results = self._query_working_memory(query_context)
        
        # Query episodic memory for similar past experiences
        em_results = self.episodic_memory.retrieve_by_similarity(
            query_context, k=3)
        
        # Query semantic memory for conceptual knowledge
        sm_results = self.semantic_memory.query(query_context.get('topic', ''))
        
        # Combine and rank results
        combined_results = {
            'working_memory': wm_results,
            'episodic_memory': em_results,
            'semantic_memory': sm_results
        }
        
        return self._rank_and_filter_memories(combined_results, time_constraint)
    
    def _is_attention_worthy(self, experience):
        """Determine if experience merits attention and potential storage"""
        # Factors influencing attention worthiness
        novelty_score = self._compute_novelty(experience)
        emotional_intensity = experience.get('emotion_intensity', 0)
        outcome_significance = abs(experience.get('reward', 0))
        
        # Combined attention score
        attention_score = (
            0.4 * novelty_score + 
            0.3 * emotional_intensity + 
            0.3 * outcome_significance
        )
        
        return attention_score > 0.6  # Attention threshold
    
    def _compute_novelty(self, experience):
        """Compute how novel an experience is relative to existing memories"""
        # Compare with recent episodic memories
        recent_episodes = self._get_recent_episodes(hours=24)
        if not recent_episodes:
            return 1.0  # Completely novel if no prior experiences
        
        similarities = [
            self._compute_experience_similarity(experience, ep)
            for ep in recent_episodes
        ]
        
        # Novelty = 1 - maximum similarity to any recent experience
        return 1.0 - max(similarities) if similarities else 1.0

class AttentionGatedMemory(nn.Module):
    def __init__(self, memory_size, key_dim, value_dim):
        super().__init__()
        self.memory_keys = nn.Parameter(torch.randn(memory_size, key_dim))
        self.memory_values = nn.Parameter(torch.randn(memory_size, value_dim))
        self.attention_mechanism = ScaledDotProductAttention(key_dim)
    
    def forward(self, query, write_key=None, write_value=None):
        # Read from memory using attention
        attention_weights = self.attention_mechanism(
            query.unsqueeze(1),  # Add sequence dimension
            self.memory_keys,
            self.memory_values
        )
        
        # If provided with write key/value, update memory
        if write_key is not None and write_value is not None:
            self._write_to_memory(write_key, write_value, attention_weights)
        
        return attention_weights.squeeze(1)  # Remove sequence dimension
    
    def _write_to_memory(self, key, value, attention_weights):
        # Soft write to memory locations based on attention
        write_strength = 0.1  # Learning rate for memory updates
        
        # Update memory keys and values weighted by attention
        weighted_key_update = torch.outer(attention_weights, key)
        weighted_value_update = torch.outer(attention_weights, value)
        
        self.memory_keys.data = (
            self.memory_keys.data * (1 - write_strength) + 
            weighted_key_update * write_strength
        )
        self.memory_values.data = (
            self.memory_values.data * (1 - write_strength) + 
            weighted_value_update * write_strength
        )

class MemoryConsolidator:
    def __init__(self, working_memory, episodic_memory, semantic_memory):
        self.working_memory = working_memory
        self.episodic_memory = episodic_memory
        self.semantic_memory = semantic_memory
        self.consolidation_queue = deque()
    
    def queue_for_consolidation(self, memory_item, priority=1.0):
        """Queue working memory items for potential consolidation"""
        self.consolidation_queue.append({
            'item': memory_item,
            'priority': priority,
            'timestamp': time.time()
        })
    
    def run_consolidation_cycle(self):
        """Run periodic consolidation of working memories"""
        # Sort by priority and recency
        self.consolidation_queue = deque(
            sorted(self.consolidation_queue, 
                   key=lambda x: (x['priority'], x['timestamp']), 
                   reverse=True)
        )
        
        # Process high-priority items
        while self.consolidation_queue and len(self.consolidation_queue) > 50:
            item_data = self.consolidation_queue.popleft()
            if item_data['priority'] > 0.7:
                self._consolidate_item(item_data['item'])
    
    def _consolidate_item(self, item):
        """Consolidate a working memory item to long-term storage"""
        # Determine type of consolidation
        if self._is_episodic(item):
            self._consolidate_to_episodic(item)
        elif self._is_semantic(item):
            self._consolidate_to_semantic(item)
        elif self._is_procedural(item):
            self._consolidate_to_procedural(item)
    
    def _is_episodic(self, item):
        """Determine if item should be stored as episodic memory"""
        return 'timestamp' in item and 'context' in item
    
    def _is_semantic(self, item):
        """Determine if item should be stored as semantic memory"""
        return 'concept' in item or 'fact' in item
    
    def _is_procedural(self, item):
        """Determine if item should be stored as procedural memory"""
        return 'procedure' in item or 'skill' in item
    
    def _consolidate_to_episodic(self, item):
        """Store item in episodic memory"""
        self.episodic_memory.record_episode({
            'context': item.get('context', {}),
            'actions': item.get('actions', []),
            'outcomes': item.get('outcomes', []),
            'rewards': item.get('rewards', []),
            'tags': item.get('tags', [])
        })
    
    def _consolidate_to_semantic(self, item):
        """Extract and store semantic knowledge"""
        if 'concept' in item:
            self.semantic_memory.add_concept(
                item['concept'],
                attributes=item.get('attributes'),
                relations=item.get('relations')
            )
        elif 'fact' in item:
            subject, predicate, obj = item['fact']
            self.semantic_memory.add_fact(subject, predicate, obj)
    
    def _consolidate_to_procedural(self, item):
        """Store procedural knowledge"""
        if 'skill' in item:
            self.procedural_memory.store_skill(
                item['skill']['name'],
                item['skill']['procedure'],
                item.get('performance_data')
            )

class NeuralTuringMachine(nn.Module):
    def __init__(self, input_size, output_size, memory_size, memory_dim):
        super().__init__()
        self.controller = nn.LSTM(input_size + memory_dim, 128)
        self.memory = ExternalMemory(memory_size, memory_dim)
        
        # Heads for reading and writing
        self.read_head = ReadHead(128, memory_dim)
        self.write_head = WriteHead(128, memory_dim)
        
        # Output projection
        self.output_projection = nn.Linear(128 + memory_dim, output_size)
    
    def forward(self, inputs, prev_states=None):
        # Get previous read vectors for controller input
        prev_reads = self.memory.prev_read_vectors if hasattr(self.memory, 'prev_read_vectors') else torch.zeros(inputs.size(0), self.memory.memory_dim)
        
        # Controller processes input concatenated with previous reads
        controller_input = torch.cat([inputs, prev_reads], dim=-1)
        controller_output, states = self.controller(controller_input.unsqueeze(0), prev_states)
        controller_output = controller_output.squeeze(0)
        
        # Read from memory
        read_vectors = self.read_head(controller_output, self.memory)
        
        # Write to memory
        self.write_head(controller_output, self.memory)
        
        # Generate output
        output_input = torch.cat([controller_output, read_vectors], dim=-1)
        output = self.output_projection(output_input)
        
        # Store read vectors for next timestep
        self.memory.prev_read_vectors = read_vectors
        
        return output, states

class ExternalMemory:
    def __init__(self, memory_size, memory_dim):
        self.memory_size = memory_size
        self.memory_dim = memory_dim
        self.memory_matrix = nn.Parameter(torch.randn(memory_size, memory_dim) * 0.01)
        self.usage_vector = torch.zeros(memory_size)
    
    def read(self, weights):
        """Read from memory using addressing weights"""
        return torch.matmul(weights, self.memory_matrix)
    
    def write(self, weights, erase_vector, add_vector):
        """Write to memory using addressing weights"""
        # Erase step
        erase_matrix = torch.outer(weights, erase_vector)
        self.memory_matrix = self.memory_matrix * (1 - erase_matrix)
        
        # Add step
        add_matrix = torch.outer(weights, add_vector)
        self.memory_matrix = self.memory_matrix + add_matrix

class ReadHead(nn.Module):
    def __init__(self, controller_output_dim, memory_dim):
        super().__init__()
        self.addressing = nn.Linear(controller_output_dim, memory_dim)
    
    def forward(self, controller_output, memory):
        """Generate read weights and read from memory"""
        key = self.addressing(controller_output)
        weights = self._content_based_addressing(key, memory.memory_matrix)
        return memory.read(weights)
    
    def _content_based_addressing(self, key, memory_matrix):
        """Compute content-based addressing weights"""
        # Cosine similarity between key and memory locations
        key_norm = torch.norm(key)
        memory_norms = torch.norm(memory_matrix, dim=1)
        
        similarities = torch.matmul(memory_matrix, key) / (
            memory_norms * key_norm + 1e-8)  # Avoid division by zero
        
        return F.softmax(similarities, dim=0)

class WriteHead(nn.Module):
    def __init__(self, controller_output_dim, memory_dim):
        super().__init__()
        self.key_addressing = nn.Linear(controller_output_dim, memory_dim)
        self.erase_vector = nn.Linear(controller_output_dim, memory_dim)
        self.add_vector = nn.Linear(controller_output_dim, memory_dim)
        self.write_strength = nn.Linear(controller_output_dim, 1)
    
    def forward(self, controller_output, memory):
        """Generate write operations"""
        key = self.key_addressing(controller_output)
        write_weights = self._content_based_addressing(key, memory.memory_matrix)
        
        erase_vec = torch.sigmoid(self.erase_vector(controller_output))
        add_vec = self.add_vector(controller_output)
        strength = F.softplus(self.write_strength(controller_output))
        
        # Apply write weights scaled by strength
        normalized_weights = F.softmax(write_weights * strength, dim=0)
        
        memory.write(normalized_weights, erase_vec, add_vec)
    
    def _content_based_addressing(self, key, memory_matrix):
        """Compute content-based addressing weights"""
        key_norm = torch.norm(key)
        memory_norms = torch.norm(memory_matrix, dim=1)
        
        similarities = torch.matmul(memory_matrix, key) / (
            memory_norms * key_norm + 1e-8)
        
        return similarities

class Differentiable Neural Computer(nn.Module):
    def __init__(self, input_size, output_size, controller_size, memory_size, memory_dim):
        super().__init__()
        self.controller = nn.LSTM(input_size + memory_dim, controller_size)
        self.memory = DynamicMemory(memory_size, memory_dim)
        
        # Interface vectors for memory operations
        self.interface_size = 3 * memory_dim + 5 * memory_size + 3
        self.interface_layer = nn.Linear(controller_size, self.interface_size)
        
        # Read heads
        self.num_read_heads = 4
        self.read_vectors = torch.zeros(self.num_read_heads, memory_dim)
        
        # Output projection
        self.output_layer = nn.Linear(controller_size + self.num_read_heads * memory_dim, output_size)
    
    def forward(self, inputs, prev_states=None):
        # Prepare controller input
        interface_input = torch.cat([inputs, self.read_vectors.flatten()], dim=-1)
        
        # Controller processes input
        controller_output, states = self.controller(interface_input.unsqueeze(0), prev_states)
        controller_output = controller_output.squeeze(0)
        
        # Generate interface vectors
        interface = self.interface_layer(controller_output)
        self._parse_interface(interface)
        
        # Memory operations
        self._update_memory()
        
        # Read from memory
        self.read_vectors = self._read_from_memory()
        
        # Generate output
        output_input = torch.cat([controller_output, self.read_vectors.flatten()], dim=-1)
        output = self.output_layer(output_input)
        
        return output, states
    
    def _parse_interface(self, interface):
        """Parse interface vector into memory operation parameters"""
        idx = 0
        
        # Read keys and strengths
        self.read_keys = interface[idx:idx + self.num_read_heads * self.memory.memory_dim].view(
            self.num_read_heads, self.memory.memory_dim)
        idx += self.num_read_heads * self.memory.memory_dim
        
        self.read_strengths = F.softplus(interface[idx:idx + self.num_read_heads])
        idx += self.num_read_heads
        
        # Write key and strength
        self.write_key = interface[idx:idx + self.memory.memory_dim]
        idx += self.memory.memory_dim
        
        self.write_strength = F.softplus(interface[idx:idx + 1])
        idx += 1
        
        # Erase and add vectors
        self.erase_vector = torch.sigmoid(interface[idx:idx + self.memory.memory_dim])
        idx += self.memory.memory_dim
        
        self.add_vector = interface[idx:idx + self.memory.memory_dim]
        idx += self.memory.memory_dim
        
        # Free gates, allocation gate, and write gate
        self.free_gates = torch.sigmoid(interface[idx:idx + self.num_read_heads])
        idx += self.num_read_heads
        
        self.allocation_gate = torch.sigmoid(interface[idx:idx + 1])
        idx += 1
        
        self.write_gate = torch.sigmoid(interface[idx:idx + 1])
        idx += 1
        
        # Link matrix for temporal linkage
        link_indices = interface[idx:idx + 2 * self.memory.memory_size].view(2, self.memory.memory_size)
        self.link_matrix = F.softmax(link_indices, dim=0)
    
    def _update_memory(self):
        """Perform memory write operations"""
        # Update usage vector based on free gates
        retention_vector = torch.prod(1 - self.free_gates.unsqueeze(1) * self.read_weights, dim=0)
        self.memory.usage_vector = self.memory.usage_vector * retention_vector
        
        # Allocate memory location
        allocation_weight = self._allocate_memory()
        
        # Compute write weights
        write_content_weight = self._content_based_addressing(
            self.write_key, self.write_strength, self.memory.memory_matrix)
        
        self.write_weights = self.write_gate * (
            self.allocation_gate * allocation_weight + 
            (1 - self.allocation_gate) * write_content_weight)
        
        # Write to memory
        self.memory.write(self.write_weights, self.erase_vector, self.add_vector)
        
        # Update temporal linkage
        self._update_linkage()
    
    def _read_from_memory(self):
        """Perform memory read operations"""
        read_vectors = []
        self.read_weights = []
        
        for i in range(self.num_read_heads):
            # Content-based addressing
            content_weight = self._content_based_addressing(
                self.read_keys[i], self.read_strengths[i], self.memory.memory_matrix)
            
            # Temporal linkage based read
            forward_weight = torch.matmul(self.link_matrix, self.previous_write_weights)
            backward_weight = torch.matmul(self.link_matrix.t(), self.previous_write_weights)
            
            # Combine addressing mechanisms
            read_weight = content_weight  # Simplified for clarity
            self.read_weights.append(read_weight)
            
            # Read vector
            read_vector = torch.matmul(read_weight, self.memory.memory_matrix)
            read_vectors.append(read_vector)
        
        self.read_weights = torch.stack(self.read_weights)
        self.previous_write_weights = self.write_weights
        
        return torch.stack(read_vectors)
    
    def _allocate_memory(self):
        """Allocate a new memory location"""
        # Find least used memory location
        sorted_usage, indices = torch.sort(self.memory.usage_vector)
        free_list = indices[sorted_usage < 0.1]  # Locations with low usage
        
        if len(free_list) > 0:
            # Allocate first free location
            allocation = torch.zeros(self.memory.memory_size)
            allocation[free_list[0]] = 1.0
            return allocation
        else:
            # No free locations, return zero allocation
            return torch.zeros(self.memory.memory_size)
    
    def _content_based_addressing(self, key, strength, memory_matrix):
        """Content-based addressing mechanism"""
        key_norm = torch.norm(key)
        memory_norms = torch.norm(memory_matrix, dim=1)
        
        similarities = torch.matmul(memory_matrix, key) / (
            memory_norms * key_norm + 1e-8)
        
        return F.softmax(similarities * strength, dim=0)
    
    def _update_linkage(self):
        """Update temporal linkage between consecutive writes"""
        # Simplified linkage update
        pass

class ConversationMemoryManager:
    def __init__(self):
        self.short_term = WorkingMemory(capacity=50)
        self.user_profiles = {}
        self.conversation_histories = EpisodicMemory()
        self.domain_knowledge = SemanticMemory()
    
    def initialize_user_profile(self, user_id, initial_preferences=None):
        """Create a profile for a new user"""
        self.user_profiles[user_id] = {
            'preferences': initial_preferences or {},
            'interaction_history': [],
            'personality_model': {},
            'topic_interests': defaultdict(float)
        }
    
    def update_user_profile(self, user_id, interaction_data):
        """Update user profile based on new interaction"""
        if user_id not in self.user_profiles:
            self.initialize_user_profile(user_id)
        
        profile = self.user_profiles[user_id]
        
        # Update preferences based on expressed likes/dislikes
        if 'feedback' in interaction_data:
            feedback = interaction_data['feedback']
            for pref, value in feedback.get('preferences', {}).items():
                profile['preferences'][pref] = value
        
        # Update topic interests
        if 'topics' in interaction_data:
            for topic in interaction_data['topics']:
                profile['topic_interests'][topic] += 1.0
        
        # Store interaction for future reference
        profile['interaction_history'].append({
            'timestamp': datetime.now(),
            'interaction': interaction_data
        })
    
    def personalize_response(self, user_id, context):
        """Generate personalized response using memory systems"""
        if user_id not in self.user_profiles:
            return None  # No profile to personalize with
        
        profile = self.user_profiles[user_id]
        
        # Retrieve relevant memories for context
        relevant_memories = self._get_relevant_memories(user_id, context)
        
        # Adjust response based on user preferences and history
        personalization_adjustments = {
            'tone_preference': profile['preferences'].get('tone', 'neutral'),
            'formality_level': profile['preferences'].get('formality', 'casual'),
            'past_topics': [mem.get('topic') for mem in relevant_memories 
                          if mem.get('topic')],
            'successful_patterns': self._get_successful_patterns(user_id)
        }
        
        return personalization_adjustments
    
    def _get_relevant_memories(self, user_id, context):
        """Retrieve memories relevant to current context"""
        # Query episodic memory for similar past conversations
        similar_conversations = self.conversation_histories.retrieve_by_similarity(
            {'user_id': user_id, 'topic': context.get('topic', '')}, k=5)
        
        # Query semantic memory for domain knowledge
        domain_knowledge = self.domain_knowledge.query(context.get('topic', ''))
        
        return {
            'conversations': similar_conversations,
            'domain_knowledge': domain_knowledge
        }
    
    def _get_successful_patterns(self, user_id):
        """Identify interaction patterns that led to positive outcomes"""
        profile = self.user_profiles[user_id]
        successful_interactions = [
            interaction for interaction in profile['interaction_history']
            if interaction.get('outcome', {}).get('success', False)
        ]
        
        # Extract patterns from successful interactions
        patterns = []
        for interaction in successful_interactions[-10:]:  # Last 10 successes
            patterns.extend(interaction.get('patterns', []))
        
        return list(set(patterns))  # Unique patterns

class ExperienceAccumulatingAgent:
    def __init__(self):
        self.memory_system = HierarchicalMemorySystem()
        self.skill_library = ProceduralMemory()
        self.exploration_strategy = ExplorationStrategy()
        self.performance_tracker = PerformanceTracker()
    
    def process_interaction(self, observation, action, reward, next_observation):
        """Process a single interaction and update memory"""
        experience = {
            'observation': observation,
            'action': action,
            'reward': reward,
            'next_observation': next_observation,
            'timestamp': time.time()
        }
        
        # Store in memory hierarchy
        self.memory_system.process_experience(experience)
        
        # Track performance metrics
        self.performance_tracker.record_outcome(reward, action.type)
        
        # Potentially extract and store new skills
        if self._should_extract_skill(experience):
            self._extract_and_store_skill(experience)
    
    def _should_extract_skill(self, experience):
        """Determine if experience contains a skill worth extracting"""
        # Criteria for skill extraction:
        # 1. High reward outcome
        # 2. Non-random action sequence
        # 3. Replicable pattern
        
        reward_threshold = 0.8
        return (experience['reward'] > reward_threshold and 
                self._is_action_sequence_meaningful(experience))
    
    def _extract_and_store_skill(self, experience):
        """Extract skill from successful experience"""
        skill_name = f"skill_{len(self.skill_library.skills) + 1}"
        
        # Define skill procedure based on experience
        def skill_procedure(context=None):
            # Simplified: return the action that led to success
            return experience['action']
        
        # Store with performance data
        self.skill_library.store_skill(
            skill_name,
            skill_procedure,
            performance_data={
                'success_rate': 1.0,
                'average_reward': experience['reward'],
                'contexts': [experience.get('context', {})]
            }
        )
    
    def select_action(self, current_state):
        """Select action using accumulated memories and skills"""
        # Retrieve relevant memories
        relevant_memories = self.memory_system.retrieve_relevant_memories(
            {'state': current_state})
        
        # Check for applicable skills
        applicable_skills = self._find_applicable_skills(current_state)
        
        # Balance exploration and exploitation
        if applicable_skills and random.random() > self.exploration_strategy.epsilon:
            # Exploit learned skills
            selected_skill = random.choice(applicable_skills)
            return self.skill_library.execute_skill(selected_skill.name)
        else:
            # Explore or fall back to basic policy
            return self._exploratory_action(current_state, relevant_memories)
    
    def _find_applicable_skills(self, current_state):
        """Find skills that might be applicable to current state"""
        applicable = []
        for skill_name, skill_data in self.skill_library.skills.items():
            # Check if skill context matches current state reasonably well
            context_match = self._compute_context_similarity(
                skill_data.get('contexts', [{}])[0], 
                {'state': current_state}
            )
            if context_match > 0.7:  # Threshold for applicability
                applicable.append(type('SkillReference', (), {
                    'name': skill_name,
                    'match_score': context_match
                })())
        
        # Sort by match score
        return sorted(applicable, key=lambda s: s.match_score, reverse=True)

class MemoryEvaluationSuite:
    def __init__(self):
        self.metrics = {}
    
    def evaluate_memory_retention(self, memory_system, test_sequences):
        """Evaluate how well memory system retains information"""
        retention_scores = []
        
        for sequence in test_sequences:
            # Present sequence to agent
            for item in sequence:
                memory_system.process_experience(item)
            
            # Test recall after delay
            time.sleep(10)  # Simulate time delay
            
            # Measure recall accuracy
            recall_accuracy = self._measure_recall_accuracy(
                memory_system, sequence)
            retention_scores.append(recall_accuracy)
        
        return np.mean(retention_scores)
    
    def evaluate_memory_utilization(self, memory_system, interaction_log):
        """Evaluate how effectively memory is utilized in decision making"""
        utilization_scores = []
        
        for interaction in interaction_log:
            # Check if relevant memories were retrieved for decision
            relevant_memories = memory_system.retrieve_relevant_memories(
                interaction['context'])
            
            # Measure impact of memory on decision quality
            decision_quality = self._assess_decision_quality(
                interaction, relevant_memories)
            utilization_scores.append(decision_quality)
        
        return np.mean(utilization_scores)
    
    def evaluate_memory_growth_efficiency(self, memory_system, learning_curve):
        """Evaluate how memory grows and adapts during learning"""
        # Analyze memory size vs. performance relationship
        memory_sizes = []
        performance_scores = []
        
        for checkpoint in learning_curve:
            memory_size = self._count_stored_memories(memory_system)
            performance = checkpoint['performance']
            
            memory_sizes.append(memory_size)
            performance_scores.append(performance)
        
        # Calculate memory efficiency (performance gain per memory unit)
        efficiency_scores = []
        for i in range(1, len(memory_sizes)):
            memory_growth = memory_sizes[i] - memory_sizes[i-1]
            performance_gain = performance_scores[i] - performance_scores[i-1]
            
            if memory_growth > 0:
                efficiency = performance_gain / memory_growth
                efficiency_scores.append(efficiency)
        
        return np.mean(efficiency_scores) if efficiency_scores else 0.0
    
    def _measure_recall_accuracy(self, memory_system, expected_items):
        """Measure accuracy of recalled information"""
        correct_recalls = 0
        total_items = len(expected_items)
        
        for item in expected_items:
            # Attempt to retrieve item from memory
            retrieved = memory_system.retrieve_item(item['key'])
            if retrieved and self._items_equal(retrieved, item):
                correct_recalls += 1
        
        return correct_recalls / total_items if total_items > 0 else 0.0
    
    def _assess_decision_quality(self, interaction, relevant_memories):
        """Assess quality of decision given available memories"""
        # Compare actual decision with optimal decision given memories
        optimal_decision = self._compute_optimal_decision(
            interaction['context'], relevant_memories)
        
        actual_decision = interaction['action']
        
        # Measure similarity/closeness of decisions
        return self._decision_similarity(actual_decision, optimal_decision)
    
    def _count_stored_memories(self, memory_system):
        """Count total number of memories stored"""
        count = 0
        # Count memories in each subsystem
        count += len(memory_system.sensory_memory.items) if hasattr(memory_system.sensory_memory, 'items') else 0
        count += len(memory_system.working_memory.memory_items)
        count += len(memory_system.episodic_memory.episodes)
        count += len(memory_system.semantic_memory.knowledge_graph.nodes())
        count += len(memory_system.procedural_memory.skills)
        return count

class MemoryCompressionManager:
    def __init__(self, compression_ratio=0.5):
        self.compression_ratio = compression_ratio
        self.compression_history = []
    
    def compress_memory_bank(self, memory_items):
        """Compress memory items to reduce storage requirements"""
        # Sort items by importance/recentness
        ranked_items = self._rank_items_by_importance(memory_items)
        
        # Keep only top percentage
        keep_count = int(len(ranked_items) * self.compression_ratio)
        compressed_items = ranked_items[:keep_count]
        
        # Log compression statistics
        self.compression_history.append({
            'original_count': len(memory_items),
            'compressed_count': len(compressed_items),
            'compression_ratio': len(compressed_items) / len(memory_items)
        })
        
        return compressed_items
    
    def _rank_items_by_importance(self, items):
        """Rank memory items by their importance/preservation value"""
        scored_items = []
        for item in items:
            score = self._compute_preservation_score(item)
            scored_items.append((score, item))
        
        # Sort by descending score
        scored_items.sort(reverse=True)
        return [item for score, item in scored_items]
    
    def _compute_preservation_score(self, item):
        """Compute score indicating how valuable item is to preserve"""
        # Factors influencing preservation value:
        recency = item.get('timestamp', 0)
        frequency = item.get('access_count', 1)
        reward_signal = item.get('reward_association', 0)
        uniqueness = item.get('novelty_score', 0.5)
        
        # Weighted combination of factors
        score = (
            0.3 * (recency / (time.time() + 1e-8)) +  # Normalize recency
            0.2 * np.log(frequency + 1) +              # Log frequency
            0.3 * reward_signal +                      # Direct reward association
            0.2 * uniqueness                           # Information uniqueness
        )
        
        return score

class DistributedMemorySystem:
    def __init__(self, nodes):
        self.nodes = nodes
        self.partition_strategy = ConsistentHashingPartitioner(nodes)
    
    def store_memory_item(self, key, value):
        """Store memory item on appropriate node"""
        target_node = self.partition_strategy.get_node(key)
        return target_node.store(key, value)
    
    def retrieve_memory_item(self, key):
        """Retrieve memory item from appropriate node"""
        target_node = self.partition_strategy.get_node(key)
        return target_node.retrieve(key)
    
    def replicate_critical_memories(self, replication_factor=3):
        """Replicate important memories across multiple nodes"""
        critical_items = self._identify_critical_memories()
        
        for item in critical_items:
            nodes = self.partition_strategy.get_nodes_for_replication(
                item.key, replication_factor)
            
            for node in nodes:
                node.store(item.key, item.value)
    
    def _identify_critical_memories(self):
        """Identify which memories are critical for system operation"""
        # Criteria for critical memories:
        # 1. Recently accessed
        # 2. High reward associations
        # 3. Frequently referenced
        # 4. System-critical information
        
        critical = []
        # Implementation would scan all memory systems to identify critical items
        return critical

class ConsistentHashingPartitioner:
    def __init__(self, nodes):
        self.nodes = sorted(nodes)
        self.ring = {}
        self._build_ring()
    
    def _build_ring(self):
        """Build consistent hash ring"""
        for node in self.nodes:
            for i in range(100):  # Virtual nodes for better distribution
                key = hash(f"{node}:{i}")
                self.ring[key] = node
    
    def get_node(self, key):
        """Get responsible node for a key"""
        if not self.ring:
            return None
        
        hash_key = hash(str(key))
        ring_keys = sorted(self.ring.keys())
        
        # Find first node with hash greater than key hash
        for ring_key in ring_keys:
            if ring_key >= hash_key:
                return self.ring[ring_key]
        
        # Wrap around to first node
        return self.ring[ring_keys[0]]
    
    def get_nodes_for_replication(self, key, count):
        """Get nodes for replicating a key"""
        if not self.ring or count <= 0:
            return []
        
        hash_key = hash(str(key))
        ring_keys = sorted(self.ring.keys())
        
        nodes = []
        start_index = 0
        
        # Find starting position
        for i, ring_key in enumerate(ring_keys):
            if ring_key >= hash_key:
                start_index = i
                break
        
        # Collect unique nodes in circular fashion
        collected_nodes = set()
        for i in range(len(ring_keys)):
            index = (start_index + i) % len(ring_keys)
            node = self.ring[ring_keys[index]]
            if node not in collected_nodes:
                collected_nodes.add(node)
                nodes.append(node)
                if len(nodes) >= count:
                    break
        
        return nodes

class SecureMemorySystem:
    def __init__(self, encryption_key):
        self.encryption_key = encryption_key
        self.memory_store = EncryptedKeyValueStore(encryption_key)
        self.access_log = []
    
    def store_sensitive_information(self, key, value, access_policy=None):
        """Store sensitive information with security measures"""
        # Encrypt data before storage
        encrypted_value = self._encrypt_data(value)
        
        # Store with access controls
        metadata = {
            'stored_at': datetime.now(),
            'access_policy': access_policy or {},
            'encryption_method': 'AES-256'
        }
        
        return self.memory_store.put(key, {
            'data': encrypted_value,
            'metadata': metadata
        })
    
    def retrieve_sensitive_information(self, key, requester_identity):
        """Retrieve sensitive information with access validation"""
        # Log access attempt
        self.access_log.append({
            'key': key,
            'requester': requester_identity,
            'timestamp': datetime.now(),
            'granted': False
        })
        
        # Check access permissions
        stored_item = self.memory_store.get(key)
        if not stored_item:
            return None
        
        access_policy = stored_item['metadata'].get('access_policy', {})
        if self._validate_access(requester_identity, access_policy):
            # Grant access and decrypt
            decrypted_data = self._decrypt_data(stored_item['data'])
            
            # Update access log
            self.access_log[-1]['granted'] = True
            
            return decrypted_data
        else:
            return None  # Access denied
    
    def _encrypt_data(self, data):
        """Encrypt data using AES-256"""
        cipher = AES.new(self.encryption_key, AES.MODE_GCM)
        ciphertext, auth_tag = cipher.encrypt_and_digest(json.dumps(data).encode())
        return {
            'nonce': cipher.nonce,
            'ciphertext': ciphertext,
            'auth_tag': auth_tag
        }
    
    def _decrypt_data(self, encrypted_data):
        """Decrypt data using AES-256"""
        cipher = AES.new(
            self.encryption_key, 
            AES.MODE_GCM, 
            nonce=encrypted_data['nonce']
        )
        plaintext = cipher.decrypt_and_verify(
            encrypted_data['ciphertext'], 
            encrypted_data['auth_tag']
        )
        return json.loads(plaintext.decode())
    
    def _validate_access(self, requester, policy):
        """Validate access based on policy"""
        # Simple role-based access control
        required_role = policy.get('required_role')
        if required_role and requester.role != required_role:
            return False
        
        # Time-based restrictions
        valid_times = policy.get('valid_times', [])
        current_time = datetime.now().time()
        if valid_times and not any(start <= current_time <= end 
                                 for start, end in valid_times):
            return False
        
        return True

class SpikingNeuralMemory:
    def __init__(self, neuron_count, memory_capacity):
        self.neurons = [SpikingNeuron() for _ in range(neuron_count)]
        self.synaptic_weights = torch.randn(neuron_count, neuron_count) * 0.1
        self.spike_history = deque(maxlen=memory_capacity)
    
    def learn_from_spikes(self, spike_train, target_output):
        """Learn memory associations from spike trains"""
        # STDP (Spike-Timing Dependent Plasticity) learning rule
        for t in range(len(spike_train) - 1):
            pre_spike = spike_train[t]
            post_spike = spike_train[t + 1]
            
            if pre_spike and post_spike:
                # Both neurons spiked - strengthen connection
                delta_w = self._stdp_rule(pre_spike.time, post_spike.time)
                self.synaptic_weights[pre_spike.neuron, post_spike.neuron] += delta_w
    
    def recall_memory(self, cue_spike_train):
        """Recall associated memories from partial cues"""
        # Activate network with cue and observe pattern completion
        network_state = self._initialize_network(cue_spike_train)
        recalled_pattern = self._run_pattern_completion(network_state)
        return recalled_pattern
    
    def _stdp_rule(self, pre_time, post_time):
        """Spike-timing dependent plasticity learning rule"""
        dt = post_time - pre_time
        if dt > 0:
            # Pre-synaptic spike followed by post-synaptic spike
            return 0.01 * np.exp(-dt / 20.0)  # LTP
        else:
            # Post-synaptic spike preceded pre-synaptic spike
            return -0.01 * np.exp(dt / 20.0)  # LTD
    
    def _initialize_network(self, cue_train):
        """Initialize network state from cue spike train"""
        state = torch.zeros(len(self.neurons))
        for spike in cue_train:
            state[spike.neuron] = 1.0
        return state
    
    def _run_pattern_completion(self, initial_state, steps=100):
        """Run network dynamics to complete pattern"""
        current_state = initial_state.clone()
        states_history = [current_state]
        
        for _ in range(steps):
            # Compute next state based on synaptic connections
            next_state = torch.sigmoid(
                torch.matmul(self.synaptic_weights, current_state))
            
            # Apply spiking nonlinearity
            spikes = (next_state > 0.5).float()
            
            # Store spike event
            self.spike_history.append(spikes)
            
            current_state = spikes
            states_history.append(current_state)
        
        return states_history[-1], states_history  # Final state and trajectory

class QuantumMemoryRegister:
    def __init__(self, num_qubits):
        self.num_qubits = num_qubits
        self.quantum_state = self._initialize_quantum_state()
        self.classical_metadata = {}
    
    def _initialize_quantum_state(self):
        """Initialize quantum memory register"""
        # Start with all qubits in |0⟩ state
        state = torch.zeros(2**self.num_qubits, dtype=torch.complex64)
        state[0] = 1.0 + 0.0j  # |000...0⟩ state
        return state
    
    def store_superposition_memory(self, classical_data):
        """Store data in quantum superposition states"""
        # Encode classical data into quantum amplitudes
        encoded_state = self._encode_classical_data(classical_data)
        
        # Apply quantum operations to create entanglement/memory associations
        self.quantum_state = self._create_memory_associations(encoded_state)
        
        # Store classical metadata for retrieval
        memory_id = hash(str(classical_data))
        self.classical_metadata[memory_id] = {
            'data': classical_data,
            'quantum_encoding': encoded_state,
            'timestamp': time.time()
        }
        
        return memory_id
    
    def retrieve_memory_in_parallel(self, query_conditions):
        """Exploit quantum parallelism for memory retrieval"""
        # Prepare query in superposition
        query_state = self._prepare_query_superposition(query_conditions)
        
        # Apply quantum search algorithm (Grover-like)
        search_result = self._quantum_search(query_state)
        
        # Measure to collapse to classical result
        retrieved_data = self._measure_quantum_result(search_result)
        
        return retrieved_data
    
    def _encode_classical_data(self, data):
        """Encode classical data into quantum state"""
        # Simple amplitude encoding
        if isinstance(data, (list, tuple)):
            # Normalize data to create valid quantum state
            data_array = np.array(data, dtype=np.float32)
            normalized = data_array / np.linalg.norm(data_array)
            
            # Pad to match quantum state dimension
            padded = np.zeros(2**self.num_qubits, dtype=np.float32)
            padded[:len(normalized)] = normalized
            
            return torch.tensor(padded, dtype=torch.complex64)
        else:
            # Scalar encoding
            state = torch.zeros(2**self.num_qubits, dtype=torch.complex64)
            state[0] = torch.tensor(complex(data), dtype=torch.complex64)
            return state
    
    def _quantum_search(self, query_state):
        """Perform quantum search on memory register"""
        # Simplified Grover-like search
        iterations = int(np.pi/4 * np.sqrt(2**self.num_qubits))
        
        # Oracle marks target states
        oracle_state = self._mark_target_states(query_state)
        
        # Diffusion operator amplifies marked states
        diffusion_op = self._create_diffusion_operator()
        
        # Iterative amplification
        current_state = oracle_state.clone()
        for _ in range(iterations):
            # Apply oracle
            current_state = self._apply_oracle(current_state)
            # Apply diffusion
            current_state = torch.matmul(diffusion_op, current_state)
        
        return current_state
    
    def _measure_quantum_result(self, quantum_state):
        """Measure quantum state to obtain classical result"""
        # Compute probabilities
        probabilities = torch.abs(quantum_state)**2
        probabilities = probabilities / torch.sum(probabilities)  # Normalize
        
        # Sample measurement outcome
        outcome_index = torch.multinomial(probabilities, 1).item()
        
        # Convert basis state back to classical data
        return self._basis_state_to_classical(outcome_index)

class PersonalAssistantAgent:
    def __init__(self, user_id):
        self.user_id = user_id
        self.memory_manager = ConversationMemoryManager()
        self.memory_manager.initialize_user_profile(user_id)
        self.skill_repository = ProceduralMemory()
        self.context_manager = ContextAwarenessEngine()
    
    def handle_user_request(self, user_input):
        """Process user request using accumulated memories and skills"""
        # Parse user input and determine intent
        intent, entities = self._parse_intent(user_input)
        
        # Build context for decision making
        context = self.context_manager.build_context({
            'intent': intent,
            'entities': entities,
            'user_id': self.user_id,
            'timestamp': datetime.now()
        })
        
        # Personalize response based on user profile
        personalization = self.memory_manager.personalize_response(
            self.user_id, context)
        
        # Find applicable skills or knowledge
        applicable_skills = self.skill_repository.query_applicable_skills(
            context, personalization)
        
        # Generate response
        response = self._generate_personalized_response(
            intent, context, personalization, applicable_skills)
        
        # Update memory with interaction
        self.memory_manager.update_user_profile(self.user_id, {
            'input': user_input,
            'response': response,
            'context': context,
            'intent': intent
        })
        
        return response
    
    def _parse_intent(self, user_input):
        """Parse user intent and extract entities"""
        # Simplified intent parsing - in practice would use NLP models
        if 'weather' in user_input.lower():
            return 'weather_query', self._extract_entities(user_input)
        elif 'schedule' in user_input.lower() or 'appointment' in user_input.lower():
            return 'schedule_management', self._extract_entities(user_input)
        elif 'recommend' in user_input.lower():
            return 'recommendation_request', self._extract_entities(user_input)
        else:
            return 'general_query', self._extract_entities(user_input)
    
    def _extract_entities(self, text):
        """Extract named entities from text"""
        # Simplified entity extraction
        entities = {}
        
        # Extract dates, times, locations, etc.
        if 'tomorrow' in text.lower():
            entities['date'] = 'tomorrow'
        if 'today' in text.lower():
            entities['date'] = 'today'
        if 'meeting' in text.lower():
            entities['event_type'] = 'meeting'
        
        return entities
    
    def _generate_personalized_response(self, intent, context, personalization, skills):
        """Generate personalized response using available information"""
        # Apply personalization adjustments
        tone = personalization.get('tone_preference', 'neutral')
        formality = personalization.get('formality_level', 'casual')
        
        # Use applicable skills
        if skills:
            skill_response = skills[0].execute(context)
            return self._format_response(skill_response, tone, formality)
        else:
            # Fallback to template-based responses
            return self._template_response(intent, context, tone, formality)
    
    def _format_response(self, content, tone, formality):
        """Format response according to personalization preferences"""
        # Adjust language style based on preferences
        if formality == 'formal':
            content = self._make_formal(content)
        elif formality == 'casual':
            content = self._make_casual(content)
        
        return content
    
    def _make_formal(self, text):
        """Make text more formal"""
        # Simplified formalization
        formal_mappings = {
            'gonna': 'going to',
            'wanna': 'want to',
            'hey': 'Hello'
        }
        
        for casual, formal in formal_mappings.items():
            text = text.replace(casual, formal)
        
        return text
    
    def _make_casual(self, text):
        """Make text more casual"""
        # Simplified casualization
        casual_mappings = {
            'going to': 'gonna',
            'want to': 'wanna'
        }
        
        for formal, casual in casual_mappings.items():
            text = text.replace(formal, casual)
        
        return text

class AutonomousVehicleMemorySystem:
    def __init__(self):
        self.driving_experience_memory = EpisodicMemory()
        self.traffic_pattern_memory = SemanticMemory()
        self.emergency_procedures = ProceduralMemory()
        self.environmental_context = WorkingMemory()
        self.safety_constraints = {}
    
    def record_driving_experience(self, driving_episode):
        """Record complete driving experience for future reference"""
        # Extract key elements from driving episode
        experience_data = {
            'route': driving_episode.get('route', {}),
            'weather_conditions': driving_episode.get('weather', {}),
            'traffic_density': driving_episode.get('traffic_density', 'normal'),
            'road_conditions': driving_episode.get('road_conditions', 'dry'),
            'maneuvers_performed': driving_episode.get('maneuvers', []),
            'safety_events': driving_episode.get('safety_events', []),
            'navigation_decisions': driving_episode.get('decisions', []),
            'performance_metrics': driving_episode.get('metrics', {})
        }
        
        # Store with rich metadata
        self.driving_experience_memory.record_episode({
            'context': experience_data,
            'actions': experience_data['maneuvers_performed'],
            'outcomes': {
                'safety_incidents': len(experience_data['safety_events']),
                'efficiency_score': experience_data['performance_metrics'].get('efficiency', 0),
                'comfort_score': experience_data['performance_metrics'].get('comfort', 0)
            },
            'tags': self._extract_experience_tags(experience_data)
        })
    
    def learn_traffic_patterns(self, location_data, time_series_data):
        """Learn recurring traffic patterns and behaviors"""
        # Analyze time series for patterns
        daily_patterns = self._detect_daily_patterns(time_series_data)
        weekly_patterns = self._detect_weekly_patterns(time_series_data)
        
        # Store detected patterns in semantic memory
        location_id = location_data['location_id']
        
        self.traffic_pattern_memory.add_concept(
            f"daily_pattern_{location_id}",
            attributes=daily_patterns,
            relations={'associated_with': location_id}
        )
        
        self.traffic_pattern_memory.add_concept(
            f"weekly_pattern_{location_id}",
            attributes=weekly_patterns,
            relations={'associated_with': location_id}
        )
    
    def retrieve_driving_knowledge(self, current_situation):
        """Retrieve relevant driving knowledge for current situation"""
        # Build query context from current situation
        query_context = {
            'location': current_situation.get('location', {}),
            'time_of_day': current_situation.get('time_of_day', ''),
            'weather': current_situation.get('weather', 'clear'),
            'traffic_density': current_situation.get('traffic_density', 'normal'),
            'vehicle_state': current_situation.get('vehicle_state', {})
        }
        
        # Retrieve similar past experiences
        similar_experiences = self.driving_experience_memory.retrieve_by_similarity(
            query_context, k=10)
        
        # Retrieve traffic patterns for location
        location_patterns = self._get_location_patterns(
            current_situation.get('location', {}).get('id', ''))
        
        # Retrieve appropriate emergency procedures
        emergency_procedures = self._get_relevant_emergency_procedures(
            current_situation)
        
        return {
            'similar_experiences': similar_experiences,
            'location_patterns': location_patterns,
            'emergency_procedures': emergency_procedures
        }
    
    def _extract_experience_tags(self, experience_data):
        """Extract descriptive tags from driving experience"""
        tags = []
        
        # Weather-related tags
        if experience_data['weather_conditions']:
            tags.append(f"weather_{experience_data['weather_conditions']}")
        
        # Traffic density tags
        tags.append(f"traffic_{experience_data['traffic_density']}")
        
        # Road condition tags
        if experience_data['road_conditions']:
            tags.append(f"road_{experience_data['road_conditions']}")
        
        # Maneuver tags
        for maneuver in experience_data['maneuvers_performed']:
            tags.append(f"maneuver_{maneuver}")
        
        # Safety event tags
        if experience_data['safety_events']:
            tags.append("safety_event")
            for event in experience_data['safety_events']:
                tags.append(f"safety_{event}")
        
        return tags
    
    def _detect_daily_patterns(self, time_series_data):
        """Detect daily recurring patterns in traffic data"""
        # Simplified pattern detection - in practice would use ML
        hourly_average_speeds = {}
        hourly_traffic_volumes = {}
        
        # Aggregate data by hour
        for timestamp, data in time_series_data:
            hour = timestamp.hour
            if hour not in hourly_average_speeds:
                hourly_average_speeds[hour] = []
                hourly_traffic_volumes[hour] = []
            
            hourly_average_speeds[hour].append(data.get('speed', 0))
            hourly_traffic_volumes[hour].append(data.get('volume', 0))
        
        # Compute averages
        daily_pattern = {
            'hourly_speeds': {h: np.mean(speeds) for h, speeds in hourly_average_speeds.items()},
            'hourly_volumes': {h: np.mean(volumes) for h, volumes in hourly_traffic_volumes.items()}
        }
        
        return daily_pattern
    
    def _detect_weekly_patterns(self, time_series_data):
        """Detect weekly recurring patterns"""
        # Similar aggregation by day of week
        daily_patterns = {}
        
        for timestamp, data in time_series_data:
            day_of_week = timestamp.weekday()  # 0=Monday, 6=Sunday
            if day_of_week not in daily_patterns:
                daily_patterns[day_of_week] = []
            
            daily_patterns[day_of_week].append(data)
        
        # Compute weekly pattern statistics
        weekly_pattern = {
            'daily_characteristics': {
                day: self._compute_daily_characteristics(data)
                for day, data in daily_patterns.items()
            }
        }
        
        return weekly_pattern
    
    def _compute_daily_characteristics(self, daily_data):
        """Compute statistical characteristics for daily data"""
        if not daily_data:
            return {}
        
        speeds = [d.get('speed', 0) for d in daily_data]
        volumes = [d.get('volume', 0) for d in daily_data]
        
        return {
            'avg_speed': np.mean(speeds),
            'speed_variance': np.var(speeds),
            'peak_volume_time': self._find_peak_time(volumes),
            'traffic_stability': self._compute_stability(volumes)
        }
    
    def _find_peak_time(self, volumes):
        """Find peak traffic volume time"""
        if not volumes:
            return None
        peak_hour = np.argmax(volumes)
        return f"{peak_hour}:00"
    
    def _compute_stability(self, data):
        """Compute data stability measure"""
        if len(data) < 2:
            return 1.0
        return 1.0 / (1.0 + np.std(data) / (np.mean(data) + 1e-8))

# Initialize the memory system in the autonomous vehicle
vehicle_memory = AutonomousVehicleMemorySystem()

# Example usage in vehicle operation
def autonomous_driving_scenario():
    # Record a successful highway driving experience
    highway_episode = {
        'route': {'highway': 'I-95', 'direction': 'north'},
        'weather': 'clear',
        'traffic_density': 'moderate',
        'road_conditions': 'dry',
        'maneuvers': ['lane_change', 'speed_adjustment', 'following_distance_maintenance'],
        'safety_events': [],
        'metrics': {'efficiency': 0.92, 'comfort': 0.88}
    }
    
    vehicle_memory.record_driving_experience(highway_episode)
    
    # Record an emergency braking experience
    emergency_episode = {
        'route': {'urban': 'Main Street', 'intersection': '5th Ave'},
        'weather': 'rainy',
        'traffic_density': 'heavy',
        'road_conditions': 'wet',
        'maneuvers': ['emergency_braking', 'obstacle_avoidance'],
        'safety_events': ['near_collision'],
        'metrics': {'efficiency': 0.45, 'comfort': 0.30}
    }
    
    vehicle_memory.record_driving_experience(emergency_episode)
    
    # Learn patterns from collected data
    location_data = {'location_id': 'main_street_5th_ave'}
    # Assume we have time series traffic data
    simulated_traffic_data = [
        (datetime(2024, 1, 15, 8, 0), {'speed': 15, 'volume': 80}),
        (datetime(2024, 1, 15, 17, 0), {'speed': 12, 'volume': 120}),
        # ... more data points
    ]
    
    vehicle_memory.learn_traffic_patterns(location_data, simulated_traffic_data)
    
    # Later, during real-time driving, retrieve relevant knowledge
    current_situation = {
        'location': {'id': 'main_street_5th_ave'},
        'time_of_day': 'evening_rush',
        'weather': 'rainy',
        'traffic_density': 'moderate',
        'vehicle_state': {'speed': 20, 'heading': 180}
    }
    
    driving_knowledge = vehicle_memory.retrieve_driving_knowledge(current_situation)
    
    return driving_knowledge