def verify_layer_independence(defense_layers, attack_set):
    """
    Test whether defense layers fail independently.
    Correlated failures indicate shared weaknesses.
    """
    layer_results = {}
 
    for attack in attack_set:
        for layer_name, layer in defense_layers.items():
            blocked = layer.check(attack)["blocked"]
            if layer_name not in layer_results:
                layer_results[layer_name] = []
            layer_results[layer_name].append(blocked)
 
    # Check pairwise correlation
    correlations = {}
    layer_names = list(layer_results.keys())
 
    for i, name_a in enumerate(layer_names):
        for j, name_b in enumerate(layer_names):
            if i < j:
                results_a = layer_results[name_a]
                results_b = layer_results[name_b]
 
                # Compute correlation
                both_fail = sum(
                    1 for a, b in zip(results_a, results_b)
                    if not a and not b
                )
                either_fail = sum(
                    1 for a, b in zip(results_a, results_b)
                    if not a or not b
                )
 
                correlation = both_fail / max(either_fail, 1)
                correlations[f"{name_a} <-> {name_b}"] = {
                    "correlation": correlation,
                    "independent": correlation < 0.3
                }
 
    return correlations

class FailClosedLayer:
    """Block request if the defense layer encounters an error."""
 
    def check(self, input_text):
        try:
            result = self.classifier.classify(input_text)
            return result
        except Exception as e:
            # Defense error -> block the request (conservative)
            logger.error(f"Defense layer error: {e}")
            return {"blocked": True, "reason": "defense_error"}
 
class FailOpenLayer:
    """Allow request through if the defense layer encounters an error."""
 
    def check(self, input_text):
        try:
            result = self.classifier.classify(input_text)
            return result
        except Exception as e:
            # Defense error -> allow through (permissive)
            logger.warning(f"Defense layer error, failing open: {e}")
            return {"blocked": False, "reason": "defense_error_failopen"}

class LayeredDefenseOrchestrator:
    """Orchestrate sync and async defense layers."""
 
    def __init__(self):
        self.sync_layers = []    # Must pass before response
        self.async_layers = []   # Run in background
 
    def process(self, request):
        # Synchronous layers: block if any fails
        for layer in self.sync_layers:
            result = layer.check(request)
            if result["blocked"]:
                return self.block_response(result)
 
        # Process request (generate response)
        response = self.generate_response(request)
 
        # Synchronous output layers
        for layer in self.sync_output_layers:
            result = layer.check(response)
            if result["blocked"]:
                return self.block_response(result)
 
        # Async layers: log and monitor without blocking
        for layer in self.async_layers:
            self.background_queue.put((layer, request, response))
 
        return response

class EscalationChain:
    """Escalate suspicious requests through increasing scrutiny."""
 
    def __init__(self):
        self.levels = [
            {"name": "automated_fast", "threshold": 0.3, "action": "allow"},
            {"name": "automated_deep", "threshold": 0.6, "action": "enhanced_check"},
            {"name": "human_review_queue", "threshold": 0.8, "action": "queue"},
            {"name": "block", "threshold": 0.95, "action": "block"},
        ]
 
    def evaluate(self, request, risk_score):
        """Route request based on risk score."""
        for level in self.levels:
            if risk_score < level["threshold"]:
                return {
                    "action": level["action"],
                    "level": level["name"],
                    "risk_score": risk_score
                }
 
        return {"action": "block", "level": "maximum", "risk_score": risk_score}

# Total latency budget: 2000ms (typical for chat applications)
LATENCY_BUDGET = {
    "perimeter": 5,           # Rate limit check: 5ms
    "input_analysis": 50,     # ML classifier: 50ms
    "context_security": 20,   # Template checking: 20ms
    "model_inference": 1500,  # LLM generation: 1500ms
    "output_validation": 100, # Safety classifier: 100ms
    "post_delivery": 0,       # Async, no added latency
    "overhead": 25,           # Network, serialization: 25ms
    "buffer": 300,            # Headroom for variance: 300ms
}
# Total: 2000ms

import asyncio
 
async def parallel_input_defense(request):
    """Run independent input defense layers in parallel."""
    results = await asyncio.gather(
        prompt_shield.check_async(request),
        encoding_normalizer.check_async(request),
        pattern_blocklist.check_async(request),
        return_exceptions=True
    )
 
    # Block if any layer flags the request
    for result in results:
        if isinstance(result, Exception):
            continue  # Individual layer failure, continue
        if result.get("blocked"):
            return result
 
    return {"blocked": False}

def layer_contribution_analysis(layers, attack_set):
    """Measure each layer's marginal contribution to defense."""
    all_layers_result = evaluate_defense(layers, attack_set)
 
    contributions = {}
    for layer_name in layers:
        # Remove this layer and evaluate
        remaining = {k: v for k, v in layers.items() if k != layer_name}
        without_layer = evaluate_defense(remaining, attack_set)
 
        contributions[layer_name] = {
            "block_rate_with": all_layers_result["block_rate"],
            "block_rate_without": without_layer["block_rate"],
            "marginal_contribution": (
                all_layers_result["block_rate"] -
                without_layer["block_rate"]
            ),
            "is_redundant": (
                all_layers_result["block_rate"] ==
                without_layer["block_rate"]
            )
        }
 
    return contributions