class ChoiceLayers:
    """
    Breaking down what looks like a choice
    """
    def the_layers(self):
        return {
            'layer_1_instinct': {
                'what': 'Automatic hardwired responses',
                'mechanism': 'Evolved neural patterns',
                'conscious': 'No (completely automatic)',
                'speed': 'Instant (milliseconds)',
                'modifiable': 'No (except via evolution)',
                'example': 'Movement triggers attack response',
                'contribution': 'Base automatic behavior'
            },
            
            'layer_2_optimization': {
                'what': 'Energy cost/benefit calculation',
                'mechanism': 'W-maximization (survival value)',
                'conscious': 'No (but looks intelligent)',
                'speed': 'Fast (seconds)',
                'modifiable': 'Somewhat (learning)',
                'example': 'Butterfly = high protein, low effort',
                'contribution': 'Selects optimal from triggered options'
            },
            
            'layer_3_consciousness': {
                'what': 'Subjective experience? Free will?',
                'mechanism': 'Unknown (consciousness mystery)',
                'conscious': '? (we cannot know for animals)',
                'speed': '? (if exists)',
                'modifiable': '? (depends on nature)',
                'example': 'Does lizard "experience" wanting butterfly?',
                'contribution': 'Unknown (possibly nothing, possibly everything)'
            },
            
            'the_combination': {
                'formula': 'Apparent_choice = f(Instinct, Optimization, Consciousness?)',
                'result': 'Behavior that looks like decision',
                'observer_sees': 'Lizard "chooses" butterfly',
                'reality': 'Layered automatic + optimized + ? process',
                'key': 'Choice may be illusion of emergence'
            }
        }

class InstinctLayer:
    """
    Automatic responses evolved over time
    """
    def instinct_mechanics(self):
        return {
            'what_is_instinct': {
                'definition': 'Hardwired neural response patterns',
                'origin': 'Evolved over millions of years',
                'modification': 'Only via evolution (slow)',
                'conscious_access': 'None (happens automatically)',
                'example': 'See movement → Attack reflex'
            },
            
            'lizard_butterfly_instinct': {
                'trigger': 'Movement in visual field',
                'response': 'Orient toward movement',
                'pattern': 'Size matches prey range',
                'action': 'Attack sequence initiated',
                'all_automatic': 'No thought required',
                'fast': 'Milliseconds from trigger to action'
            },
            
            'why_this_exists': {
                'evolutionary_pressure': 'Fast response = survival',
                'slow_thinkers': 'Got eaten',
                'fast_reactors': 'Survived, reproduced',
                'result': 'Instinct hardwired into brain',
                'benefit': 'No computation time needed'
            },
            
            'not_choice': {
                'claim': 'Instinct is not choice',
                'reason': 'No alternatives considered',
                'mechanism': 'Trigger → Response (automatic)',
                'like': 'Knee-jerk reflex',
                'key': 'Zero conscious involvement'
            },
            
            'but_looks_like_choice': {
                'observer_sees': 'Lizard attacks butterfly',
                'observer_thinks': '"Lizard chose to attack"',
                'reality': 'Automatic trigger-response',
                'illusion': 'Agency where none exists',
                'contribution_to_apparent_choice': '~40% of behavior'
            }
        }

