class TraditionalNO:
    """
    How traditional systems handle NO
    """
    def the_old_way(self):
        return {
            'request_response_paradigm': {
                'request': 'node.get_chunk("chunk_x")',
                'expected': 'Chunk data returned',
                'if_unavailable': 'Exception thrown or error code',
                'developer_sees': 'ERROR: Chunk not found',
                'system_response': 'Try/catch, retry logic, fallback',
                'problem': 'NO treated as failure, not information'
            },
            
            'blocking_nature': {
                'thread': 'Blocks waiting for response',
                'timeout': 'Must set timeout (how long to wait?)',
                'retry': 'Must implement retry logic',
                'cascading': 'Blocked thread blocks other operations',
                'result': 'Complex error handling, reduced throughput'
            },
            
            'information_loss': {
                'what_you_learn': 'Chunk not available (eventually)',
                'what_you_dont_learn': {
                    'why_not': 'Rate limited? Doesn\'t have it? Offline?',
                    'when_retry': 'Immediately? In 60s? Never?',
                    'who_else': 'Are other nodes similar?',
                    'pattern': 'Is this isolated or systemic?'
                },
                'problem': 'NO collapsed to single bit (success/fail)'
            },
            
            'exception_overhead': {
                'stack_unwinding': 'Expensive',
                'state_cleanup': 'Complex',
                'retry_logic': 'Error-prone',
                'cascading_failures': 'Common',
                'result': 'NO is expensive to handle'
            }
        }

class PureFluxNO:
    """
    How pure flux handles NO (from Post 878)
    """
    def the_new_way(self):
        return {
            'push_intent': {
                'action': 'dht.push_intent({"want_chunk": "chunk_x"})',
                'returns': 'Immediately (no waiting)',
                'no_blocking': 'Thread continues',
                'responses_later': 'Via P2P, asynchronously'
            },
            
            'p2p_responses': {
                'node_has_chunk': {
                    'response': '{"status": "YES", "data": chunk_data}',
                    'append_to_series': {
                        'event': 'chunk_received',
                        'chunk_id': 'chunk_x',
                        'from': node_address,
                        'data': chunk_data
                    }
                },
                
                'node_rate_limited': {
                    'response': '{"status": "NO", "reason": "rate_limited", "retry_after": 60}',
                    'append_to_series': {
                        'event': 'chunk_denied',
                        'chunk_id': 'chunk_x',
                        'from': node_address,
                        'reason': 'rate_limited',
                        'retry_after': 60
                    },
                    'value': 'VALID DATA - tells us about constraint'
                },
                
                'node_lacks_chunk': {
                    'response': '{"status": "NO", "reason": "dont_have", "suggested_nodes": [addr1, addr2]}',
                    'append_to_series': {
                        'event': 'chunk_unavailable',
                        'chunk_id': 'chunk_x',
                        'from': node_address,
                        'reason': 'dont_have',
                        'suggestions': [addr1, addr2]
                    },
                    'value': 'VALID DATA - tells us where to look instead'
                }
            },
            
            'no_exceptions': {
                'everything_is_data': 'YES, NO, MAYBE all just data',
                'append_to_series': 'All responses appended',
                'derive_state': 'Reduce series to understand current state',
                'no_blocking': 'Never blocks on NO',
                'no_errors': 'NO is not error, just information'
            }
        }

