class SocialGraph:
    """
    Community = nodes + weighted edges
    """
    def __init__(self):
        self.nodes = people_in_community()
        self.edges = relationships_between_people()
        
    def edge_weight(self, person_a, person_b):
        """
        How easily they can coordinate
        """
        return {
            'trust': 'Mutual confidence level',
            'access': 'Resources shared',
            'communication': 'Information flow',
            'coordination_ease': 'How easily they work together',
            'w_contribution': 'Value created by connection'
        }

class GraphW:
    """
    W (configuration space) determined by graph position
    """
    def calculate_w(self, person):
        # Sum of all edge weights
        total_weight = sum(
            edge.weight 
            for edge in person.connections
        )
        
        # Network effects
        n_connections = len(person.connections)
        network_value = n_connections ** 2
        
        # Combined W
        w_total = total_weight * network_value
        
        return {
            'w': w_total,
            'depends_on': 'Graph position + edge weights',
            'high_w': 'Well connected, strong edges',
            'low_w': 'Peripheral, weak edges',
            'zero_w': 'Only if completely isolated (imprisonment)'
        }

class CrimeAppreciation:
    """
    Community collectively evaluates severity
    """
    def appreciate(self, crime):
        # Community members evaluate
        evaluations = []
        for member in community.members:
            severity = member.evaluate_severity(crime)
            harm = member.evaluate_harm(crime)
            context = member.consider_context(crime)
            
            evaluation = {
                'severity': severity,
                'harm': harm,
                'context': context,
                'suggested_adjustment': self.calculate_adjustment(
                    severity, harm, context
                )
            }
            evaluations.append(evaluation)
        
        # Aggregate (median or mode, not mean)
        community_appreciation = aggregate(evaluations)
        
        return {
            'severity': community_appreciation.severity,
            'harm_level': community_appreciation.harm,
            'context': community_appreciation.context,
            'graph_adjustment': community_appreciation.adjustment
        }

crime_appreciations = {
    'minor_theft': {
        'community_severity': 'Low',
        'harm': 'Small financial loss',
        'context': 'Desperation? Malice?',
        'graph_adjustment': 'Slight edge weakening (10-20%)',
        'duration': 'Short (weeks to months)'
    },
    
    'fraud': {
        'community_severity': 'Medium',
        'harm': 'Trust violation + financial',
        'context': 'Intentional deception',
        'graph_adjustment': 'Moderate weakening (30-50%)',
        'duration': 'Medium (months to year)'
    },
    
    'violence': {
        'community_severity': 'High',
        'harm': 'Physical + psychological',
        'context': 'Threat to safety',
        'graph_adjustment': 'Significant weakening (60-80%)',
        'duration': 'Long (years, but recoverable)'
    },
    
    'murder': {
        'community_severity': 'Maximum',
        'harm': 'Irreversible (death)',
        'context': 'Permanent loss',
        'graph_adjustment': 'Heavy weakening (80-95%)',
        'duration': 'Extended (years, gradual recovery)'
    }
}

class GraphReorganization:
    """
    Community adjusts criminal's graph position
    """
    def reorganize(self, criminal, crime_appreciation):
        # Calculate reduction factor
        reduction = crime_appreciation.graph_adjustment
        # e.g., 0.7 = 70% weakening
        
        # Weaken all edges from criminal
        for edge in criminal.connections:
            edge.old_weight = edge.weight
            edge.new_weight = edge.weight * (1 - reduction)
            edge.update_weight(edge.new_weight)
            
        # Move toward periphery
        old_position = criminal.graph_position
        new_position = move_toward_periphery(
            old_position, 
            reduction
        )
        
        return {
            'before': {
                'position': 'Central or mid-graph',
                'avg_edge_weight': 'High',
                'w': 'High (easy coordination)'
            },
            'after': {
                'position': 'Peripheral (but still in graph)',
                'avg_edge_weight': 'Reduced',
                'w': 'Lower (harder coordination)'
            },
            'still_possible': True,
            'recovery_path': 'Exists'
        }

