The Data Platform Crisis Hiding Behind AI: Why you have 6 months to pivot

import torch
import torch.nn as nn
from torch.optim import Adam
from langchain.embeddings import OpenAIEmbeddings
from typing import List, Dict, Tuple
import numpy as np

class DifferentiableSemanticSchema(nn.Module):
    """
    Schema represented as a learnable embedding space with continuous optimization.
    Agents interact with the schema, and their success/failure patterns drive evolution.
    """
    def __init__(self, n_entities: int, embedding_dim: int = 768):
        super().__init__()
        # Entity embeddings (tables, columns, relationships)
        self.entity_embeddings = nn.Parameter(torch.randn(n_entities, embedding_dim))
        # Relationship adjacency matrix (learnable graph structure)
        self.relationships = nn.Parameter(torch.randn(n_entities, n_entities))
        # Semantic projection layers
        self.query_encoder = nn.Sequential(
            nn.Linear(embedding_dim, embedding_dim * 2),
            nn.LayerNorm(embedding_dim * 2),
            nn.GELU(),
            nn.Linear(embedding_dim * 2, embedding_dim)
        )
        self.fitness_history = []
        
    def semantic_query(self, query_embedding: torch.Tensor) -> Tuple[torch.Tensor, float]:
        """
        Execute query in continuous semantic space, return results + confidence
        """
        # Encode query through learned projection
        encoded_query = self.query_encoder(query_embedding)
        
        # Compute semantic similarity to all entities
        similarities = torch.cosine_similarity(
            encoded_query.unsqueeze(0),
            self.entity_embeddings,
            dim=1
        )
        
        # Apply learned relationship graph
        relationship_weights = torch.softmax(self.relationships, dim=1)
        contextualized_similarities = torch.matmul(relationship_weights, similarities.unsqueeze(1)).squeeze()
        
        # Return top-k entities and aggregate confidence
        confidence = torch.max(contextualized_similarities).item()
        return contextualized_similarities, confidence
    
    def compute_fitness(self, 
                       query_history: List[Dict], 
                       alpha: float = 0.4,
                       beta: float = 0.3, 
                       gamma: float = 0.2,
                       delta: float = 0.1) -> float:
        """
        Compute schema fitness based on recent agent interactions
        """
        # Efficiency: inverse of mean latency
        latencies = [q['latency'] for q in query_history]
        efficiency = 1.0 / (np.mean(latencies) + 1e-6)
        
        # Expressiveness: success rate
        successes = [q['success'] for q in query_history]
        expressiveness = np.mean(successes)
        
        # Stability: schema churn rate (changes in embedding space)
        if len(self.fitness_history) > 10:
            recent_embeddings = self.fitness_history[-10:]
            embedding_deltas = [torch.norm(recent_embeddings[i] - recent_embeddings[i-1]).item() 
                              for i in range(1, len(recent_embeddings))]
            stability = 1.0 - np.mean(embedding_deltas)
        else:
            stability = 1.0
        
        # Entropy: schema complexity penalty
        embedding_probs = torch.softmax(torch.norm(self.entity_embeddings, dim=1), dim=0)
        entropy = -torch.sum(embedding_probs * torch.log(embedding_probs + 1e-10)).item()
        
        fitness = alpha * efficiency + beta * expressiveness + gamma * stability - delta * entropy
        return fitness

    def evolve(self, query_history: List[Dict], learning_rate: float = 1e-4):
        """
        Evolve schema based on agent interaction patterns using gradient descent
        """
        optimizer = Adam(self.parameters(), lr=learning_rate)
        
        # Compute current fitness
        current_fitness = self.compute_fitness(query_history)
        self.fitness_history.append(self.entity_embeddings.detach().clone())
        
        # Define loss as negative fitness (maximize fitness = minimize negative fitness)
        loss = -torch.tensor(current_fitness, requires_grad=True)
        
        # Backpropagate and update schema
        optimizer.zero_grad()
        
        # Compute gradients based on query success patterns
        for query in query_history[-100:]:  # Last 100 queries
            query_emb = torch.tensor(query['embedding'], dtype=torch.float32)
            _, confidence = self.semantic_query(query_emb)
            
            # Reward schema for successful queries, penalize for failures
            query_loss = -confidence if query['success'] else confidence
            query_loss.backward(retain_graph=True)
        
        optimizer.step()
        
        print(f"Schema evolved: Fitness = {current_fitness:.4f}, "
              f"Entities = {self.entity_embeddings.shape[0]}, "
              f"Mean embedding norm = {torch.norm(self.entity_embeddings, dim=1).mean():.4f}")