class UniversalNOComputation:
    """
    NO as universal constraint signal
    """
    def the_framework(self):
        return {
            'no_meanings': {
                'rate_limited_no': {
                    'signal': 'Resource constraint active',
                    'constraint_type': 'Bandwidth/rate limit',
                    'probability_space': 'Temporarily reduced',
                    'information': 'Can try later (when?)',
                    'w_implication': 'Configuration space temporarily collapsed'
                },
                
                'dont_have_no': {
                    'signal': 'Data not at this location',
                    'constraint_type': 'Data distribution',
                    'probability_space': 'This path unavailable',
                    'information': 'Try different node',
                    'w_implication': 'This configuration impossible'
                },
                
                'permission_no': {
                    'signal': 'Authorization failed',
                    'constraint_type': 'Access control',
                    'probability_space': 'This action forbidden',
                    'information': 'Need different credentials',
                    'w_implication': 'Configuration space restricted by policy'
                },
                
                'capacity_no': {
                    'signal': 'System at limit',
                    'constraint_type': 'Resource exhaustion',
                    'probability_space': 'No room for more',
                    'information': 'System boundaries reached',
                    'w_implication': 'Maximum W reached for this substrate'
                }
            },
            
            'universal_pattern': {
                'all_nos': 'Signal reduced probability space',
                'connection_to_511': 'R = P_prev ∧ ¬P_curr (constraint detector)',
                'connection_to_800': 'W reduced (configuration space collapsed)',
                'value': 'Every NO gives information about system boundaries',
                'computation': 'Collect NOs, derive constraints, detect patterns'
            }
        }

class NOInSeries:
    """
    How NOs flow through iR³Series
    """
    def __init__(self):
        self.series = iR3Series()
        self.dht = iR3DHT()
        
        # Register NO handler
        self.dht.on_p2p_response(self._handle_response)
    
    def request_chunk(self, chunk_id):
        """Request chunk (pure flux)"""
        # Push intent
        self.dht.push_intent({
            'intent': 'want_chunk',
            'chunk_id': chunk_id,
            'from': self.address
        })
        
        # Append request to series
        self.series.append({
            'event': 'chunk_requested',
            'chunk_id': chunk_id,
            'timestamp': time.time()
        })
        
        # Return immediately (no waiting)
        return
    
    def _handle_response(self, response):
        """Handle any response (YES or NO)"""
        if response['status'] == 'YES':
            # Append YES as data
            self.series.append({
                'event': 'chunk_received',
                'chunk_id': response['chunk_id'],
                'data': response['data'],
                'from': response['from'],
                'timestamp': time.time()
            })
        
        elif response['status'] == 'NO':
            # Append NO as data (NOT exception!)
            self.series.append({
                'event': 'chunk_denied',
                'chunk_id': response['chunk_id'],
                'reason': response['reason'],
                'from': response['from'],
                'retry_after': response.get('retry_after'),
                'suggestions': response.get('suggested_nodes', []),
                'timestamp': time.time()
            })
        
        # Both YES and NO are just data!
        # No exceptions, no errors, just events in series
    
    def derive_chunk_status(self, chunk_id):
        """Derive status by reducing series"""
        events = [e for e in self.series if e.get('chunk_id') == chunk_id]
        
        # Analyze pattern
        yes_count = len([e for e in events if e['event'] == 'chunk_received'])
        no_count = len([e for e in events if e['event'] == 'chunk_denied'])
        
        if yes_count > 0:
            return {'status': 'HAVE', 'source': events[-1]['from']}
        
        if no_count > 0:
            # Analyze NOs for pattern
            reasons = [e['reason'] for e in events if e['event'] == 'chunk_denied']
            
            if 'rate_limited' in reasons:
                return {
                    'status': 'TEMPORARILY_UNAVAILABLE',
                    'retry_after': min(e.get('retry_after', 60) for e in events if e.get('retry_after')),
                    'constraint': 'Rate limit active'
                }
            
            if all(r == 'dont_have' for r in reasons):
                return {
                    'status': 'NOT_IN_NETWORK',
                    'tried_nodes': len(set(e['from'] for e in events)),
                    'suggestions': list(set(sum([e.get('suggestions', []) for e in events], []))),
                    'constraint': 'Chunk not stored anywhere queried'
                }
        
        return {
            'status': 'UNKNOWN',
            'request_pending': True
        }