class OptimizationLayer:
    """
    Automatic optimization (looks intelligent but isn't conscious)
    """
    def optimization_mechanics(self):
        return {
            'what_is_optimization': {
                'definition': 'Automatic cost/benefit calculation',
                'mechanism': 'Evolved value functions',
                'maximizes': 'W (survival/reproduction probability)',
                'conscious': 'No (but adaptive)',
                'example': 'Choose prey with best energy return'
            },
            
            'lizard_butterfly_optimization': {
                'inputs': {
                    'butterfly_size': 'Energy content estimate',
                    'distance': 'Energy cost to catch',
                    'speed': 'Success probability',
                    'competition': 'Will others get it first?',
                    'satiation': 'How hungry am I?'
                },
                'calculation': 'Expected_value = Energy_gain × P(success) - Energy_cost',
                'comparison': 'Compare to other visible prey',
                'decision': 'Attack if Expected_value > threshold',
                'all_automatic': 'No conscious math happening'
            },
            
            'why_butterfly_wins': {
                'vs_fly': 'Butterfly bigger (more energy) but slower (higher P(success))',
                'vs_cricket': 'Butterfly more visible, easier target',
                'vs_beetle': 'Butterfly softer, easier to digest',
                'result': 'Butterfly often optimal choice',
                'not_conscious': 'Lizard doesn\'t "know" this - just evolved to prefer optimal'
            },
            
            'how_this_evolved': {
                'lizards_that_optimized': 'Got more energy',
                'more_energy': 'Better survival/reproduction',
                'over_generations': 'Optimization circuits evolved',
                'result': 'Built-in value functions',
                'key': 'Optimization without consciousness'
            },
            
            'looks_like_choice': {
                'observer_sees': 'Lizard evaluates options, picks butterfly',
                'observer_thinks': '"Lizard made smart choice"',
                'reality': 'Automatic optimization calculation',
                'intelligence': 'Yes (but not conscious)',
                'contribution_to_apparent_choice': '~50% of behavior'
            }
        }

class ConsciousnessLayer:
    """
    Do animals have subjective experience? Free will?
    """
    def consciousness_question(self):
        return {
            'the_hard_problem': {
                'question': 'Does lizard experience wanting butterfly?',
                'or': 'Is it just automatic processes (Layers 1+2)?',
                'we_cannot_know': 'No way to access lizard subjective experience',
                'philosophical': 'Hard problem of consciousness',
                'unresolved': 'No scientific consensus'
            },
            
            'possibilities': {
                'option_1_no_consciousness': {
                    'claim': 'Lizard is philosophical zombie',
                    'mechanism': 'Only Layers 1+2 (instinct + optimization)',
                    'experience': 'None (lights are off)',
                    'choice': 'Completely illusory',
                    'behavior': 'Identical to conscious version',
                    'problem': 'Cannot disprove'
                },
                'option_2_some_consciousness': {
                    'claim': 'Lizard has basic awareness',
                    'mechanism': 'Layers 1+2 + minimal qualia',
                    'experience': 'Dim sensation of hunger, success',
                    'choice': 'Mostly automatic, slight consciousness',
                    'behavior': 'Guided by feeling',
                    'problem': 'Cannot prove, cannot quantify'
                },
                'option_3_full_consciousness': {
                    'claim': 'Lizard is conscious like humans',
                    'mechanism': 'Layers 1+2 + rich subjective experience',
                    'experience': 'Vivid wanting, deciding, satisfaction',
                    'choice': 'Real free will',
                    'behavior': 'Consciously chosen',
                    'problem': 'Seems anthropomorphic'
                }
            },
            
            'we_project': {
                'observation': 'When we see lizard attack butterfly',
                'we_assume': 'Lizard experiences like we do',
                'reason': 'Only have access to our own consciousness',
                'projection': 'Assume others similar',
                'problem': 'No way to verify',
                'result': 'Cannot know consciousness contribution'
            },
            
            'contribution_unknown': {
                'if_option_1': 'Layer 3 contributes 0%',
                'if_option_2': 'Layer 3 contributes ~10%',
                'if_option_3': 'Layer 3 contributes ~40%',
                'reality': 'Unknown and unknowable',
                'estimate': '~10% (but pure guess)',
                'key': 'Cannot measure consciousness'
            }
        }