# Multi-Cloud Semantic Evolution Manager
class MultiCloudSemanticEvolver:
    """
    Orchestrates semantic schema evolution across AWS, Azure, GCP
    """
    def __init__(self, cloud_configs: Dict[str, str]):
        self.schemas = {
            'aws': DifferentiableSemanticSchema(n_entities=500),  # AWS Redshift entities
            'azure': DifferentiableSemanticSchema(n_entities=450),  # Azure Synapse entities
            'gcp': DifferentiableSemanticSchema(n_entities=480)  # GCP BigQuery entities
        }
        self.cloud_configs = cloud_configs
        self.embedder = OpenAIEmbeddings()
        
    def route_query(self, query: str) -> Tuple[str, torch.Tensor]:
        """
        Intelligently route query to optimal cloud based on semantic fit
        """
        query_embedding = torch.tensor(self.embedder.embed_query(query))
        
        best_cloud = None
        best_confidence = 0.0
        
        for cloud, schema in self.schemas.items():
            _, confidence = schema.semantic_query(query_embedding)
            if confidence > best_confidence:
                best_confidence = confidence
                best_cloud = cloud
        
        return best_cloud, query_embedding
    
    def execute_and_learn(self, query: str) -> Dict:
        """
        Execute query and evolve schemas based on outcome
        """
        import time
        start_time = time.time()
        
        # Route to best cloud
        target_cloud, query_embedding = self.route_query(query)
        
        # Simulate execution (replace with actual DB calls)
        success = np.random.random() > 0.1  # 90% success rate
        latency = time.time() - start_time
        
        # Record interaction
        interaction = {
            'query': query,
            'embedding': query_embedding.numpy(),
            'cloud': target_cloud,
            'success': success,
            'latency': latency,
            'timestamp': time.time()
        }
        
        # Periodic schema evolution (every 100 queries)
        if np.random.random() < 0.01:  # 1% chance to trigger evolution
            for schema in self.schemas.values():
                schema.evolve([interaction])
        
        return interaction

# Usage Example
evolver = MultiCloudSemanticEvolver({
    'aws': 'redshift://...',
    'azure': 'synapse://...',
    'gcp': 'bigquery://...'
})

# Agent generates queries, schemas evolve
for _ in range(1000):
    agent_query = "Analyze Q4 revenue trends by region with anomaly detection"
    result = evolver.execute_and_learn(agent_query)
    print(f"Query routed to {result['cloud']}, Success: {result['success']}")

import hashlib
import time
from typing import Dict, List, Optional, Set, Tuple
from dataclasses import dataclass
from collections import defaultdict
import json