class ConstraintDetectionViaNO:
    """
    Detect probability space collapse from NO responses
    """
    def __init__(self):
        self.series = iR3Series()
    
    def detect_constraint(self, action):
        """
        Detect if probability space has collapsed
        From Post 511: R = P_prev ∧ ¬P_curr
        """
        # Was this action possible before?
        past_events = self._get_past_attempts(action)
        p_prev = any(e['status'] == 'YES' for e in past_events if e['timestamp'] < time.time() - 3600)
        
        # Is this action possible now?
        recent_events = self._get_recent_attempts(action)
        p_curr = any(e['status'] == 'YES' for e in recent_events)
        
        # Constraint detected if was possible, now impossible
        r = p_prev and not p_curr
        
        if r:
            # Append constraint detection to series
            self.series.append({
                'event': 'constraint_detected',
                'action': action,
                'was_possible': p_prev,
                'now_possible': p_curr,
                'alarm': True,
                'timestamp': time.time()
            })
            
            return {
                'constraint_detected': True,
                'message': f'Probability space collapsed for {action}',
                'evidence': recent_events
            }
        
        return {'constraint_detected': False}
    
    def _get_past_attempts(self, action):
        """Get historical attempts from Series"""
        return [e for e in self.series 
                if e.get('action') == action 
                and e['timestamp'] < time.time() - 3600]
    
    def _get_recent_attempts(self, action):
        """Get recent attempts from Series"""
        return [e for e in self.series 
                if e.get('action') == action 
                and e['timestamp'] >= time.time() - 300]

class NOAndW:
    """
    Connection between NO responses and W framework
    """
    def the_connection(self):
        return {
            'w_definition': {
                'from_post_800': 'W = configuration space',
                'interpretation': 'W = number of possible futures/states',
                'high_w': 'Many configurations possible',
                'low_w': 'Few configurations possible',
                'w_zero': 'No configurations possible (dead)'
            },
            
            'no_signals_reduced_w': {
                'yes_response': {
                    'meaning': 'Configuration possible',
                    'w_impact': 'Path available',
                    'probability_space': 'Open'
                },
                
                'no_response': {
                    'meaning': 'Configuration impossible',
                    'w_impact': 'Path closed',
                    'probability_space': 'Constrained',
                    'information': 'Boundary of configuration space discovered'
                },
                
                'pattern_of_nos': {
                    'many_nos': 'Configuration space very limited',
                    'few_nos': 'Configuration space mostly open',
                    'all_nos': 'W approaching zero for this action',
                    'some_yes': 'W still positive, paths exist'
                }
            },
            
            'w_computation_from_nos': {
                'formula': 'W ≈ Σ(YES_responses) / Σ(total_responses)',
                'interpretation': 'Ratio of possible to attempted configurations',
                'declining_w': 'More NOs over time → constraint increasing',
                'increasing_w': 'More YESes over time → liberation',
                'from_post_511': 'R fires when W declining (P_prev > P_curr)'
            },
            
            'ethical_implication': {
                'from_post_800': 'Goal = maximize total W',
                'when_nos_increase': 'System W declining',
                'should': 'Identify source of constraints',
                'action': 'Remove constraints to restore W',
                'or': 'Accept constraint if necessary trade-off',
                'no_data_enables': 'Explicit W optimization'
            }
        }