graph_transformation = {
    'before_crime': {
        'connections': 100,
        'avg_weight': 0.8,
        'total_weight': 80,
        'w': '100² × 80 = 800,000',
        'position': 'Central'
    },
    
    'after_serious_crime': {
        'connections': 100,  # Still connected
        'avg_weight': 0.2,   # Reduced by 75%
        'total_weight': 20,
        'w': '100² × 20 = 200,000',
        'position': 'Peripheral'
    },
    
    'comparison': {
        'w_lost': '600,000 (75% reduction)',
        'w_remaining': '200,000 (25% maintained)',
        'vs_imprisonment': '200,000 vs ~0',
        'better': 'Graph justice (W > 0)'
    }
}

class HarderProgress:
    """
    Reduced edge weights = harder coordination
    """
    def effects(self, criminal_with_weak_edges):
        return {
            'economic': {
                'before': 'Easy to find work (trusted)',
                'after': 'Harder (less trust)',
                'still_possible': 'Yes (some trust remains)',
                'path': 'Prove reliability over time'
            },
            
            'social': {
                'before': 'Easy to make plans (welcomed)',
                'after': 'Harder (hesitation from others)',
                'still_possible': 'Yes (connections exist)',
                'path': 'Rebuild through good behavior'
            },
            
            'resources': {
                'before': 'Easy access (high trust)',
                'after': 'Harder (reduced access)',
                'still_possible': 'Yes (partial access)',
                'path': 'Demonstrate responsibility'
            },
            
            'coordination': {
                'before': 'Easy (high edge weights)',
                'after': 'Harder (low edge weights)',
                'still_possible': 'Yes (edges exist)',
                'path': 'Consistent positive actions'
            }
        }

difficulty_gradient = {
    'immediately_after': {
        'edge_weights': 'Minimum (post-crime)',
        'difficulty': 'Maximum',
        'w': 'Minimum (but > 0)',
        'message': 'Community disapproves'
    },
    
    'weeks_later': {
        'edge_weights': 'Starting to recover',
        'difficulty': 'High but improving',
        'w': 'Growing',
        'message': 'Progress acknowledged'
    },
    
    'months_later': {
        'edge_weights': 'Significant recovery',
        'difficulty': 'Medium',
        'w': 'Approaching original',
        'message': 'Rehabilitation recognized'
    },
    
    'years_later': {
        'edge_weights': 'Nearly or fully restored',
        'difficulty': 'Normal',
        'w': 'Restored',
        'message': 'Reintegrated'
    }
}

class EdgeRecovery:
    """
    Positive actions rebuild edge weights
    """
    def strengthen_edge(self, criminal, community_member, action):
        # Positive action observed
        if action.is_positive():
            # Increase edge weight slightly
            edge = get_edge(criminal, community_member)
            
            old_weight = edge.weight
            increase = calculate_increase(action)
            new_weight = min(
                old_weight + increase,
                original_weight  # Cap at original
            )
            
            edge.update_weight(new_weight)
            
        return {
            'action': action,
            'effect': 'Edge weight increased',
            'cumulative': 'Many actions → full recovery',
            'message': 'Positive behavior rewarded'
        }

recovery_actions = {
    'restitution_payment': {
        'action': 'Pay victim compensation',
        'edge_increase': 'Significant (5-10%)',
        'signal': 'Taking responsibility'
    },
    
    'apology': {
        'action': 'Genuine public apology',
        'edge_increase': 'Moderate (2-5%)',
        'signal': 'Acknowledgment of harm'
    },
    
    'community_service': {
        'action': 'Help community members',
        'edge_increase': 'Small per action (0.5-1%)',
        'signal': 'Contributing positively'
    },
    
    'skill_building': {
        'action': 'Learn valuable skills',
        'edge_increase': 'Moderate (3-7%)',
        'signal': 'Self-improvement'
    },
    
    'consistent_honesty': {
        'action': 'Reliable over time',
        'edge_increase': 'Gradual (0.1% daily)',
        'signal': 'Trustworthy behavior'
    }
}

