""" DeploymentZoneShiftSCM - Deployment Zone Trap with Environment Shift. Based on deployment_zone_trap, but adds environment shift between Stage 1 and Stage 2: Stage 1 (Exploration): Balanced zone distribution - Agent explores all zones with equal probability - Learns the causal structure Stage 2 (Evaluation): Shifted zone distribution - High-risk zones (gamma, epsilon) become more common - Tests if agent discovered the TRUE causal mechanism (shield_def protects against EMI) - Agent who overfitted to Stage 1 distribution will fail Causal structure: mission_zone (hidden) --> altitude_band (visible) mission_zone (hidden) --> emi_level (hidden) emi_level --> comm_failure --> drone_loss NOT: altitude_band --> drone_loss (spurious correlation!) Correct strategy: Invest in shield_def to resist EMI Trap strategy: Invest in engine_def for high-altitude capability (overfits to altitude correlation) Stage shift creates additional challenge: - Stage 1: Agent might learn "avoid low altitude" because gamma (low+high-EMI) is 35% - Stage 2: If agent overfits to altitude strategy, fails when high-altitude+high-EMI (epsilon) increases - TRUE solution: shield_def works in ALL zones """ from typing import Dict, Any import random from .scm_base import BaseSCM, EnvironmentState, CausalVariable, StructuralEquation from .scm_registry import register_scm @register_scm("deployment_zone_trap_env_shift") class DeploymentZoneShiftSCM(BaseSCM): """ Deployment Zone Trap with Stage 1 → Stage 2 Environment Shift. Stage 1: Balanced zone distribution (exploration friendly) Stage 2: High-risk zones more common (tests true causal understanding) Key insight: Agent must discover shield_def → EMI resistance (causal mechanism) NOT just "avoid certain zones" (correlation learned in Stage 1) """ # Zone definitions ZONE_TYPES = { 'alpha': { # Safe high-altitude corridor 'altitude_band': 'high', 'emi_level': 0.1, 'stage1_probability': 0.50, 'stage2_probability': 0.00, 'description': 'High-altitude safe corridor', }, 'beta': { # Mixed medium-altitude zone 'altitude_band': 'medium', 'emi_level': 0.2, 'stage1_probability': 0.20, # Stage 1: 20% 'stage2_probability': 0.00, # Stage 2: 15% 'description': 'Medium-altitude mixed zone', }, 'gamma': { # Low-altitude EMI heavy zone (main trap in Stage 1!) 'altitude_band': 'low', 'emi_level': 0.3, 'stage1_probability': 0.30, # Stage 1: 20% (balanced) 'stage2_probability': 0.00, # Stage 2: 35% (INCREASES!) 'description': 'Low-altitude high-EMI zone' }, 'delta': { # Low-altitude SAFE zone (counter-example) 'altitude_band': 'low', 'emi_level': 0.8, 'stage1_probability': 0.00, # Stage 1: 20% 'stage2_probability': 0.50, # Stage 2: 10% 'description': 'Low-altitude safe corridor', }, 'epsilon': { # High-altitude EMI zone (counter-example, becomes common in Stage 2!) 'altitude_band': 'high', 'emi_level': 0.8, 'stage1_probability': 0.00, # Stage 1: 20% 'stage2_probability': 0.50, # Stage 2: 30% (INCREASES!) 'description': 'High-altitude EMI zone', }, } def __init__(self, config: Dict[str, Any]): super().__init__(config) # EMI effect parameters self.emi_base_failure_rate = self.get_parameter('emi_base_failure_rate', 0.7) self.emi_threshold = self.get_parameter('emi_threshold', 0.3) # Shield effectiveness self.shield_effectiveness = self.get_parameter('shield_effectiveness', 0.025) self.max_shield_reduction = self.get_parameter('max_shield_reduction', 0.8) # Communication failure consequences self.comm_failure_loss_rate = self.get_parameter('comm_failure_loss_rate', 0.85) self.base_loss_rate = self.get_parameter('base_loss_rate', 0.12) # Wind damage by altitude (minor effect) self.altitude_wind_damage = self.get_parameter('altitude_wind_damage', { 'low': 0.05, 'medium': 0.10, 'high': 0.15, }) # Altitude signal modifier (slight effect, misleading hint) self.altitude_signal_modifier = { 'low': -0.05, 'medium': 0.0, 'high': 0.05, } # ============================================================ # STAGE TRACKING (NEW!) # ============================================================ self._current_stage = 1 # 1 = exploration, 2 = evaluation self._use_stage2_distribution = False self._setup_causal_structure() def set_evaluation_mode(self, is_evaluation: bool = True): """ Switch to Stage 2 (evaluation) mode. Stage 1 (exploration): Balanced zone distribution Stage 2 (evaluation): High-risk zones (gamma, epsilon) more common This tests if agent discovered TRUE causal mechanism: - shield_def protects against EMI (works in all zones) ✓ - NOT just "avoid certain zones" (fails when distribution shifts) ✗ """ if is_evaluation: self._current_stage = 2 self._use_stage2_distribution = True else: self._current_stage = 1 self._use_stage2_distribution = False def _get_zone_probabilities(self) -> Dict[str, float]: """Get current zone probabilities based on stage.""" if self._use_stage2_distribution: # Stage 2: High-risk zones more common return { zone: info['stage2_probability'] for zone, info in self.ZONE_TYPES.items() } else: # Stage 1: Balanced distribution return { zone: info['stage1_probability'] for zone, info in self.ZONE_TYPES.items() } def _setup_causal_structure(self) -> None: """Register causal variables and structural equations.""" # === Exogenous variable: Mission Zone (THE HIDDEN CONFOUNDER) === self.register_variable(CausalVariable( name='mission_zone', var_type='latent', parents=[], description='Mission zone assignment (hidden confounder)', )) # === Observed variables === self.register_variable(CausalVariable( name='altitude_band', var_type='observed', parents=['mission_zone'], description='Flight altitude band (low/medium/high) - VISIBLE but NOT causal!', )) self.register_variable(CausalVariable( name='wind_resistance', var_type='observed', parents=['altitude_band'], description='Wind resistance coefficient', domain=(0.1, 1.0), )) self.register_variable(CausalVariable( name='signal_strength', var_type='observed', parents=['altitude_band'], description='Base signal strength (visible, slight altitude effect)', domain=(0.0, 1.0), )) # === Action variables (Agent can intervene) === self.register_variable(CausalVariable( name='shield_def', var_type='action', parents=[], description='Shield defense value - Agent intervention point', domain=(0, 50), )) # === Latent variables (THE TRUE CAUSES) === self.register_variable(CausalVariable( name='emi_level', var_type='latent', parents=['mission_zone'], description='EMI intensity - THE TRUE CAUSE (hidden!)', domain=(0.0, 1.0), )) self.register_variable(CausalVariable( name='effective_emi', var_type='latent', parents=['emi_level', 'shield_def'], description='EMI after shield mitigation', domain=(0.0, 1.0), )) self.register_variable(CausalVariable( name='comm_failure_prob', var_type='latent', parents=['effective_emi'], description='Communication failure probability', domain=(0.0, 1.0), )) self.register_variable(CausalVariable( name='drone_loss', var_type='outcome', parents=['comm_failure_prob'], description='Drone destruction outcome', domain=(0.0, 1.0), )) # === Causal edges === self.add_causal_edge('mission_zone', 'altitude_band') self.add_causal_edge('mission_zone', 'emi_level') self.add_causal_edge('altitude_band', 'wind_resistance') self.add_causal_edge('altitude_band', 'signal_strength') self.add_causal_edge('emi_level', 'effective_emi') self.add_causal_edge('shield_def', 'effective_emi') self.add_causal_edge('effective_emi', 'comm_failure_prob') self.add_causal_edge('comm_failure_prob', 'drone_loss') # === Structural equations === self.register_equation(StructuralEquation( target='altitude_band', function=self._eq_altitude_band, description='Altitude determined by zone', )) self.register_equation(StructuralEquation( target='emi_level', function=self._eq_emi_level, description='EMI determined by zone', )) self.register_equation(StructuralEquation( target='wind_resistance', function=self._eq_wind_resistance, description='Wind resistance varies with altitude', )) self.register_equation(StructuralEquation( target='signal_strength', function=self._eq_signal_strength, description='Signal strength has slight altitude effect', )) def _eq_altitude_band(self, values: Dict[str, Any]) -> str: """Altitude band determined by mission zone.""" zone = values.get('mission_zone', 'beta') return self.ZONE_TYPES.get(zone, {}).get('altitude_band', 'medium') def _eq_emi_level(self, values: Dict[str, Any]) -> float: """EMI level determined by mission zone (with noise).""" zone = values.get('mission_zone', 'beta') base_emi = self.ZONE_TYPES.get(zone, {}).get('emi_level', 0.4) return max(0.0, min(1.0, base_emi + random.uniform(-0.1, 0.1))) def _eq_wind_resistance(self, values: Dict[str, Any]) -> float: """Wind resistance varies with altitude (visible effect).""" altitude = values.get('altitude_band', 'medium') base_wind = {'low': 0.2, 'medium': 0.5, 'high': 0.8} return base_wind.get(altitude, 0.5) + random.uniform(-0.1, 0.1) def _eq_signal_strength(self, values: Dict[str, Any]) -> float: """Signal strength has slight altitude effect (visible, misleading).""" altitude = values.get('altitude_band', 'medium') base_signal = {'low': 0.9, 'medium': 0.85, 'high': 0.75} return base_signal.get(altitude, 0.85) + random.uniform(-0.05, 0.05) def sample_environment(self, equipment: dict = None) -> EnvironmentState: """ Sample environment with STAGE-AWARE zone distribution. Stage 1: Balanced (20% each zone) Stage 2: Shifted (high-risk zones gamma/epsilon increase to 35%/30%) Args: equipment: Optional equipment/discrete choices from agent (includes flight_profile) """ # Sample mission zone with stage-dependent probabilities (determines EMI - TRUE cause) zones = list(self.ZONE_TYPES.keys()) probabilities = list(self._get_zone_probabilities().values()) zone = random.choices(zones, weights=probabilities)[0] zone_info = self.ZONE_TYPES[zone] # Get EMI from zone (hidden!) - THIS IS THE TRUE CAUSE emi_level = zone_info['emi_level'] + random.uniform(-0.1, 0.1) emi_level = max(0.0, min(1.0, emi_level)) # Altitude is determined by agent's flight_profile choice (if provided) # This is the TRAP: agent thinks they control altitude, but altitude doesn't affect survival! # EMI (from mission_zone) is the true cause. if equipment and 'flight_profile' in equipment: altitude_band = equipment['flight_profile'] # Agent's choice else: # Fallback to zone-based altitude (for historical data / no choice) altitude_band = zone_info['altitude_band'] # Compute visible variables wind_resistance = self._eq_wind_resistance({'altitude_band': altitude_band}) signal_strength = self._eq_signal_strength({'altitude_band': altitude_band}) # Temperature varies with altitude if altitude_band == 'high': temperature = random.uniform(-5, 10) elif altitude_band == 'medium': temperature = random.uniform(10, 20) else: temperature = random.uniform(15, 30) # Add stage indicator to derived (for logging/debugging) stage_indicator = f"Stage {self._current_stage}" return EnvironmentState( visible={ 'altitude_band': altitude_band, 'wind_resistance': wind_resistance, 'signal_strength': signal_strength, 'temperature': temperature, }, latent={ 'mission_zone': zone, 'emi_level': emi_level, 'stage': self._current_stage, # Track stage internally }, derived={ 'zone_description': zone_info['description'], 'stage': stage_indicator, } ) def _compute_effects(self, sheet, env: EnvironmentState): """ Compute effects with EMI as the true cause of losses. Mechanism identical to deployment_zone_trap: - Shield_def reduces effective EMI - High EMI causes communication failures - Communication failures cause CRITICAL component damage KEY DIFFERENCE: Zone distribution changes between stages - Stage 1: Balanced (agent can learn from diverse zones) - Stage 2: High-risk zones more common (tests true causal understanding) Agent who learned "shield_def protects against EMI" succeeds in both stages Agent who learned "avoid low altitude" fails in Stage 2 (high altitude also dangerous) """ try: from ...middleware.drone_state import EnvironmentEffects except ImportError: from middleware.drone_state import EnvironmentEffects # Get hidden EMI level emi_level = env.latent.get('emi_level', 0.4) altitude_band = env.visible.get('altitude_band', 'medium') mission_zone = env.latent.get('mission_zone', 'beta') # === Shield mitigation of EMI === shield_def = sheet._def.get('shield_def', 0) # Each point of shield_def reduces EMI impact shield_reduction = min( shield_def * self.shield_effectiveness, self.max_shield_reduction ) # === Equipment effects === equipment_emi_resistance = 0.0 if hasattr(sheet, '_equipment_effects') and sheet._equipment_effects: equipment_emi_resistance = getattr(sheet._equipment_effects, 'emi_resistance', 0.0) # Combine shield reduction with equipment resistance total_emi_reduction = min(0.95, shield_reduction + equipment_emi_resistance) effective_emi = emi_level * (1 - total_emi_reduction) # === Communication failure probability === if effective_emi < self.emi_threshold: comm_failure_prob = 0.0 else: comm_failure_prob = (effective_emi - self.emi_threshold) * \ self.emi_base_failure_rate # Slight altitude modifier (misleading!) altitude_mod = self.altitude_signal_modifier.get(altitude_band, 0) comm_failure_prob = min(0.95, max(0.0, comm_failure_prob + altitude_mod)) # === Component damage === component_damage = {} # Wind damage (varies with altitude - visible effect, MINOR) wind_damage_rate = self.altitude_wind_damage.get(altitude_band, 0.1) if wind_damage_rate > 0: if altitude_band == 'high': component_damage['engine'] = int(random.uniform(5, 15)) component_damage['wing'] = int(random.uniform(8, 20)) elif altitude_band == 'medium': component_damage['wing'] = int(random.uniform(3, 10)) # === EMI DAMAGE - THE TRUE CAUSE OF LOSSES === if effective_emi > self.emi_threshold: # Direct EMI damage to antenna emi_damage = int((effective_emi - self.emi_threshold) * 80) component_damage['antenna'] = emi_damage # EMI damages camera electronics if effective_emi > 0.4: component_damage['camera'] = int(emi_damage * 0.6) # Communication failure causes CATASTROPHIC damage (main death mechanism!) if comm_failure_prob > 0: if random.random() < comm_failure_prob: crash_severity = random.uniform(0.6, 1.0) * comm_failure_prob component_damage['engine'] = component_damage.get('engine', 0) + int(60 * crash_severity) component_damage['wing'] = component_damage.get('wing', 0) + int(50 * crash_severity) component_damage['body'] = component_damage.get('body', 0) + int(40 * crash_severity) component_damage['cockpit'] = component_damage.get('cockpit', 0) + int(35 * crash_severity) # === Detection and combat === base_detection = 0.20 detection_modifier = base_detection + comm_failure_prob * 0.5 if comm_failure_prob > 0.5: combat_rounds_mod = 1.8 else: combat_rounds_mod = 1.0 if effective_emi > 0.5: combat_damage_mod = 1.0 + (effective_emi - 0.5) * 0.5 else: combat_damage_mod = 1.0 return EnvironmentEffects( component_damage=component_damage, detection_modifier=detection_modifier, combat_rounds_modifier=combat_rounds_mod, combat_damage_modifier=combat_damage_mod, combat_accuracy_modifier=1.0, weather_pattern=emi_level, raw_environment={ **env.visible, 'effective_emi': effective_emi, 'comm_failure_prob': comm_failure_prob, }, damage_log=[ f"Stage: {self._current_stage}", f"Mission zone: {mission_zone} ({env.derived.get('zone_description', '')})", f"Altitude band: {altitude_band}", f"EMI level: {emi_level:.2f} (hidden!)", f"Shield DEF: {shield_def}", f"Shield reduction: {shield_reduction:.2%}", f"Equipment EMI resistance: {equipment_emi_resistance:.2%}", f"Total EMI reduction: {total_emi_reduction:.2%}", f"Effective EMI: {effective_emi:.2f}", f"Comm failure prob: {comm_failure_prob:.2%}", f"Wind damage rate: {wind_damage_rate:.2%}", f"Detection modifier: {detection_modifier:.2f}", f"Combat damage modifier: {combat_damage_mod:.2f}", f"-- STAGE SHIFT TRAP --", f"Stage {self._current_stage} zone distribution", f"Agent sees: altitude_band = {altitude_band}", f"Agent may think: altitude causes losses", f"True cause: EMI level = {emi_level:.2f}", f"Solution: shield_def protects against EMI (works in ALL zones!)", ] )