class PracticalNOExamples:
    """
    Real scenarios using NO computation
    """
    def example_rate_limiting(self):
        """
        Scenario: Node rate limiting
        """
        return {
            'situation': 'Requesting chunks from node',
            
            'series_events': [
                {'t': 0, 'event': 'chunk_requested', 'chunk': 'A'},
                {'t': 1, 'event': 'chunk_received', 'chunk': 'A', 'from': 'node1'},  # YES
                {'t': 2, 'event': 'chunk_requested', 'chunk': 'B'},
                {'t': 3, 'event': 'chunk_received', 'chunk': 'B', 'from': 'node1'},  # YES
                {'t': 4, 'event': 'chunk_requested', 'chunk': 'C'},
                {'t': 5, 'event': 'chunk_denied', 'chunk': 'C', 'from': 'node1', 'reason': 'rate_limited', 'retry_after': 60},  # NO
                {'t': 6, 'event': 'chunk_requested', 'chunk': 'D'},
                {'t': 7, 'event': 'chunk_denied', 'chunk': 'D', 'from': 'node1', 'reason': 'rate_limited', 'retry_after': 59},  # NO
            ],
            
            'computation': {
                'p_prev': True,  # Was able to get chunks (A, B successful)
                'p_curr': False,  # Now cannot get chunks (C, D denied)
                'r': True,  # Constraint detected!
                'interpretation': 'Rate limit activated - probability space collapsed',
                'w_impact': 'W reduced for chunk access via node1',
                'action': 'Wait 60s OR try different node'
            },
            
            'value_of_no': {
                'learned': 'Rate limit is 2 chunks per time window',
                'learned': 'Retry after 60 seconds',
                'learned': 'node1 enforces constraints',
                'enables': 'Optimize request pattern to avoid limits',
                'enables': 'Try alternative nodes',
                'no_blocking': 'Learned this without blocking any threads'
            }
        }
    
    def example_network_partition(self):
        """
        Scenario: Network partitioning
        """
        return {
            'situation': 'Minting money across network',
            
            'series_events': [
                {'t': 0, 'event': 'mint_requested', 'currency': 'USD', 'amount': 100},
                {'t': 1, 'event': 'mint_accepted', 'from': 'validator1'},  # YES
                {'t': 1, 'event': 'mint_accepted', 'from': 'validator2'},  # YES
                {'t': 1, 'event': 'mint_accepted', 'from': 'validator3'},  # YES
                # Network partition happens
                {'t': 60, 'event': 'mint_requested', 'currency': 'USD', 'amount': 100},
                {'t': 61, 'event': 'mint_timeout', 'from': 'validator1'},  # NO (timeout)
                {'t': 61, 'event': 'mint_denied', 'from': 'validator2', 'reason': 'cannot_reach_quorum'},  # NO
                {'t': 61, 'event': 'mint_timeout', 'from': 'validator3'},  # NO (timeout)
            ],
            
            'computation': {
                'p_prev': True,  # Could mint before (3 acceptances)
                'p_curr': False,  # Cannot mint now (all denied/timeout)
                'r': True,  # Constraint detected!
                'interpretation': 'Network partition - quorum impossible',
                'w_impact': 'W drastically reduced (coordination broken)',
                'urgency': 'High - system fractured'
            },
            
            'value_of_no': {
                'learned': 'Network is partitioned',
                'learned': 'Validators cannot reach each other',
                'learned': 'Consensus impossible currently',
                'enables': 'Wait for partition healing',
                'enables': 'Alert operators to issue',
                'no_blocking': 'Immediate detection via NO pattern'
            }
        }