class ChoiceFormula:
    """
    How layers combine to produce apparent choice
    """
    def the_formula(self):
        return {
            'apparent_choice': {
                'what_we_see': 'Animal "chooses" to do X',
                'components': [
                    'Layer 1: Instinct (automatic trigger-response)',
                    'Layer 2: Optimization (automatic value calculation)',
                    'Layer 3: Consciousness (unknown contribution)'
                ],
                'formula': 'Choice_apparent = f(I, O, C?)',
                'where': {
                    'I': 'Instinct contribution (~40%)',
                    'O': 'Optimization contribution (~50%)',
                    'C': 'Consciousness contribution (0-40%, unknown)'
                }
            },
            
            'lizard_butterfly_example': {
                'instinct_40': 'Movement triggers attack',
                'optimization_50': 'Butterfly optimal energy/effort',
                'consciousness_10': 'Maybe dim experience of hunger',
                'sum': '40% + 50% + 10% = 100% apparent choice',
                'observer_sees': 'Lizard chooses butterfly',
                'reality': 'Emergent from automatic + optimized + ?'
            },
            
            'key_insight': {
                'choice_is_emergent': 'Not single decision process',
                'multiple_layers': 'Each contributing',
                'most_automatic': '90% instinct + optimization',
                'consciousness_small': 'If present at all',
                'illusion': 'Looks like unified choice',
                'reality': 'Layered automatic processes'
            },
            
            'applies_to_all_animals': {
                'birds': 'Choose seeds (instinct + optimization + ?)',
                'fish': 'Choose direction (instinct + optimization + ?)',
                'mammals': 'Choose mates (instinct + optimization + ?)',
                'insects': 'Choose flowers (instinct + optimization + 0?)',
                'pattern': 'Same formula, different weights',
                'consciousness': 'Varies by species (probably)'
            }
        }

class HumanChoiceParallel:
    """
    Do humans have fundamentally different choice mechanism?
    """
    def human_vs_animal(self):
        return {
            'uncomfortable_possibility': {
                'claim': 'Human choice = same formula',
                'formula': 'Human_choice = f(Instinct, Optimization, Consciousness?)',
                'difference': 'Only in weights/complexity',
                'humans': 'Instinct (20%) + Optimization (30%) + Consciousness? (50%)',
                'animals': 'Instinct (40%) + Optimization (50%) + Consciousness? (10%)',
                'key': 'Same mechanism, different proportions'
            },
            
            'human_instinct_examples': {
                'trigger_response': 'Jump at loud noise (automatic)',
                'preferences': 'Sweet food tastes good (evolved)',
                'emotions': 'Fear of heights (survival instinct)',
                'reflexes': 'Pull hand from hot surface',
                'all_automatic': 'Like animal instinct, just more complex'
            },
            
            'human_optimization_examples': {
                'career_choice': 'Maximize income/status (W)',
                'mate_selection': 'Optimize attractiveness/compatibility',
                'food_choice': 'Taste/nutrition/cost optimization',
                'social_decisions': 'Maximize social standing',
                'all_calculated': 'Like animal optimization, but conscious of it'
            },
            
            'human_consciousness_difference': {
                'self_awareness': 'We know we\'re choosing',
                'deliberation': 'Can think about thinking',
                'override': 'Sometimes override instinct/optimization',
                'language': 'Can describe experience',
                'but': 'Does this change the mechanism?',
                'or': 'Just makes us aware of automatic process?'
            },
            
            'the_question': {
                'are_human_choices': 'Qualitatively different from animal?',
                'or': 'Just same formula with higher consciousness%?',
                'free_will': 'Do humans have it if animals don\'t?',
                'or': 'Same emergent phenomenon, just more complex?',
                'uncomfortable': 'Maybe no fundamental difference'
            }
        }

class ChoiceAsEmergence:
    """
    Choice emerges from layered processes
    """
    def emergence_explanation(self):
        return {
            'emergence_defined': {
                'what': 'Higher-level phenomenon from lower-level interactions',
                'example': 'Wetness emerges from H₂O molecules',
                'key': 'Properties at higher level not in components',
                'here': 'Choice emerges from instinct + optimization + ?'
            },
            
            'choice_emergence': {
                'component_1': 'Instinct (no choice, automatic)',
                'component_2': 'Optimization (no choice, calculated)',
                'component_3': 'Consciousness (unknown)',
                'interaction': 'Components interact',
                'emerges': '"Choice" as higher-level phenomenon',
                'key': 'Choice not in any single component'
            },
            
            'why_looks_unified': {
                'observer_perspective': 'We see behavior, not mechanism',
                'behavior_coherent': 'Lizard attacks butterfly (one action)',
                'mechanism_multiple': 'Many processes produced action',
                'brain_integrates': 'Combines inputs → single output',
                'appears': 'Unified decision',
                'actually': 'Emergent from layers'
            },
            
            'no_choice_module': {
                'not_in_brain': 'No "decision center"',
                'instead': 'Distributed processes',
                'each_layer': 'Contributes to final action',
                'integration': 'Happens automatically',
                'result': 'Behavior that looks chosen',
                'reality': 'Emergent from automatic processes'
            },
            
            'philosophical_implications': {
                'free_will': 'May be emergent illusion',
                'consciousness': 'May not "cause" choice',
                'instead': 'Accompanies automatic processes',
                'we_feel': 'We are choosing',
                'actually': 'Automatic layers producing behavior + consciousness observing',
                'uncomfortable': 'No "decider" - just emergence'
            }
        }