@dataclass
class ContextArtifact:
    """
    Immutable context artifact with causal timestamp
    """
    agent_id: str
    data: Dict
    vector_clock: Dict[str, int]  # Lamport timestamp
    hash: str
    dependencies: Set[str]  # Hashes of prerequisite artifacts
    
    def __post_init__(self):
        if not self.hash:
            self.hash = self._compute_hash()
    
    def _compute_hash(self) -> str:
        content = json.dumps({
            'agent': self.agent_id,
            'data': self.data,
            'clock': self.vector_clock,
            'deps': sorted(list(self.dependencies))
        }, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()

class CausalContextMesh:
    """
    Decentralized context mesh with causal consistency guarantees.
    Implements vector clocks for causality tracking and Merkle DAGs for verification.
    """
    def __init__(self):
        self.artifacts: Dict[str, ContextArtifact] = {}  # hash -> artifact
        self.agent_clocks: Dict[str, int] = defaultdict(int)  # agent -> logical clock
        self.causal_graph: Dict[str, Set[str]] = defaultdict(set)  # hash -> dependency hashes
        
    def publish(self, agent_id: str, data: Dict, dependencies: Optional[Set[str]] = None) -> ContextArtifact:
        """
        Publish context artifact with causal timestamp
        """
        # Increment agent's logical clock
        self.agent_clocks[agent_id] += 1
        
        # Build vector clock incorporating dependencies
        vector_clock = {agent_id: self.agent_clocks[agent_id]}
        if dependencies:
            for dep_hash in dependencies:
                if dep_hash in self.artifacts:
                    dep_artifact = self.artifacts[dep_hash]
                    # Take max of current and dependency clocks
                    for dep_agent, dep_time in dep_artifact.vector_clock.items():
                        vector_clock[dep_agent] = max(
                            vector_clock.get(dep_agent, 0),
                            dep_time
                        )
        
        # Create artifact
        artifact = ContextArtifact(
            agent_id=agent_id,
            data=data,
            vector_clock=vector_clock,
            hash="",  # Will be computed in __post_init__
            dependencies=dependencies or set()
        )
        
        # Store in mesh
        self.artifacts[artifact.hash] = artifact
        self.causal_graph[artifact.hash] = artifact.dependencies
        
        print(f"Published artifact {artifact.hash[:8]}... by {agent_id} at clock {vector_clock}")
        return artifact
    
    def happens_before(self, artifact1_hash: str, artifact2_hash: str) -> bool:
        """
        Determine if artifact1 causally precedes artifact2 using vector clocks
        Returns True if artifact1 → artifact2 in causal order
        """
        if artifact1_hash not in self.artifacts or artifact2_hash not in self.artifacts:
            return False
        
        clock1 = self.artifacts[artifact1_hash].vector_clock
        clock2 = self.artifacts[artifact2_hash].vector_clock
        
        # artifact1 → artifact2 iff clock1 ≤ clock2 component-wise AND clock1 ≠ clock2
        all_leq = all(clock1.get(agent, 0) <= clock2.get(agent, 0) for agent in clock1)
        some_less = any(clock1.get(agent, 0) < clock2.get(agent, 0) for agent in clock1)
        
        return all_leq and some_less
    
    def are_concurrent(self, artifact1_hash: str, artifact2_hash: str) -> bool:
        """
        Check if two artifacts are concurrent (neither causally precedes the other)
        """
        return not self.happens_before(artifact1_hash, artifact2_hash) and \
               not self.happens_before(artifact2_hash, artifact1_hash)
    
    def query_causal_history(self, artifact_hash: str) -> List[ContextArtifact]:
        """
        Retrieve complete causal history (transitive closure of dependencies)
        """
        if artifact_hash not in self.artifacts:
            return []
        
        history = []
        visited = set()
        
        def dfs(hash: str):
            if hash in visited:
                return
            visited.add(hash)
            
            artifact = self.artifacts[hash]
            history.append(artifact)
            
            for dep_hash in artifact.dependencies:
                dfs(dep_hash)
        
        dfs(artifact_hash)
        return history
    
    def verify_causal_consistency(self) -> Tuple[bool, List[str]]:
        """
        Verify mesh satisfies causal consistency (all dependencies properly ordered)
        Returns (is_consistent, list_of_violations)
        """
        violations = []
        
        for artifact_hash, artifact in self.artifacts.items():
            for dep_hash in artifact.dependencies:
                if dep_hash not in self.artifacts:
                    violations.append(f"Missing dependency {dep_hash[:8]} for {artifact_hash[:8]}")
                    continue
                
                # Verify dependency causally precedes artifact
                if not self.happens_before(dep_hash, artifact_hash):
                    violations.append(
                        f"Causal violation: {dep_hash[:8]} does not precede {artifact_hash[:8]}"
                    )
        
        return len(violations) == 0, violations
    
    def create_causal_cut(self, min_timestamp: Dict[str, int]) -> Set[str]:
        """
        Create consistent snapshot (causal cut) of all artifacts after given vector time.
        A causal cut is a set of artifacts that could have existed simultaneously.
        """
        cut = set()
        
        for artifact_hash, artifact in self.artifacts.items():
            # Check if artifact's vector clock dominates min_timestamp
            dominates = all(
                artifact.vector_clock.get(agent, 0) >= min_timestamp.get(agent, 0)
                for agent in min_timestamp
            )
            if dominates:
                cut.add(artifact_hash)
        
        return cut

# Federated Context Mesh with Swarm Intelligence
class SwarmContextMesh:
    """
    Multi-agent swarm with emergent behavior through context mesh
    """
    def __init__(self, n_agents: int):
        self.mesh = CausalContextMesh()
        self.agents = [f"agent_{i}" for i in range(n_agents)]
        self.agent_states = {agent: {} for agent in self.agents}
        
    def swarm_consensus(self, query: str, n_rounds: int = 3) -> Dict:
        """
        Achieve consensus through iterative context sharing and voting
        """
        # Round 1: Each agent generates initial response
        round_1_artifacts = []
        for agent in self.agents[:5]:  # Use subset for demo
            response = {
                'query': query,
                'answer': f"{agent}_answer",
                'confidence': 0.7 + 0.3 * hash(agent) % 100 / 100  # Simulated
            }
            artifact = self.mesh.publish(agent, response)
            round_1_artifacts.append(artifact.hash)
        
        # Round 2: Agents review peers' responses and update
        round_2_artifacts = []
        for agent in self.agents[:5]:
            # Read all round 1 artifacts
            peer_responses = [self.mesh.artifacts[h].data for h in round_1_artifacts]
            
            # Update belief based on peer confidence
            avg_confidence = sum(r['confidence'] for r in peer_responses) / len(peer_responses)
            updated_response = {
                'query': query,
                'answer': f"{agent}_updated_answer",
                'confidence': (self.mesh.artifacts[round_1_artifacts[0]].data['confidence'] + avg_confidence) / 2,
                'round': 2
            }
            
            artifact = self.mesh.publish(
                agent, 
                updated_response,
                dependencies=set(round_1_artifacts)  # Causal dependency on round 1
            )
            round_2_artifacts.append(artifact.hash)
        
        # Final consensus: highest confidence answer
        final_artifact = max(
            [self.mesh.artifacts[h] for h in round_2_artifacts],
            key=lambda a: a.data['confidence']
        )
        
        return {
            'consensus_answer': final_artifact.data['answer'],
            'confidence': final_artifact.data['confidence'],
            'artifact_hash': final_artifact.hash,
            'causal_history_depth': len(self.mesh.query_causal_history(final_artifact.hash))
        }

# Usage Example
swarm = SwarmContextMesh(n_agents=10)

# Execute swarm consensus
result = swarm.consensus("What are Q4 revenue optimization strategies?")
print(f"\nSwarm Consensus: {result['consensus_answer']}")
print(f"Confidence: {result['confidence']:.2f}")
print(f"Causal History Depth: {result['causal_history_depth']}")

# Verify causal consistency
is_consistent, violations = swarm.mesh.verify_causal_consistency()
print(f"\nMesh Consistency: {is_consistent}")
if violations:
    print(f"Violations: {violations}")

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GCNConv, global_mean_pool
from typing import List, Dict, Tuple
import numpy as np

class PropheticEvaluationGNN(nn.Module):
    """
    Graph Neural Network for predicting agent execution failures before they occur.
    Analyzes execution plan structure to identify high-risk operations.
    """
    def __init__(self, node_feature_dim: int = 64, hidden_dim: int = 128):
        super().__init__()
        # GNN layers for learning execution graph structure
        self.conv1 = GCNConv(node_feature_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, hidden_dim)
        self.conv3 = GCNConv(hidden_dim, hidden_dim // 2)
        
        # Prediction head
        self.predictor = nn.Sequential(
            nn.Linear(hidden_dim // 2, 32),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(32, 1),
            nn.Sigmoid()  # Failure probability [0, 1]
        )
        
        # Risk scoring
        self.risk_threshold = 0.7
        
    def forward(self, x: torch.Tensor, edge_index: torch.Tensor, batch: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Forward pass: predict failure probability for each node in execution graph
        
        Args:
            x: Node features [num_nodes, feature_dim]
            edge_index: Graph edges [2, num_edges]
            batch: Batch assignment [num_nodes] for batched graphs
        
        Returns:
            node_predictions: Failure probability per node [num_nodes, 1]
            graph_prediction: Overall execution failure probability [batch_size, 1]
        """
        # Message passing through graph
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.2, training=self.training)
        
        x = self.conv2(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.2, training=self.training)
        
        x = self.conv3(x, edge_index)
        x = F.relu(x)
        
        # Node-level predictions
        node_predictions = self.predictor(x)
        
        # Graph-level prediction (aggregate node risks)
        graph_embeddings = global_mean_pool(x, batch)
        graph_predictions = self.predictor(graph_embeddings)
        
        return node_predictions, graph_predictions
    
    def identify_critical_paths(self, 
                               x: torch.Tensor, 
                               edge_index: torch.Tensor,
                               batch: torch.Tensor) -> List[List[int]]:
        """
        Identify execution paths most likely to fail (critical paths)
        """
        with torch.no_grad():
            node_risks, _ = self.forward(x, edge_index, batch)
            
            # Find high-risk nodes
            high_risk_nodes = (node_risks.squeeze() > self.risk_threshold).nonzero(as_tuple=True)[0]
            
            # Trace critical paths (simplified: just return high-risk nodes)
            # In production, would perform graph traversal to find complete paths
            critical_paths = []
            for node_idx in high_risk_nodes.tolist():
                critical_paths.append([node_idx])
            
            return critical_paths

class PropheticEvaluationOracle:
    """
    Meta-agent system that predicts and prevents agent failures
    """
    def __init__(self):
        self.gnn = PropheticEvaluationGNN()
        self.optimizer = torch.optim.Adam(self.gnn.parameters(), lr=1e-3)
        self.execution_history = []
        self.failure_stats = {
            'predicted_correctly': 0,
            'false_alarms': 0,
            'missed_failures': 0,
            'prevented_failures': 0
        }
        
    def analyze_execution_plan(self, execution_graph: Dict) -> Dict:
        """
        Analyze agent execution plan and predict failure probability
        
        Args:
            execution_graph: {
                'nodes': List of operation dicts,
                'edges': List of [source, target] pairs
            }
        
        Returns:
            Analysis with risk assessment and recommendations
        """
        # Convert execution plan to graph tensors
        node_features = self._encode_nodes(execution_graph['nodes'])
        edge_index = torch.tensor(execution_graph['edges'], dtype=torch.long).t()
        batch = torch.zeros(len(execution_graph['nodes']), dtype=torch.long)
        
        # Predict failure probability
        self.gnn.eval()
        with torch.no_grad():
            node_risks, graph_risk = self.gnn(node_features, edge_index, batch)
        
        # Identify critical paths
        critical_paths = self.gnn.identify_critical_paths(node_features, edge_index, batch)
        
        analysis = {
            'overall_failure_probability': graph_risk.item(),
            'high_risk_nodes': (node_risks.squeeze() > 0.7).sum().item(),
            'critical_paths': critical_paths,
            'recommendation': self._generate_recommendation(graph_risk.item(), node_risks),
            'estimated_cost_if_failed': self._estimate_failure_cost(execution_graph)
        }
        
        return analysis
    
    def _encode_nodes(self, nodes: List[Dict]) -> torch.Tensor:
        """
        Encode operation nodes as feature vectors
        """
        features = []
        for node in nodes:
            # Feature engineering based on operation characteristics
            feature_vec = [
                1.0 if node['type'] == 'api_call' else 0.0,
                1.0 if node['type'] == 'reasoning' else 0.0,
                1.0 if node['type'] == 'data_fetch' else 0.0,
                node.get('complexity', 1.0) / 10.0,  # Normalized complexity
                node.get('estimated_latency', 100) / 1000.0,  # Normalized latency
                node.get('dependencies_count', 0) / 10.0,  # Normalized dependency count
                node.get('historical_failure_rate', 0.1),  # Historical failure rate
                1.0 if node.get('requires_external_service') else 0.0,
            ]
            # Pad to 64 dimensions
            feature_vec += [0.0] * (64 - len(feature_vec))
            features.append(feature_vec)
        
        return torch.tensor(features, dtype=torch.float32)
    
    def _generate_recommendation(self, graph_risk: float, node_risks: torch.Tensor) -> str:
        """
        Generate actionable recommendation based on risk analysis
        """
        if graph_risk > 0.8:
            return "ABORT: Execution plan has >80% failure probability. Recommend re-planning with simpler operations."
        elif graph_risk > 0.5:
            high_risk_count = (node_risks.squeeze() > 0.7).sum().item()
            return f"WARNING: {high_risk_count} high-risk operations detected. Consider adding fallbacks or simplifying these steps."
        else:
            return "PROCEED: Execution plan appears sound with acceptable risk level."
    
    def _estimate_failure_cost(self, execution_graph: Dict) -> float:
        """
        Estimate cost if execution fails (API costs, compute, corrupted state)
        """
        total_cost = 0.0
        for node in execution_graph['nodes']:
            if node['type'] == 'api_call':
                total_cost += 0.05  # $0.05 per API call
            elif node['type'] == 'data_fetch':
                total_cost += 0.02  # $0.02 per data fetch
        
        # Add downstream corruption cost (speculative)
        downstream_nodes = len(execution_graph['nodes'])
        total_cost += downstream_nodes * 0.01  # $0.01 per affected downstream operation
        
        return total_cost
    
    def learn_from_execution(self, execution_graph: Dict, actual_outcome: bool):
        """
        Train GNN on actual execution outcomes to improve predictions
        
        Args:
            execution_graph: The execution plan
            actual_outcome: True if execution succeeded, False if failed
        """
        # Convert to tensors
        node_features = self._encode_nodes(execution_graph['nodes'])
        edge_index = torch.tensor(execution_graph['edges'], dtype=torch.long).t()
        batch = torch.zeros(len(execution_graph['nodes']), dtype=torch.long)
        
        # Forward pass
        self.gnn.train()
        node_risks, graph_risk = self.gnn(node_features, edge_index, batch)
        
        # Loss: binary cross-entropy (predict success/failure)
        target = torch.tensor([[0.0 if actual_outcome else 1.0]])  # 1 = failure
        loss = F.binary_cross_entropy(graph_risk, target)
        
        # Backprop
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()
        
        # Update stats
        predicted_failure = graph_risk.item() > 0.5
        actual_failure = not actual_outcome
        
        if predicted_failure == actual_failure:
            self.failure_stats['predicted_correctly'] += 1
        elif predicted_failure and not actual_failure:
            self.failure_stats['false_alarms'] += 1
        elif not predicted_failure and actual_failure:
            self.failure_stats['missed_failures'] += 1
        
        print(f"Oracle learned from execution: Loss = {loss.item():.4f}, "
              f"Predicted risk = {graph_risk.item():.2f}, Actual = {'failure' if actual_failure else 'success'}")

# Usage Example
oracle = PropheticEvaluationOracle()

# Agent proposes execution plan
execution_plan = {
    'nodes': [
        {'type': 'api_call', 'complexity': 5, 'estimated_latency': 200, 'dependencies_count': 0, 'historical_failure_rate': 0.05, 'requires_external_service': True},
        {'type': 'reasoning', 'complexity': 8, 'estimated_latency': 500, 'dependencies_count': 1, 'historical_failure_rate': 0.15, 'requires_external_service': False},
        {'type': 'data_fetch', 'complexity': 3, 'estimated_latency': 150, 'dependencies_count': 1, 'historical_failure_rate': 0.02, 'requires_external_service': True},
        {'type': 'api_call', 'complexity': 7, 'estimated_latency': 300, 'dependencies_count': 2, 'historical_failure_rate': 0.12, 'requires_external_service': True},
    ],
    'edges': [[0, 1], [1, 2], [1, 3], [2, 3]]  # Dependency graph
}

# Prophetic evaluation
analysis = oracle.analyze_execution_plan(execution_plan)
print(f"\nProphetic Analysis:")
print(f"  Overall Failure Probability: {analysis['overall_failure_probability']:.2%}")
print(f"  High Risk Nodes: {analysis['high_risk_nodes']}")
print(f"  Recommendation: {analysis['recommendation']}")
print(f"  Estimated Cost if Failed: ${analysis['estimated_cost_if_failed']:.2f}")

# Execute and learn
simulated_outcome = np.random.random() > analysis['overall_failure_probability']
oracle.learn_from_execution(execution_plan, simulated_outcome)

# Print oracle performance stats
print(f"\nOracle Performance:")
print(f"  Predictions Correct: {oracle.failure_stats['predicted_correctly']}")
print(f"  False Alarms: {oracle.failure_stats['false_alarms']}")
print(f"  Missed Failures: {oracle.failure_stats['missed_failures']}")