class NOPatternDetection:
    """
    Aggregate NOs to understand system
    """
    def analyze_no_pattern(self, series):
        """
        Reduce series to detect constraint patterns
        """
        # Collect all responses
        responses = [e for e in series if e['event'] in ['chunk_received', 'chunk_denied']]
        
        # Group by node
        by_node = {}
        for r in responses:
            node = r.get('from')
            if node not in by_node:
                by_node[node] = {'yes': 0, 'no': 0, 'reasons': []}
            
            if r['event'] == 'chunk_received':
                by_node[node]['yes'] += 1
            else:
                by_node[node]['no'] += 1
                by_node[node]['reasons'].append(r.get('reason'))
        
        # Analyze each node
        analysis = {}
        for node, counts in by_node.items():
            total = counts['yes'] + counts['no']
            no_ratio = counts['no'] / total if total > 0 else 0
            
            analysis[node] = {
                'yes_count': counts['yes'],
                'no_count': counts['no'],
                'no_ratio': no_ratio,
                'w_estimate': 1 - no_ratio,  # W ≈ YES ratio
                'status': self._classify_node(no_ratio, counts['reasons']),
                'constraint_type': self._identify_constraint(counts['reasons'])
            }
        
        return analysis
    
    def _classify_node(self, no_ratio, reasons):
        """Classify node based on NO pattern"""
        if no_ratio == 0:
            return 'FULLY_AVAILABLE'
        elif no_ratio < 0.3:
            return 'MOSTLY_AVAILABLE'
        elif no_ratio < 0.7:
            return 'PARTIALLY_CONSTRAINED'
        elif no_ratio < 1.0:
            return 'HEAVILY_CONSTRAINED'
        else:
            return 'UNAVAILABLE'
    
    def _identify_constraint(self, reasons):
        """Identify constraint type from NO reasons"""
        if not reasons:
            return None
        
        reason_counts = {}
        for r in reasons:
            reason_counts[r] = reason_counts.get(r, 0) + 1
        
        primary_reason = max(reason_counts, key=reason_counts.get)
        
        constraint_types = {
            'rate_limited': 'BANDWIDTH_CONSTRAINT',
            'dont_have': 'DATA_DISTRIBUTION_CONSTRAINT',
            'permission_denied': 'ACCESS_CONTROL_CONSTRAINT',
            'capacity_full': 'RESOURCE_CONSTRAINT',
            'timeout': 'NETWORK_CONSTRAINT'
        }
        
        return constraint_types.get(primary_reason, 'UNKNOWN_CONSTRAINT')

class UniversalNOFramework:
    """
    Complete framework summary
    """
    def the_framework(self):
        return {
            'from_post_878_pure_flux': {
                'paradigm': 'Push-only, immediate returns',
                'no_blocking': 'Never wait for responses',
                'yes_and_no': 'Both valid data, not error vs success',
                'append_all': 'Everything goes to Series',
                'derive_state': 'Reduce Series to understand current state'
            },
            
            'from_post_511_constraint_detection': {
                'formula': 'R = P_prev ∧ ¬P_curr',
                'meaning': 'Detect probability space collapse',
                'p_prev': 'Was action possible? (YES responses in past)',
                'p_curr': 'Is action possible now? (YES responses currently)',
                'r': 'Constraint alarm fires when was-possible-now-impossible'
            },
            
            'from_post_800_w_framework': {
                'w_definition': 'W = configuration space',
                'no_signal': 'NO = configuration impossible = reduced W',
                'yes_signal': 'YES = configuration possible = W available',
                'w_measurement': 'W ≈ YES_count / total_responses',
                'goal': 'Maximize total W (maximize YES ratio)'
            },
            
            'universal_no_computation': {
                'step_1': 'Push intents via DHT (immediate)',
                'step_2': 'Receive YES/NO via P2P (async)',
                'step_3': 'Append all to Series (valid data)',
                'step_4': 'Derive state by reduction (pattern detection)',
                'step_5': 'Detect constraints (R = P_prev ∧ ¬P_curr)',
                'step_6': 'Measure W (YES ratio)',
                'step_7': 'Optimize (maximize W, remove constraints)'
            },
            
            'key_insights': {
                'no_is_data': 'Not error, not exception, just information',
                'no_signals_boundary': 'Tells you about system limits',
                'no_enables_optimization': 'Can optimize if you measure',
                'no_is_immediate': 'Pure flux = no blocking on NO',
                'no_is_valuable': 'Every NO teaches about constraints',
                'no_is_universal': 'Same computation across all domains'
            }
        }

# Universal NO computation
def universal_no_computation():
    # 1. Push (no blocking)
    dht.push_intent(intent)
    
    # 2. Append (immediate)
    series.append({'event': 'intent_pushed'})
    
    # 3. Responses flow in (async)
    @on_p2p_response
    def handle(response):
        # YES and NO both valid
        series.append(response)
    
    # 4. Derive state (anytime)
    state = series.derive_state()
    
    # 5. Detect constraints (Post 511)
    r = p_prev and not p_curr
    if r:
        alarm('Constraint detected!')
    
    # 6. Measure W (Post 800)
    w = yes_count / total_responses
    
    # 7. Optimize
    maximize(w)