Behavior Ranking & Selection

behavior_score = (impact_score × feasibility_score × alignment_score) ^ (1/3)

def assess_feasibility(behavior, user_segment):
    """
    Evaluate feasibility using Behavioral State Model
    """
    bsm_scores = {
        'ability_match': assess_ability_requirements(behavior, user_segment),
        'motivation_fit': assess_motivation_alignment(behavior, user_segment),
        'environmental_support': assess_context_compatibility(behavior, user_segment),
        'perception_alignment': assess_belief_compatibility(behavior, user_segment)
    }
    
    # Minimum component rule
    min_score = min(bsm_scores.values())
    
    if min_score < 6:
        return {
            'feasibility_score': 3,  # cap when below feasibility floor
            'verdict': 'INFEASIBLE',
            'blocker': min(bsm_scores, key=bsm_scores.get),
            'recommendation': 'Address blocker or choose different behavior'
        }
    
    # Weighted average for feasible behaviors
    weights = {
        'ability_match': 0.35,
        'motivation_fit': 0.25,
        'environmental_support': 0.25,
        'perception_alignment': 0.15
    }
    
    feasibility = sum(bsm_scores[k] * weights[k] for k in bsm_scores)
    
    return {
        'feasibility_score': feasibility,
        'verdict': 'FEASIBLE' if feasibility > 6 else 'CHALLENGING',
        'improvement_areas': [k for k, v in bsm_scores.items() if v < 7]
    }

class BehaviorRanker:
    def __init__(self, strategic_weights=None):
        self.strategic_weights = strategic_weights or {
            'acquisition': 0.3,
            'retention': 0.4,
            'revenue': 0.2,
            'brand': 0.1
        }
    
    def rank_behaviors(self, behaviors, user_segment):
        """
        Rank behaviors by combined score
        """
        scored_behaviors = []
        
        for behavior in behaviors:
            # Calculate three core dimensions
            impact = self.calculate_impact(behavior)
            feasibility = self.calculate_feasibility(behavior, user_segment)
            alignment = self.calculate_alignment(behavior, self.strategic_weights)
            
            # Combined score (geometric mean)
            combined_score = (impact * feasibility * alignment) ** (1/3)
            
            # Confidence based on data quality
            confidence = self.assess_confidence(behavior)
            
            scored_behaviors.append({
                'behavior': behavior,
                'scores': {
                    'impact': impact,
                    'feasibility': feasibility,
                    'alignment': alignment,
                    'combined': combined_score
                },
                'confidence': confidence,
                'rank': None  # Set after sorting
            })
        
        # Sort by combined score
        scored_behaviors.sort(key=lambda x: x['scores']['combined'], reverse=True)
        
        # Assign ranks
        for i, sb in enumerate(scored_behaviors):
            sb['rank'] = i + 1
        
        return scored_behaviors

# Runnable example
import numpy as np
from collections import defaultdict
import copy
rng = np.random.default_rng(42)

def add_measurement_noise(behaviors, std=0.5):
    noisy = copy.deepcopy(behaviors)
    for b in noisy:
        for k in ['impact','feasibility','alignment']:
            b[k] = max(0, min(10, b[k] + rng.normal(0, std)))
    return noisy

def rank_behaviors(behaviors):
    out = []
    for b in behaviors:
        combined = (b['impact'] * b['feasibility'] * b['alignment']) ** (1/3)
        out.append({**b, 'combined': combined})
    out.sort(key=lambda x: x['combined'], reverse=True)
    for i, b in enumerate(out): b['rank'] = i+1
    return out

def sensitivity_analysis(behaviors, variations=100):
    """
    Monte Carlo simulation of ranking stability
    """
    rank_distributions = defaultdict(list)
    for _ in range(variations):
        noisy_behaviors = add_measurement_noise(behaviors, std=0.5)
        rankings = rank_behaviors(noisy_behaviors)
        for behavior in rankings:
            rank_distributions[behavior['name']].append(behavior['rank'])
    stability_report = {}
    for behavior, ranks in rank_distributions.items():
        stability_report[behavior] = {
            'mean_rank': float(np.mean(ranks)),
            'rank_std': float(np.std(ranks)),
            'rank_range': (min(ranks), max(ranks)),
            'top_3_probability': sum(r <= 3 for r in ranks) / len(ranks)
        }
    return stability_report

def analyze_dependencies(behaviors):
    """
    Identify behavioral prerequisites and sequences
    """
    dependency_graph = {}
    
    for behavior in behaviors:
        dependencies = {
            'hard_prerequisites': [],  # Must happen first
            'soft_prerequisites': [],  # Helpful but not required
            'enables': [],            # This behavior enables others
            'reinforces': []          # Mutual reinforcement
        }
        
        # Example logic
        if behavior['name'] == 'daily_tracking':
            dependencies['hard_prerequisites'] = ['account_setup', 'initial_goal']
            dependencies['enables'] = ['weekly_review', 'streak_building']
            dependencies['reinforces'] = ['motivation_maintenance']
        
        dependency_graph[behavior['name']] = dependencies
    
    return optimize_behavior_sequence(dependency_graph)

import pandas as pd  # required for the example below
from sklearn.ensemble import RandomForestRegressor

def ml_behavior_prediction(historical_data):
    """
    Use ML to predict behavior success
    """
    # Features: behavior characteristics
    features = historical_data[[
        'complexity_score',
        'time_requirement',
        'social_component',
        'immediate_reward',
        'ability_requirement',
        'motivation_type'
    ]]
    
    # Target: actual adoption rate
    target = historical_data['adoption_success']
    
    # Train model
    model = RandomForestRegressor(n_estimators=100)
    model.fit(features, target)
    
    # Feature importance
    importance = pd.DataFrame({
        'feature': features.columns,
        'importance': model.feature_importances_
    }).sort_values('importance', ascending=False)
    
    return model, importance

from scipy.optimize import minimize

def optimize_behavior_portfolio(behaviors, constraints=None):
    """
    Select optimal mix of behaviors given constraints
    """
    n_behaviors = len(behaviors)
    
    # Objective: maximize total impact
    def objective(weights):
        total_impact = sum(
            w * b['impact'] * b['feasibility'] 
            for w, b in zip(weights, behaviors)
        )
        return -total_impact  # Minimize negative
    
    # Constraints
    cons = [
        {'type': 'eq', 'fun': lambda w: sum(w) - 1},  # Weights sum to 1
        {'type': 'ineq', 'fun': lambda w: w}          # Non-negative
    ]
    
    # Bounds
    bounds = [(0, 1) for _ in range(n_behaviors)]
    
    # Initial guess
    initial = [1/n_behaviors] * n_behaviors
    
    # Optimize
    result = minimize(objective, initial, method='SLSQP', 
                      bounds=bounds, constraints=cons)
    
    # Return portfolio
    portfolio = [
        {'behavior': b, 'allocation': w}
        for b, w in zip(behaviors, result.x)
        if w > 0.05  # 5% threshold
    ]
    
    return sorted(portfolio, key=lambda x: x['allocation'], reverse=True)