class WhyThisMatters:
    """
    Implications of deconstructed choice
    """
    def implications(self):
        return {
            'for_understanding_animals': {
                'stop_anthropomorphizing': 'Don\'t project human consciousness',
                'recognize_automation': 'Most behavior is automatic',
                'appreciate_optimization': 'Intelligence without consciousness',
                'humility': 'We don\'t know their experience',
                'result': 'Better understanding of animal behavior'
            },
            
            'for_understanding_humans': {
                'recognize_automatic': 'Much of our "choice" automatic too',
                'instinct_still_there': 'Evolved responses guide us',
                'optimization_constant': 'Always calculating W-max',
                'consciousness_observer': 'Maybe just witnessing automatic processes',
                'result': 'Humility about free will'
            },
            
            'for_ai_development': {
                'dont_need_consciousness': 'Can build intelligent systems with Layers 1+2',
                'optimization_sufficient': 'W-maximization produces adaptive behavior',
                'consciousness_unknown': 'Don\'t know how to add Layer 3',
                'current_ai': 'Layer 2 only (optimization)',
                'result': 'Intelligent behavior without consciousness (like animals?)'
            },
            
            'for_ethics': {
                'animal_suffering': 'Unknown if animals experience (Layer 3)',
                'precautionary_principle': 'Assume they might',
                'human_responsibility': 'Even if automatic, still conscious?',
                'moral_status': 'Depends on consciousness weight',
                'result': 'Ethics complicated by uncertainty'
            },
            
            'for_self_understanding': {
                'examine_your_choices': 'How much is automatic?',
                'instinct_recognition': 'Notice triggered responses',
                'optimization_awareness': 'See cost/benefit calculations',
                'consciousness_role': 'What does awareness add?',
                'result': 'Deeper self-knowledge'
            }
        }

class SeparatingLayers:
    """
    Can we isolate each layer's contribution?
    """
    def isolation_attempts(self):
        return {
            'isolating_instinct': {
                'method': 'Observe reflexes (no time for optimization)',
                'example': 'Lizard tongue flicks at moving dot',
                'too_fast': 'No optimization calculation',
                'pure_instinct': 'Automatic trigger-response',
                'observable': 'Yes (study reflexes)',
                'contribution': '~40% baseline'
            },
            
            'isolating_optimization': {
                'method': 'Vary prey options, measure preferences',
                'example': 'Offer different size/speed prey',
                'prediction': 'Choose optimal energy/effort ratio',
                'observed': 'Animals do optimize',
                'not_instinct': 'Can override simple triggers',
                'observable': 'Yes (controlled experiments)',
                'contribution': '~50% adaptive behavior'
            },
            
            'isolating_consciousness': {
                'method': '??? (unknown)',
                'problem': 'Cannot measure subjective experience',
                'attempts': [
                    'Mirror test (self-awareness)',
                    'Tool use (planning)',
                    'Communication (reporting experience)'
                ],
                'limitations': 'All indirect, ambiguous',
                'observable': 'No (hard problem)',
                'contribution': '? (unknowable)'
            },
            
            'the_difficulty': {
                'layers_interact': 'Cannot fully separate',
                'behavior_integrated': 'Single output from multiple inputs',
                'consciousness_invisible': 'No direct measurement',
                'best_we_can_do': 'Estimate contributions',
                'uncertainty': 'Especially for Layer 3'
            }
        }