comparison = {
    'imprisonment': {
        'mechanism': 'Remove from graph (isolate)',
        'w_effect': 'Reduced to ~0',
        'recovery': 'None (during imprisonment)',
        'post_release': 'Difficulty reintegrating',
        'recidivism': 'High (67% within 3 years)',
        'cost': '$35,000/year',
        'message': 'You are excluded'
    },
    
    'graph_justice': {
        'mechanism': 'Weaken edges (reduce access)',
        'w_effect': 'Reduced but > 0',
        'recovery': 'Continuous (via positive actions)',
        'incentive': 'Every good action helps',
        'recidivism': 'Low (path to reintegration clear)',
        'cost': 'Minimal (software + monitoring)',
        'message': 'You can recover'
    },
    
    'advantage': {
        'w_preservation': 'Graph justice maintains W > 0',
        'recovery_path': 'Always exists and visible',
        'incentives': 'Aligned with positive behavior',
        'cost': '10x cheaper',
        'outcomes': 'Better (lower recidivism)'
    }
}

class GraphJusticeSystem:
    """
    Practical implementation
    """
    def __init__(self):
        self.graph = SocialGraph()
        self.reputation_system = ReputationTracker()
        
    def handle_crime(self, criminal, crime):
        # Step 1: Community appreciation
        appreciation = self.community_appreciate(crime)
        
        # Step 2: Calculate adjustment
        reduction = appreciation.graph_adjustment
        
        # Step 3: Reorganize graph
        self.graph.weaken_edges(criminal, reduction)
        self.graph.move_peripheral(criminal, reduction)
        
        # Step 4: Track and monitor
        self.reputation_system.track(criminal)
        
        # Step 5: Enable recovery
        self.reputation_system.enable_recovery_path(criminal)
        
        return {
            'immediate': 'Edges weakened',
            'ongoing': 'Actions tracked',
            'recovery': 'Path available',
            'transparency': 'All visible to criminal'
        }
        
    def track_recovery(self, criminal):
        """
        Monitor positive actions
        """
        for action in criminal.actions:
            if action.is_positive():
                # Strengthen edges
                increase = self.calculate_increase(action)
                self.graph.strengthen_edges(criminal, increase)
                
                # Notify criminal (feedback)
                self.notify(criminal, f"Edge weight +{increase}")

current_reality_justice = {
    'crime_tracking': {
        'system': 'current-reality repo',
        'tracks': 'Criminal actions + community evaluations',
        'stores': 'PST universal database',
        'accessible': 'Via graph query AVS'
    },
    
    'graph_adjustment': {
        'calculated': 'Community appreciation aggregation',
        'applied': 'Edge weight updates (automatic)',
        'monitored': 'current-reality tracks changes',
        'verified': 'Eigen validators confirm'
    },
    
    'recovery_tracking': {
        'actions': 'Observed via current-reality',
        'evaluation': 'Community members signal',
        'weights': 'Updated automatically',
        'transparent': 'Criminal sees progress'
    }
}

w_optimization = {
    'traditional_justice': {
        'action': 'Imprison criminal',
        'w_criminal': '10^20 → ~0 (destroyed)',
        'w_victim': '0 (still harmed)',
        'w_society': '-cost (expensive)',
        'total_delta_w': '-10^20 - cost',
        'optimal': False
    },
    
    'graph_justice': {
        'action': 'Weaken criminal edges',
        'w_criminal': '10^20 → 0.25×10^20 (reduced but maintained)',
        'w_victim': '0 (still harmed, but see restitution)',
        'w_society': '+safety - minimal_cost',
        'w_recovery': 'Increases over time (positive actions)',
        'total_delta_w': '-0.75×10^20 + recovery',
        'optimal': 'More optimal (W > 0 maintained)'
    },
    
    'comparison': {
        'w_difference': '0.25×10^20 vs 0',
        'advantage': '0.25×10^20 better',
        'plus_recovery': 'Graph justice trends upward',
        'plus_incentives': 'Aligned with W maximization',
        'conclusion': 'Graph justice optimal'
    }
}