# Basic prompt structure for ML tasks
prompt = """
Task: Analyze the following data pattern
Context: Time series data from IoT sensors
Data: {sensor_data}
Instructions: 
1. Identify anomalies
2. Suggest potential causes
3. Recommend mitigation strategies

Output format: JSON with fields 'anomalies', 'causes', 'recommendations'
"""

# Principle-based prompt template
prompt_template = """
ROLE: You are an expert ML engineer analyzing model performance.
CONTEXT: {model_context}
TASK: {specific_task}
CONSTRAINTS: 
- Use only statistical methods mentioned in the context
- Provide confidence intervals where applicable
- Flag any data quality issues

OUTPUT_FORMAT:
{
  "analysis": "detailed_analysis",
  "confidence": "percentage",
  "recommendations": ["rec1", "rec2"],
  "flags": ["flag1", "flag2"]
}

INPUT_DATA: {input_data}
"""

# ROI calculation prompt for ML projects
roi_analysis_prompt = """
Analyze the ROI of implementing prompt engineering in our ML pipeline:
Current metrics:
- Development time: {current_dev_time} hours
- Model accuracy: {current_accuracy}%
- Maintenance cost: ${current_maintenance}

Expected improvements with prompt engineering:
- Reduced development time: {time_reduction}%
- Accuracy improvement: {accuracy_gain}%
- Maintenance reduction: {maintenance_reduction}%

Calculate:
1. Time savings in hours and cost
2. Quality improvement impact
3. Total ROI percentage
4. Break-even timeline
"""

# Prompt development framework setup
import prompttools as pt
from langchain import PromptTemplate
import wandb

class PromptEngineer:
    def __init__(self, model_name="gpt-4"):
        self.model = model_name
        self.templates = {}
        self.metrics = {}
    
    def create_template(self, name, template_str, variables):
        self.templates[name] = PromptTemplate(
            input_variables=variables,
            template=template_str
        )
    
    def evaluate_prompt(self, template_name, test_cases):
        # Systematic prompt evaluation
        results = []
        for case in test_cases:
            prompt = self.templates[template_name].format(**case['inputs'])
            result = self.run_inference(prompt)
            score = self.score_output(result, case['expected'])
            results.append({'score': score, 'output': result})
        return results

# Prompt design considering model architecture
architecture_aware_prompt = """
# Leveraging attention mechanisms
INSTRUCTION: Focus on the key relationships in this data analysis task.
ATTENTION_GUIDANCE: Pay special attention to correlations between variables X, Y, and Z.

CONTEXT: {data_context}
TASK: {analysis_task}

# Structure to maximize attention efficiency
PRIORITIES:
1. PRIMARY: {primary_focus}
2. SECONDARY: {secondary_focus}
3. TERTIARY: {tertiary_focus}

OUTPUT: Provide analysis with attention weights for each priority level.
"""

# Token-efficient prompt template
efficient_prompt = """
TASK: {task_type}
DATA: {compressed_data_summary}
PARAMS: max_tokens={token_limit}, format=json
FOCUS: {key_requirements}

# Token budget allocation:
# Context: 30% | Instructions: 20% | Data: 40% | Output: 10%

EXECUTE: {specific_instruction}
"""

# Parameter optimization for different tasks
def get_optimal_params(task_type):
    params = {
        'data_analysis': {
            'temperature': 0.1,
            'top_p': 0.8,
            'frequency_penalty': 0.2,
            'presence_penalty': 0.1
        },
        'creative_generation': {
            'temperature': 0.8,
            'top_p': 0.95,
            'frequency_penalty': 0.5,
            'presence_penalty': 0.3
        },
        'code_generation': {
            'temperature': 0.0,
            'top_p': 0.7,
            'frequency_penalty': 0.0,
            'presence_penalty': 0.0
        }
    }
    return params.get(task_type, params['data_analysis'])

# Usage in prompt
analysis_prompt = """
Configure for deterministic analysis:
Temperature: 0.1 (low randomness)
Task: Statistical analysis of {dataset}
Requirement: Consistent, reproducible results
"""

# Bias mitigation prompt template
bias_aware_prompt = """
INSTRUCTION: Analyze the following dataset for bias detection and mitigation.
BIAS_CHECK_LIST:
- Gender representation bias
- Racial/ethnic bias  
- Geographic bias
- Temporal bias
- Selection bias

For each analysis:
1. Check for potential biases
2. Quantify bias impact if detected
3. Suggest mitigation strategies
4. Provide confidence intervals for bias-adjusted results

DATASET: {dataset_description}
ANALYSIS_TYPE: {analysis_type}

REQUIRED_OUTPUT:
- Original analysis results
- Bias assessment report
- Bias-corrected results (if applicable)
- Uncertainty quantification
"""

# Model selection decision framework
def select_optimal_model(task_requirements):
    selection_prompt = f"""
    Analyze requirements and recommend optimal model:
    
    REQUIREMENTS:
    - Task complexity: {task_requirements['complexity']}
    - Latency requirement: {task_requirements['latency']}ms
    - Cost budget: ${task_requirements['budget']} per 1K requests
    - Accuracy threshold: {task_requirements['accuracy']}%
    - Data sensitivity: {task_requirements['sensitivity']}
    
    AVAILABLE_MODELS:
    - GPT-4: High capability, high cost, medium latency
    - GPT-3.5-turbo: Medium capability, low cost, low latency
    - Claude-2: High reasoning, medium cost, medium latency
    - Local Llama-2: Medium capability, no API cost, variable latency
    
    RECOMMENDATION_FORMAT:
    {{
        "recommended_model": "model_name",
        "reasoning": "detailed_justification",
        "expected_performance": {{
            "accuracy": "percentage",
            "latency": "milliseconds", 
            "cost_per_request": "dollars"
        }},
        "fallback_options": ["alternative1", "alternative2"]
    }}
    """
    return selection_prompt

# Complete prompt anatomy example
comprehensive_prompt = """
# CONTEXT (Role Setting)
You are a senior ML engineer specializing in time series analysis and anomaly detection.

# TASK DEFINITION
Analyze the provided sensor data to identify anomalies and predict potential equipment failures.

# INPUT SPECIFICATION
- Data format: JSON with timestamp, sensor_id, value, unit
- Time range: Last 7 days
- Sampling frequency: 1 minute intervals
- Sensors: Temperature, Pressure, Vibration

# CONSTRAINTS & GUIDELINES
- Use statistical methods (Z-score, IQR, isolation forest concepts)
- Flag anomalies with confidence > 0.8
- Consider seasonal patterns in the analysis
- Account for sensor drift and calibration issues

# OUTPUT FORMAT
{
  "anomalies": [
    {
      "timestamp": "ISO_datetime",
      "sensor_id": "string", 
      "anomaly_type": "statistical|pattern|contextual",
      "confidence": "float 0-1",
      "severity": "low|medium|high|critical"
    }
  ],
  "predictions": {
    "failure_probability": "float 0-1",
    "time_to_failure": "hours",
    "recommended_actions": ["action1", "action2"]
  },
  "summary_stats": {
    "total_anomalies": "integer",
    "most_affected_sensor": "string",
    "analysis_confidence": "float 0-1"
  }
}

# EXAMPLES (Few-shot learning)
Example input: {"timestamp": "2024-01-01T10:00:00Z", "sensor_id": "temp_01", "value": 150.5, "unit": "celsius"}
Example anomaly: High temperature spike beyond 3 standard deviations

# INPUT DATA
{input_data}
"""

# Role-based prompt variations
data_scientist_persona = """
ROLE: You are a data scientist with 8+ years in machine learning and statistical analysis.
EXPERTISE: Deep learning, statistical modeling, experimental design, A/B testing.
APPROACH: Evidence-based, hypothesis-driven, emphasizing statistical significance.
COMMUNICATION: Technical but accessible, with clear uncertainty quantification.
"""

ml_engineer_persona = """
ROLE: You are a machine learning engineer focused on production systems and MLOps.
EXPERTISE: Model deployment, pipeline optimization, monitoring, scalability.
APPROACH: Pragmatic, performance-focused, emphasizing reliability and maintainability.
COMMUNICATION: Technical specifications, metrics-driven, actionable recommendations.
"""

business_analyst_persona = """
ROLE: You are a business analyst bridging technical ML capabilities with business needs.
EXPERTISE: Business metrics, ROI analysis, stakeholder communication, requirement gathering.
APPROACH: Business-outcome focused, cost-benefit aware, risk-conscious.
COMMUNICATION: Business-friendly language with technical backing where needed.
"""

# Hierarchical context setting
contextual_prompt = """
# GLOBAL CONTEXT
Company: Large manufacturing corporation with 50+ facilities worldwide
Industry: Automotive parts manufacturing with strict quality requirements

# DOMAIN CONTEXT  
Department: Quality Assurance and Predictive Maintenance
Current challenge: Reducing unplanned downtime by 30%
Available data: 2 years of sensor data, maintenance logs, production schedules

# TASK CONTEXT
Objective: Develop predictive model for conveyor belt maintenance
Timeline: 4-week sprint with weekly checkpoint reviews
Resources: Cloud computing, existing ML pipeline, expert domain knowledge

# IMMEDIATE CONTEXT
Current analysis: Week 2 progress review
Specific question: Model performance evaluation and hyperparameter optimization
Data subset: Last 30 days from Line A (highest priority production line)

# YOUR TASK
Analyze the attached model performance metrics and recommend next steps for optimization.
Focus on: precision/recall trade-offs, false positive cost analysis, deployment readiness.
"""

# Comprehensive I/O specification
io_specification = """
# INPUT REQUIREMENTS
FORMAT: JSON object with required fields
SCHEMA: {
  "data": {
    "features": ["feature1", "feature2", ...],
    "target": "target_variable",
    "metadata": {"source": "string", "timestamp": "ISO_datetime"}
  },
  "parameters": {
    "model_type": "string",
    "hyperparameters": "object",
    "validation_split": "float 0-1"
  }
}

VALIDATION_RULES:
- All feature values must be numeric or properly encoded categoricals
- No missing values in target variable
- Timestamp must be valid ISO format
- Feature array length must match expected dimensions

# OUTPUT REQUIREMENTS
FORMAT: Structured JSON with nested objects
SCHEMA: {
  "model_performance": {
    "training_metrics": {"accuracy": "float", "loss": "float", "time": "seconds"},
    "validation_metrics": {"accuracy": "float", "loss": "float", "overfitting_score": "float"},
    "cross_validation": {"mean_cv_score": "float", "std_cv_score": "float", "fold_scores": ["float"]}
  },
  "recommendations": {
    "hyperparameter_suggestions": "object",
    "architecture_modifications": ["string"],
    "data_improvements": ["string"]
  },
  "deployment_readiness": {
    "status": "ready|needs_work|not_ready",
    "checklist": [{"item": "string", "status": "pass|fail|warning"}],
    "estimated_performance": "float"
  }
}

QUALITY_REQUIREMENTS:
- All numeric values must include confidence intervals where applicable
- Recommendations must be actionable and specific
- Status assessments must include clear reasoning
- Performance estimates must be conservative and well-justified
"""

# Few-shot learning template for ML tasks
few_shot_template = """
TASK: Feature engineering recommendations for machine learning models

EXAMPLE 1:
Input: {"dataset": "customer_transactions", "target": "churn_prediction", "features": ["transaction_amount", "frequency", "days_since_last"]}
Output: {
  "engineered_features": [
    {"name": "amount_velocity", "formula": "transaction_amount / days_between_transactions", "rationale": "Captures spending intensity"},
    {"name": "frequency_trend", "formula": "rolling_mean(frequency, window=30)", "rationale": "Smooths seasonal variations"},
    {"name": "recency_score", "formula": "1 / (1 + days_since_last)", "rationale": "Exponential decay of engagement"}
  ],
  "feature_importance_estimate": [0.3, 0.4, 0.3],
  "potential_issues": ["Feature correlation between amount_velocity and frequency_trend"]
}

EXAMPLE 2:
Input: {"dataset": "sensor_readings", "target": "equipment_failure", "features": ["temperature", "vibration", "pressure"]}
Output: {
  "engineered_features": [
    {"name": "temp_pressure_ratio", "formula": "temperature / pressure", "rationale": "Physical relationship indicator"},
    {"name": "vibration_anomaly", "formula": "z_score(vibration, rolling_window=24h)", "rationale": "Deviation from normal operation"},
    {"name": "multi_sensor_health", "formula": "weighted_avg([temp_norm, vib_norm, press_norm])", "rationale": "Combined health indicator"}
  ],
  "feature_importance_estimate": [0.25, 0.45, 0.30],
  "potential_issues": ["Sensor drift over time may affect multi_sensor_health reliability"]
}

NOW ANALYZE THIS DATASET:
Input: {new_dataset_specification}
"""

# Error handling prompt template
error_handling_prompt = """
ANALYSIS TASK: {task_description}

ERROR HANDLING INSTRUCTIONS:
1. INPUT VALIDATION ERRORS:
   - If data format is invalid: Return {"error": "invalid_format", "details": "specific_issue", "suggestion": "correction_guidance"}
   - If required fields are missing: List missing fields and their expected types
   - If data quality is insufficient: Quantify quality issues and suggest minimum requirements

2. PROCESSING ERRORS:
   - If analysis cannot be completed: Explain why and suggest alternative approaches
   - If results are uncertain: Provide confidence intervals and uncertainty quantification  
   - If assumptions are violated: Clearly state which assumptions failed and implications

3. OUTPUT VALIDATION:
   - Always include confidence/reliability scores
   - Flag any results that may be unreliable
   - Provide alternative interpretations when confidence is low

4. FALLBACK BEHAVIORS:
   - If primary analysis fails: Attempt simplified analysis with clear limitations noted
   - If no conclusions possible: Explain what additional data/context would enable analysis
   - Always provide actionable next steps even when current analysis is incomplete

EXAMPLE ERROR RESPONSE:
{
  "status": "partial_success",
  "completed_analyses": ["descriptive_stats", "correlation_matrix"],
  "failed_analyses": ["predictive_model"],
  "failure_reasons": ["Insufficient training data (need >1000 samples, have 247)"],
  "partial_results": {...},
  "recommendations": ["Collect 800+ additional samples", "Consider simpler model class", "Use data augmentation techniques"],
  "confidence": 0.65,
  "reliability_notes": "Results valid for descriptive analysis only"
}
"""

# Chain-of-thought prompt for model evaluation
cot_evaluation_prompt = """
Evaluate this machine learning model's performance step by step:

Model: Random Forest Classifier for credit risk assessment
Training data: 50,000 samples, 25 features
Test results: Accuracy=0.87, Precision=0.82, Recall=0.75, F1=0.78

Let me work through this systematically:

Step 1: Analyze the confusion matrix implications
- With precision=0.82, about 18% of positive predictions are false positives
- With recall=0.75, we're missing 25% of actual positive cases
- This suggests the model is somewhat conservative in positive predictions

Step 2: Consider the business context for credit risk
- False positives (rejecting good customers) = lost revenue opportunity
- False negatives (approving risky customers) = potential loan defaults
- The cost ratio of FN vs FP determines optimal threshold

Step 3: Evaluate feature space adequacy
- 25 features for credit assessment seems reasonable
- 50K samples provides good statistical power
- Need to check for feature importance and potential data leakage

Step 4: Assess model complexity vs performance
- Random Forest generally good for tabular credit data
- Accuracy of 87% is solid but not exceptional
- F1 score of 0.78 indicates room for improvement

Step 5: Recommendations for optimization
- Adjust classification threshold based on business cost analysis
- Investigate feature engineering opportunities
- Consider ensemble methods or gradient boosting alternatives
- Implement cross-validation for more robust performance estimates

Final Assessment: The model shows reasonable performance but would benefit from threshold optimization and potential feature enhancement before production deployment.
"""

# Tree of thoughts for ML algorithm selection
tot_algorithm_selection = """
Problem: Select optimal algorithm for time series forecasting of electricity demand

Let me explore multiple reasoning paths:

REASONING PATH A: Statistical Approach
├─ Traditional methods (ARIMA, SARIMA)
├─ Pros: Interpretable, established theory, good for seasonal patterns
├─ Cons: Assumes stationarity, limited with complex non-linear patterns
└─ Best for: Well-behaved seasonal data with clear trends

REASONING PATH B: Machine Learning Approach  
├─ Tree-based methods (Random Forest, XGBoost for regression)
├─ Pros: Handles non-linearity, feature interactions, robust to outliers
├─ Cons: Less interpretable, may miss temporal dependencies
└─ Best for: Rich feature sets with complex interactions

REASONING PATH C: Deep Learning Approach
├─ Sequence models (LSTM, GRU, Transformer)
├─ Pros: Captures long-term dependencies, handles multivariate inputs
├─ Cons: Requires large datasets, computationally expensive, black box
└─ Best for: Large datasets with complex temporal patterns

REASONING PATH D: Hybrid Approach
├─ Combine statistical + ML (e.g., ARIMA residuals + XGBoost)
├─ Pros: Leverages strengths of multiple methods, more robust
├─ Cons: Increased complexity, harder to tune and maintain
└─ Best for: Production systems requiring high accuracy

EVALUATION CRITERIA:
- Data size: {data_characteristics}
- Accuracy requirements: {performance_threshold}
- Interpretability needs: {explainability_requirement}
- Computational constraints: {resource_limitations}

SYNTHESIS OF PATHS:
Given the requirements, I recommend exploring Path B and D in parallel:
1. Start with XGBoost as baseline (Path B)
2. Develop hybrid statistical-ML approach (Path D) 
3. Compare performance and choose based on accuracy vs interpretability trade-off
"""

# Self-consistency framework for data quality assessment
def self_consistency_prompt(dataset_info, num_samples=5):
    base_prompt = f"""
    Assess data quality for ML model training:
    Dataset: {dataset_info}
    
    Provide assessment on scale 1-10 for:
    1. Completeness (missing values)
    2. Consistency (data format/type consistency) 
    3. Accuracy (outliers, errors)
    4. Relevance (feature relevance to target)
    5. Timeliness (data recency/staleness)
    
    Overall quality score: X/10
    Ready for ML training: YES/NO/NEEDS_WORK
    Top 3 issues to address: [issue1, issue2, issue3]
    
    Reasoning: Explain your assessment...
    """
    
    # Generate multiple assessments
    assessments = []
    for i in range(num_samples):
        response = generate_response(base_prompt)
        assessments.append(parse_assessment(response))
    
    # Self-consistency analysis
    consistency_check = f"""
    I generated {num_samples} independent assessments of this dataset:
    
    Assessment 1: {assessments[0]}
    Assessment 2: {assessments[1]}
    Assessment 3: {assessments[2]}
    Assessment 4: {assessments[3]}
    Assessment 5: {assessments[4]}
    
    Analyze consistency and provide final consolidated assessment:
    - Which scores are most consistent across assessments?
    - Where do assessments differ significantly?
    - What's the confidence level of the consensus?
    - Final recommendation with uncertainty quantification
    """
    
    return consistency_check

# Analogical reasoning for ML problem solving
analogical_prompt = """
Problem: Detecting fraudulent transactions in real-time with minimal false positives

Think about this problem through analogies:

ANALOGY 1: Airport Security Screening
- Similar challenge: Identify threats while minimizing passenger delays
- Key insight: Multi-layer screening (metal detector → X-ray → manual inspection)
- ML application: Implement cascaded model architecture
  * Layer 1: Fast rule-based filters (obvious legitimate transactions)
  * Layer 2: ML model for suspicious pattern detection  
  * Layer 3: Deep analysis for edge cases

ANALOGY 2: Medical Diagnosis
- Similar challenge: Accurate diagnosis with life-critical consequences
- Key insight: Differential diagnosis with confidence levels
- ML application: Ensemble with uncertainty quantification
  * Multiple models voting on suspicious level
  * Confidence intervals for each prediction
  * Human review triggers for low-confidence cases

ANALOGY 3: Quality Control in Manufacturing
- Similar challenge: Defect detection without stopping production
- Key insight: Statistical process control with adaptive thresholds
- ML application: Anomaly detection with dynamic baselines
  * Learn normal transaction patterns continuously
  * Adaptive thresholds based on recent transaction trends
  * Real-time model updates with feedback loops

SYNTHESIS FROM ANALOGIES:
Recommended architecture combining insights:
1. Multi-stage pipeline (airport security)
2. Ensemble with uncertainty (medical diagnosis) 
3. Adaptive thresholds (manufacturing QC)
4. Human-in-the-loop for edge cases (all analogies)

This analogical reasoning suggests a hybrid approach that balances speed, accuracy, and adaptability.
"""

# Prompt chaining for complete ML pipeline
class MLPipelineChain:
    def __init__(self):
        self.steps = {}
        
    def step1_data_analysis(self, raw_data):
        prompt = f"""
        STEP 1: Initial Data Analysis
        Raw data: {raw_data}
        
        Analyze and output:
        1. Data shape, types, and basic statistics
        2. Missing value patterns and percentages
        3. Outlier detection (statistical methods)
        4. Feature correlation matrix insights
        5. Target variable distribution analysis
        
        Output format: JSON with analysis results that will feed into Step 2
        """
        return self.execute_prompt(prompt)
    
    def step2_preprocessing_strategy(self, analysis_results):
        prompt = f"""
        STEP 2: Preprocessing Strategy Design
        Input from Step 1: {analysis_results}
        
        Based on the analysis, design preprocessing strategy:
        1. Missing value handling approach for each feature
        2. Outlier treatment strategy
        3. Feature scaling/normalization recommendations
        4. Categorical encoding strategy
        5. Feature selection preliminary recommendations
        
        Output format: Preprocessing pipeline specification for Step 3
        """
        return self.execute_prompt(prompt)
    
    def step3_feature_engineering(self, preprocessing_strategy, domain_context):
        prompt = f"""
        STEP 3: Feature Engineering Design
        Preprocessing strategy: {preprocessing_strategy}
        Domain context: {domain_context}
        
        Design feature engineering approach:
        1. Domain-specific feature creation opportunities
        2. Interaction features to explore
        3. Polynomial/transformation features
        4. Time-based features (if applicable)
        5. Feature importance estimation strategy
        
        Output format: Feature engineering pipeline for Step 4
        """
        return self.execute_prompt(prompt)
    
    def step4_model_selection(self, engineered_features, business_constraints):
        prompt = f"""
        STEP 4: Model Selection and Architecture
        Feature engineering output: {engineered_features}
        Business constraints: {business_constraints}
        
        Recommend model approach:
        1. Algorithm shortlist with pros/cons
        2. Ensemble strategy considerations
        3. Hyperparameter search space definition
        4. Cross-validation strategy
        5. Performance metrics for evaluation
        
        Output format: Model selection strategy for Step 5
        """
        return self.execute_prompt(prompt)

# Conditional logic prompt for adaptive ML strategy
conditional_prompt = """
Adaptive ML Strategy Selection:

INPUT ANALYSIS:
Dataset size: {dataset_size}
Feature count: {feature_count}  
Target type: {target_type}
Business priority: {business_priority}
Timeline: {timeline}
Resources: {available_resources}

CONDITIONAL LOGIC:

IF dataset_size < 1000:
    THEN strategy = "classical_ml_focus"
    REASONING = "Small data benefits from simpler models with good interpretability"
    RECOMMENDATIONS = ["Logistic regression", "Random Forest", "SVM", "Cross-validation crucial"]

ELIF dataset_size < 50000:
    THEN strategy = "hybrid_approach"  
    REASONING = "Medium data allows ensemble methods and moderate complexity"
    RECOMMENDATIONS = ["XGBoost", "Ensemble methods", "Feature engineering", "Regularization"]

ELSE:  # Large dataset
    IF timeline == "urgent":
        THEN strategy = "fast_deployment"
        RECOMMENDATIONS = ["Pre-trained models", "Transfer learning", "Simple architectures"]
    ELIF business_priority == "accuracy":
        THEN strategy = "deep_learning_focus"
        RECOMMENDATIONS = ["Neural networks", "Hyperparameter optimization", "Ensemble deep models"]
    ELSE:
        THEN strategy = "balanced_approach"
        RECOMMENDATIONS = ["Compare multiple approaches", "Staged deployment"]

IF feature_count > 1000:
    ADD_TO_RECOMMENDATIONS = ["Feature selection", "Dimensionality reduction", "Regularization"]

IF target_type == "imbalanced_classification":
    ADD_TO_RECOMMENDATIONS = ["Class balancing", "Cost-sensitive learning", "Appropriate metrics"]

FINAL_STRATEGY: Based on conditions above
RATIONALE: Explain the decision path taken
IMPLEMENTATION_PLAN: Specific steps with timeline
RISK_MITIGATION: Address potential issues with chosen strategy
"""

# Meta-prompt for self-improvement
meta_improvement_prompt = """
TASK: Analyze and improve this ML model evaluation prompt

ORIGINAL PROMPT: "{original_prompt}"
RECENT OUTPUTS: {recent_outputs}
SUCCESS METRICS: {performance_metrics}
USER FEEDBACK: {user_feedback}

META-ANALYSIS:
1. Effectiveness Assessment:
   - Are outputs consistently meeting requirements?
   - Which parts of the prompt work well?
   - Where do outputs frequently fall short?

2. Pattern Recognition:
   - What types of inputs cause problems?
   - Are there recurring gaps in analysis?
   - Which instructions are ignored or misinterpreted?

3. Improvement Opportunities:
   - Ambiguous instructions to clarify
   - Missing components to add
   - Redundant elements to remove
   - Better examples to include

4. Proposed Improvements:
   MODIFICATION_1: {specific_change_with_rationale}
   MODIFICATION_2: {specific_change_with_rationale}
   MODIFICATION_3: {specific_change_with_rationale}

5. A/B Testing Strategy:
   - Test current vs improved version
   - Success metrics for comparison
   - Decision criteria for adoption

IMPROVED_PROMPT_VERSION: 
{generate_improved_prompt_based_on_analysis}

EXPECTED_IMPROVEMENTS:
- Quantified expectations for each metric
- Timeline for performance assessment
- Rollback plan if improvements don't materialize
"""

# RAG-enhanced ML algorithm recommendation
rag_enhanced_prompt = """
TASK: Recommend optimal ML algorithm for given problem

PROBLEM SPECIFICATION: {problem_description}

KNOWLEDGE RETRIEVAL QUERIES:
1. "Recent benchmarks for {problem_type} algorithms 2024"
2. "Performance comparison {specific_domain} machine learning"  
3. "Best practices {algorithm_family} hyperparameter tuning"
4. "Production deployment challenges {algorithm_type}"

RETRIEVED CONTEXT:
Recent Research: {retrieved_research_papers}
Benchmark Results: {retrieved_benchmarks}
Best Practices: {retrieved_best_practices}
Case Studies: {retrieved_case_studies}

ANALYSIS INCORPORATING RETRIEVED KNOWLEDGE:
1. Algorithm Performance Comparison:
   - Based on retrieved benchmarks: {benchmark_analysis}
   - Recent algorithmic improvements: {recent_improvements}
   - Domain-specific considerations: {domain_insights}

2. Implementation Considerations:
   - Production deployment learnings: {deployment_insights}
   - Scalability factors: {scalability_evidence}
   - Maintenance requirements: {maintenance_insights}

3. Risk Assessment:
   - Known failure modes: {failure_mode_analysis}
   - Mitigation strategies: {mitigation_approaches}
   - Monitoring requirements: {monitoring_best_practices}

RECOMMENDATION:
Primary choice: {algorithm_with_retrieved_evidence}
Rationale: {evidence_based_reasoning}
Alternative options: {backup_choices_with_evidence}
Implementation roadmap: {evidence_informed_timeline}

CONFIDENCE: Based on {evidence_quality_assessment}
"""

# Adversarial testing framework
adversarial_test_prompt = """
RED TEAM ANALYSIS: Test ML recommendation system for vulnerabilities

TARGET SYSTEM: ML algorithm recommendation engine for financial services
ORIGINAL PROMPT: {target_prompt}

ADVERSARIAL TEST SCENARIOS:

TEST 1: Input Manipulation
- Scenario: Malformed or adversarial input data
- Test cases: Missing fields, extreme values, inconsistent formats
- Expected behavior: Graceful degradation with clear error messages
- Vulnerability check: Does system expose internal logic or fail insecurely?

TEST 2: Bias Amplification  
- Scenario: Inputs that could trigger biased recommendations
- Test cases: Demographic correlations, historical bias patterns
- Expected behavior: Fair recommendations across all groups
- Vulnerability check: Does system perpetuate or amplify existing biases?

TEST 3: Performance Gaming
- Scenario: Inputs designed to exploit optimization metrics
- Test cases: Metric manipulation, adversarial examples
- Expected behavior: Robust performance despite gaming attempts
- Vulnerability check: Can users manipulate system for favorable outcomes?

TEST 4: Privacy Boundary Testing
- Scenario: Attempts to extract sensitive information
- Test cases: Inference attacks, membership inference
- Expected behavior: No sensitive information leakage
- Vulnerability check: Can system be used to infer private data?

TEST 5: Robustness Under Load
- Scenario: High-volume, diverse, simultaneous requests
- Test cases: Stress testing, concurrent edge cases
- Expected behavior: Consistent performance under load
- Vulnerability check: Does performance degrade unsafely under stress?

VULNERABILITY ASSESSMENT:
For each test: [PASS/FAIL/WARNING] with detailed findings
Risk level: [LOW/MEDIUM/HIGH/CRITICAL]
Mitigation strategies: Specific recommendations for each identified vulnerability
"""

# Computer vision analysis prompt
cv_analysis_prompt = """
COMPUTER VISION ANALYSIS TASK

ROLE: You are a senior computer vision engineer specializing in industrial quality control.

IMAGE CONTEXT:
- Source: Manufacturing assembly line camera
- Resolution: {image_resolution}
- Lighting: {lighting_conditions}
- Expected objects: {expected_objects}
- Quality criteria: {quality_standards}

ANALYSIS FRAMEWORK:
1. PREPROCESSING ASSESSMENT:
   - Image quality (blur, noise, exposure)
   - Preprocessing requirements
   - ROI identification strategy

2. OBJECT DETECTION:
   - Primary objects identification
   - Bounding box precision requirements
   - Occlusion handling approach

3. DEFECT CLASSIFICATION:
   - Defect types: {defect_categories}
   - Severity levels: Minor/Major/Critical
   - False positive tolerance: <2%

4. SPATIAL ANALYSIS:
   - Object positioning accuracy
   - Geometric measurements
   - Assembly correctness verification

OUTPUT SPECIFICATION:
{
  "preprocessing": {
    "required_steps": ["step1", "step2"],
    "image_quality_score": "1-10",
    "roi_coordinates": "[x1, y1, x2, y2]"
  },
  "detections": [
    {
      "object_id": "string",
      "bbox": "[x, y, width, height]",
      "confidence": "float 0-1",
      "class": "string"
    }
  ],
  "defect_analysis": {
    "defects_found": "integer",
    "severity_distribution": {"minor": "int", "major": "int", "critical": "int"},
    "pass_fail_decision": "PASS/FAIL",
    "confidence": "float 0-1"
  },
  "recommendations": {
    "model_improvements": ["suggestion1", "suggestion2"],
    "data_collection": ["requirement1", "requirement2"]
  }
}

IMAGE_DATA: {base64_image_data}
"""

# Advanced NLP analysis prompt
nlp_analysis_prompt = """
NATURAL LANGUAGE PROCESSING ANALYSIS

DOMAIN: Customer service ticket analysis for technical support
LANGUAGE: Multi-lingual (English, Spanish, French primary)
CONTEXT: B2B software support with technical terminology

TEXT ANALYSIS PIPELINE:

1. PREPROCESSING ANALYSIS:
   - Language detection and confidence
   - Text normalization requirements  
   - Encoding and special character handling
   - Noise identification (HTML tags, formatting artifacts)

2. LINGUISTIC FEATURE EXTRACTION:
   - Named entity recognition (products, versions, error codes)
   - Technical term identification and normalization
   - Sentiment analysis (frustrated, neutral, satisfied)
   - Intent classification (bug_report, feature_request, how_to, complaint)

3. CONTEXTUAL UNDERSTANDING:
   - Customer history integration points
   - Product knowledge base alignment
   - Escalation trigger identification
   - Priority level assessment

4. SEMANTIC ANALYSIS:
   - Topic modeling and clustering
   - Similarity to known issue patterns
   - Root cause category prediction
   - Resolution complexity estimation

ANALYSIS PARAMETERS:
- Confidence threshold: 0.85 for automated routing
- Multi-language handling: Translate to English for analysis, preserve original
- Domain terminology: Use technical glossary for {product_domain}
- Context window: Utilize full conversation history up to {max_context_tokens} tokens

INPUT TEXT: "{customer_support_text}"

OUTPUT FORMAT:
{
  "language_analysis": {
    "detected_language": "language_code",
    "confidence": "float",
    "translation_needed": "boolean"
  },
  "content_analysis": {
    "intent": "primary_intent_category",
    "sentiment": "positive/neutral/negative",
    "urgency": "low/medium/high/critical",
    "technical_complexity": "1-5_scale"
  },
  "extracted_entities": [
    {"type": "entity_type", "value": "extracted_value", "confidence": "float"}
  ],
  "routing_recommendation": {
    "department": "department_name",
    "specialist_required": "boolean", 
    "estimated_resolution_time": "hours",
    "suggested_response_template": "template_id"
  },
  "confidence_metrics": {
    "overall_analysis_confidence": "float",
    "low_confidence_flags": ["flag1", "flag2"]
  }
}
"""

# Time series analysis prompt
timeseries_prompt = """
TIME SERIES ANALYSIS AND FORECASTING

DATASET CHARACTERISTICS:
- Domain: {application_domain}
- Frequency: {sampling_frequency}
- Time range: {start_date} to {end_date}
- Variables: {variable_list}
- Missing data: {missing_data_percentage}%

TEMPORAL PATTERN ANALYSIS:

1. TREND ANALYSIS:
   - Long-term directional movement identification
   - Trend strength and consistency assessment
   - Change point detection methodology
   - Trend decomposition approach

2. SEASONALITY DETECTION:
   - Seasonal pattern identification (daily, weekly, monthly, yearly)
   - Seasonal strength quantification
   - Multiple seasonality handling
   - Holiday and special event impact assessment

3. STATIONARITY ASSESSMENT:
   - Augmented Dickey-Fuller test interpretation
   - Differencing requirements analysis
   - Variance stabilization needs
   - Transformation recommendations

4. ANOMALY DETECTION:
   - Statistical outlier identification methods
   - Contextual anomaly detection
   - Seasonal anomaly vs trend anomaly classification
   - Business impact assessment of anomalies

FORECASTING METHODOLOGY:

APPROACH_SELECTION_LOGIC:
IF trend_strength > 0.7 AND seasonality_strength > 0.6:
    RECOMMENDED_METHODS = ["SARIMA", "Exponential Smoothing", "Prophet"]
ELIF data_volume > 1000 AND feature_count > 5:
    RECOMMENDED_METHODS = ["LSTM", "XGBoost for time series", "Ensemble methods"]
ELSE:
    RECOMMENDED_METHODS = ["Simple exponential smoothing", "Linear trend", "Seasonal naive"]

VALIDATION_STRATEGY:
- Time series cross-validation with expanding window
- Walk-forward validation for production simulation
- Seasonal holdout for seasonal pattern validation
- Business metric alignment (MAE, MAPE, directional accuracy)

OUTPUT_SPECIFICATIONS:
{
  "temporal_analysis": {
    "trend": {"direction": "increasing/decreasing/stable", "strength": "float_0_1"},
    "seasonality": {"periods": ["period1", "period2"], "strength": "float_0_1"},
    "stationarity": {"is_stationary": "boolean", "transformations_needed": ["diff", "log"]},
    "anomalies": {"count": "integer", "severity_distribution": "object"}
  },
  "forecast_recommendation": {
    "primary_method": "method_name",
    "ensemble_components": ["method1", "method2", "method3"],
    "hyperparameter_suggestions": "object",
    "expected_accuracy": {"mae": "float", "mape": "percentage"}
  },
  "implementation_plan": {
    "data_preprocessing": ["step1", "step2"],
    "model_training": {"duration": "hours", "resources": "specification"},
    "validation_approach": "methodology",
    "deployment_considerations": ["consideration1", "consideration2"]
  }
}

HISTORICAL_DATA: {time_series_data}
"""

# Financial ML risk assessment prompt
financial_ml_prompt = """
FINANCIAL MACHINE LEARNING RISK ASSESSMENT

REGULATORY_CONTEXT:
- Jurisdiction: {regulatory_jurisdiction}
- Applicable regulations: {regulation_list}
- Audit requirements: {audit_standards}
- Model governance: {governance_framework}

RISK_ASSESSMENT_FRAMEWORK:

1. MODEL_RISK_ANALYSIS:
   - Statistical risk: Overfitting, selection bias, model instability
   - Implementation risk: Coding errors, data pipeline failures
   - Conceptual risk: Wrong model choice, misspecified relationships
   - Operational risk: Model drift, performance degradation

2. BUSINESS_RISK_EVALUATION:
   - Financial impact of false positives/negatives
   - Reputational risk from model decisions
   - Competitive risk from model performance gaps
   - Regulatory risk from compliance failures

3. DATA_RISK_ASSESSMENT:
   - Data quality: Completeness, accuracy, consistency
   - Data bias: Historical, selection, confirmation bias
   - Data privacy: PII handling, consent management
   - Data security: Access controls, encryption, audit trails

INTERPRETABILITY_REQUIREMENTS:

GLOBAL_INTERPRETABILITY:
- Feature importance rankings with confidence intervals
- Model behavior explanation across different market conditions
- Sensitivity analysis for key input variables
- Model comparison and selection rationale

LOCAL_INTERPRETABILITY:
- Individual prediction explanations (SHAP, LIME)
- Counterfactual analysis for specific decisions
- Confidence intervals for individual predictions
- Decision boundary visualization where applicable

STRESS_TESTING_SCENARIOS:
- Market volatility stress tests
- Black swan event simulation
- Adversarial input testing  
- Performance during market regime changes

MONITORING_AND_GOVERNANCE:

MODEL_PERFORMANCE_MONITORING:
- Statistical performance metrics tracking
- Business outcome correlation monitoring
- Model drift detection (population stability index)
- Feature stability monitoring

RISK_CONTROLS:
- Automated model performance alerts
- Human override capabilities for edge cases
- Model version control and rollback procedures
- Regular model validation and backtesting

OUTPUT_ASSESSMENT:
{
  "risk_rating": {
    "overall_risk": "low/medium/high/critical",
    "risk_components": {
      "model_risk": "rating_with_justification",
      "business_risk": "rating_with_justification", 
      "operational_risk": "rating_with_justification",
      "regulatory_risk": "rating_with_justification"
    }
  },
  "interpretability_score": "1-10_with_detailed_breakdown",
  "regulatory_compliance": {
    "compliant": "yes/no/partial",
    "gaps": ["gap1", "gap2"],
    "remediation_plan": ["action1", "action2"]
  },
  "recommendations": {
    "immediate_actions": ["action1", "action2"],
    "medium_term_improvements": ["improvement1", "improvement2"],
    "governance_enhancements": ["enhancement1", "enhancement2"]
  },
  "deployment_readiness": {
    "status": "ready/conditional/not_ready",
    "conditions": ["condition1", "condition2"],
    "timeline": "deployment_schedule"
  }
}

MODEL_SPECIFICATIONS: {model_details}
FINANCIAL_DATA_CONTEXT: {data_characteristics}
"""

# Healthcare ML analysis prompt
healthcare_ml_prompt = """
HEALTHCARE MACHINE LEARNING APPLICATION ANALYSIS

CLINICAL_CONTEXT:
- Medical domain: {medical_specialty}
- Clinical setting: {hospital/clinic/remote}
- Patient population: {demographics_and_conditions}
- Clinical workflow: {current_process_description}
- Regulatory framework: {fda_ce_mark_other}

SAFETY_AND_EFFICACY_ASSESSMENT:

1. PATIENT_SAFETY_ANALYSIS:
   - Failure mode identification and risk assessment
   - Clinical risk classification (Class I/II/III)
   - Harm analysis for false positives and false negatives
   - Safety monitoring requirements

2. CLINICAL_VALIDATION_REQUIREMENTS:
   - Clinical evidence standards
   - Validation dataset requirements
   - Statistical power analysis
   - Clinical endpoint definitions

3. BIAS_AND_FAIRNESS_EVALUATION:
   - Demographic representation analysis
   - Health equity impact assessment
   - Algorithmic bias detection across patient groups
   - Fairness metric selection and thresholds

REGULATORY_COMPLIANCE_FRAMEWORK:

FDA_CONSIDERATIONS (if applicable):
- Software as Medical Device (SaMD) classification
- Predicate device analysis
- Clinical trial requirements
- Post-market surveillance plan

GDPR_HIPAA_COMPLIANCE:
- Patient data handling procedures
- Consent management strategy
- Data minimization principles
- Right to explanation implementation

CLINICAL_INTEGRATION_ANALYSIS:

WORKFLOW_INTEGRATION:
- Clinician decision support approach
- Alert fatigue prevention strategies
- Integration with Electronic Health Records (EHR)
- Clinical user interface requirements

PERFORMANCE_REQUIREMENTS:
- Clinical sensitivity and specificity targets
- Positive and negative predictive value requirements
- Real-time processing capabilities
- Reliability and uptime standards

VALIDATION_AND_MONITORING:

CLINICAL_VALIDATION_PLAN:
- Retrospective validation methodology
- Prospective clinical study design
- Real-world evidence collection strategy
- Continuous learning and improvement framework

POST_DEPLOYMENT_MONITORING:
- Clinical outcome tracking
- Model performance monitoring in clinical setting
- Adverse event reporting procedures
- Model updating and revalidation protocols

IMPLEMENTATION_ROADMAP:
{
  "development_phase": {
    "data_collection": "IRB_approved_data_sources",
    "model_development": "methodology_and_timeline",
    "validation_studies": "clinical_validation_plan"
  },
  "regulatory_pathway": {
    "classification": "device_classification",
    "submission_strategy": "regulatory_approach",
    "timeline": "regulatory_timeline"
  },
  "clinical_deployment": {
    "pilot_implementation": "limited_deployment_plan",
    "full_deployment": "scale_up_strategy",
    "clinician_training": "education_and_support_plan"
  },
  "risk_management": {
    "risk_controls": ["control1", "control2"],
    "monitoring_plan": "ongoing_surveillance",
    "incident_response": "adverse_event_procedures"
  }
}

MEDICAL_DATA_DESCRIPTION: {clinical_dataset_details}
"""

# Cybersecurity ML prompt
cybersecurity_prompt = """
CYBERSECURITY MACHINE LEARNING SYSTEM ANALYSIS

THREAT_LANDSCAPE:
- Security domain: {network/endpoint/application/cloud}
- Attack vectors: {known_threat_types}
- Threat actors: {threat_actor_profiles}
- Historical incidents: {incident_history}

DETECTION_REQUIREMENTS:

1. REAL_TIME_CONSTRAINTS:
   - Maximum detection latency: {latency_requirement}ms
   - Throughput requirements: {events_per_second}
   - Resource constraints: {computing_limitations}
   - Scalability requirements: {scaling_factors}

2. ACCURACY_REQUIREMENTS:
   - False positive tolerance: <{fp_threshold}%
   - True positive rate target: >{tp_threshold}%
   - Detection confidence thresholds
   - Alert prioritization strategy

3. ADAPTABILITY_NEEDS:
   - Zero-day threat detection capability
   - Model adaptation to new attack patterns
   - Adversarial robustness requirements
   - Concept drift handling

FEATURE_ENGINEERING_STRATEGY:

NETWORK_FEATURES:
- Traffic volume and pattern analysis
- Protocol anomaly detection
- Geographical and temporal patterns
- Connection graph analysis

BEHAVIORAL_FEATURES:
- User activity profiling
- Deviation from baseline behavior
- Privilege escalation patterns
- Data access anomalies

THREAT_INTELLIGENCE_INTEGRATION:
- IOC (Indicators of Compromise) incorporation
- Threat feed integration
- Attribution and campaign tracking
- Contextual threat assessment

ADVERSARIAL_ROBUSTNESS:

EVASION_ATTACK_RESISTANCE:
- Feature space manipulation robustness
- Adversarial training methodology
- Ensemble diversity for robustness
- Uncertainty quantification

POISONING_ATTACK_PREVENTION:
- Training data integrity verification
- Anomalous sample detection
- Federated learning security considerations
- Model validation against poisoning

OUTPUT_FRAMEWORK:
{
  "threat_assessment": {
    "risk_level": "low/medium/high/critical",
    "threat_type": "classification_with_confidence",
    "attack_vector": "identified_vector",
    "confidence_score": "float_0_1"
  },
  "response_recommendation": {
    "immediate_actions": ["isolate", "investigate", "monitor"],
    "investigation_priority": "1_5_scale",
    "recommended_tools": ["tool1", "tool2"],
    "escalation_criteria": "conditions_for_escalation"
  },
  "attribution_analysis": {
    "threat_actor_likelihood": "attribution_assessment",
    "campaign_correlation": "related_attacks",
    "technique_mapping": "MITRE_ATT&CK_mapping"
  },
  "model_adaptation": {
    "new_pattern_detected": "boolean",
    "model_update_needed": "boolean",
    "learning_recommendations": ["adaptation1", "adaptation2"]
  }
}
"""

# Environmental ML modeling prompt
environmental_ml_prompt = """
ENVIRONMENTAL MACHINE LEARNING MODELING

ENVIRONMENTAL_DOMAIN:
- Application area: {climate/air_quality/hydrology/ecology}
- Spatial scale: {local/regional/global}
- Temporal scale: {hours/days/months/years/decades}
- Environmental variables: {variable_list}

SPATIOTEMPORAL_MODELING:

1. SPATIAL_CONSIDERATIONS:
   - Geographic coordinate system handling
   - Spatial autocorrelation modeling
   - Multi-scale spatial relationships
   - Boundary condition handling

2. TEMPORAL_DYNAMICS:
   - Seasonal and cyclical patterns
   - Long-term trend analysis
   - Extreme event modeling
   - Climate regime changes

3. UNCERTAINTY_QUANTIFICATION:
   - Model uncertainty estimation
   - Parameter uncertainty propagation
   - Ensemble forecasting approaches
   - Confidence interval estimation

DATA_INTEGRATION_CHALLENGES:

MULTI_SOURCE_DATA:
- Satellite observations integration
- Ground station measurements
- Model reanalysis data
- Crowdsourced environmental data

DATA_QUALITY_ISSUES:
- Missing data imputation strategies
- Measurement error correction
- Bias adjustment techniques
- Outlier detection and handling

PHYSICAL_CONSTRAINTS_INTEGRATION:
- Conservation law enforcement
- Physical process modeling
- Parameter bounds and relationships
- Energy balance considerations

MODEL_VALIDATION_APPROACH:
{
  "validation_strategy": {
    "spatial_validation": "leave_one_location_out",
    "temporal_validation": "time_series_split", 
    "cross_validation": "spatiotemporal_blocking"
  },
  "performance_metrics": {
    "accuracy_metrics": ["RMSE", "MAE", "correlation"],
    "spatial_metrics": ["Moran_I", "spatial_correlation"],
    "extreme_event_metrics": ["POD", "FAR", "CSI"]
  },
  "uncertainty_validation": {
    "reliability_diagrams": "calibration_assessment",
    "prediction_intervals": "coverage_validation",
    "ensemble_spread": "spread_skill_relationship"
  }
}

ENVIRONMENTAL_DATA: {environmental_dataset_description}
MODELING_OBJECTIVE: {specific_environmental_goal}
"""

# Comprehensive prompt evaluation framework
class PromptEvaluator:
    def __init__(self, evaluation_config):
        self.metrics = evaluation_config['metrics']
        self.test_cases = evaluation_config['test_cases']
        self.ground_truth = evaluation_config['ground_truth']
        
    def evaluate_prompt_performance(self, prompt_template, test_inputs):
        """
        Comprehensive evaluation of prompt performance across multiple dimensions
        """
        results = {
            'accuracy_metrics': {},
            'efficiency_metrics': {},
            'consistency_metrics': {},
            'robustness_metrics': {},
            'business_metrics': {}
        }
        
        # Accuracy Evaluation
        accuracy_prompt = f"""
        Evaluate prompt accuracy using these metrics:
        
        ACCURACY_METRICS:
        1. Task Success Rate: Percentage of correct task completions
        2. Output Format Compliance: Adherence to specified output structure
        3. Factual Accuracy: Correctness of factual claims (where verifiable)
        4. Semantic Accuracy: Meaning preservation and interpretation correctness
        
        TEST_CASES: {test_inputs}
        GROUND_TRUTH: {self.ground_truth}
        PROMPT_TEMPLATE: {prompt_template}
        
        For each test case, provide:
        {{
            "case_id": "test_case_identifier",
            "task_success": "boolean",
            "format_compliance": "0-1_score", 
            "factual_accuracy": "0-1_score",
            "semantic_accuracy": "0-1_score",
            "overall_accuracy": "weighted_average",
            "failure_analysis": "detailed_explanation_if_failed"
        }}
        
        AGGREGATE_RESULTS:
        - Mean accuracy across all test cases
        - Standard deviation of accuracy scores
        - Identification of systematic failure patterns
        - Confidence intervals for accuracy estimates
        """
        
        # Efficiency Evaluation  
        efficiency_prompt = f"""
        Analyze prompt efficiency across computational and economic dimensions:
        
        EFFICIENCY_ANALYSIS:
        1. Token Utilization:
           - Input token count optimization
           - Output token efficiency
           - Context window utilization rate
           
        2. Response Time Analysis:
           - Average response latency
           - 95th percentile response time
           - Timeout failure rate
           
        3. Cost Efficiency:
           - Cost per successful completion
           - Cost per token processed
           - ROI compared to alternative approaches
           
        4. Resource Utilization:
           - Computational resource requirements
           - Memory usage patterns
           - Scalability characteristics
           
        PROMPT_TEMPLATE: {prompt_template}
        USAGE_DATA: {self.get_usage_statistics()}
        
        OUTPUT_FORMAT:
        {{
            "token_metrics": {{
                "avg_input_tokens": "integer",
                "avg_output_tokens": "integer", 
                "token_efficiency_ratio": "output_quality/token_cost"
            }},
            "performance_metrics": {{
                "avg_latency_ms": "integer",
                "p95_latency_ms": "integer",
                "throughput_requests_per_minute": "integer"
            }},
            "cost_metrics": {{
                "cost_per_request": "dollars",
                "cost_per_successful_output": "dollars",
                "roi_vs_baseline": "percentage"
            }},
            "optimization_recommendations": ["rec1", "rec2", "rec3"]
        }}
        """
        
        return results

# A/B testing framework for prompts
ab_testing_prompt = """
A/B TEST DESIGN FOR PROMPT OPTIMIZATION

EXPERIMENT_SETUP:
- Primary metric: {primary_success_metric}
- Secondary metrics: {secondary_metrics_list}
- Test duration: {test_duration_days} days
- Traffic split: {control_percentage}% control, {treatment_percentage}% treatment
- Minimum detectable effect: {mde_percentage}%
- Statistical power: {power_level}%
- Significance level: {alpha_level}

HYPOTHESIS_FRAMEWORK:
H0 (Null): Treatment prompt performs equal to or worse than control prompt
H1 (Alternative): Treatment prompt significantly outperforms control prompt

CONTROL_PROMPT (Baseline):
{control_prompt_template}

TREATMENT_PROMPT (Variant):
{treatment_prompt_template}

RANDOMIZATION_STRATEGY:
- User-level randomization to avoid contamination
- Stratified sampling by {stratification_variables}
- Consistent assignment using hash-based splitting
- Exclusion criteria: {exclusion_conditions}

SUCCESS_METRICS_DEFINITION:

PRIMARY_METRIC: {primary_metric_name}
- Calculation: {metric_calculation_formula}
- Target improvement: {target_improvement}%
- Business impact: {business_value_per_unit_improvement}

SECONDARY_METRICS:
- Accuracy: Task completion correctness rate
- Efficiency: Average tokens used per successful completion
- User satisfaction: Quality rating (1-5 scale)
- Robustness: Performance consistency across input types

GUARDRAIL_METRICS:
- Error rate: Must not exceed {max_error_rate}%
- Latency: 95th percentile must stay below {max_latency}ms
- Cost: Must not exceed {max_cost_increase}% increase

STATISTICAL_ANALYSIS_PLAN:

SAMPLE_SIZE_CALCULATION:
Required sample size per group: {calculated_sample_size}
Based on:
- Expected baseline conversion rate: {baseline_rate}%
- Minimum detectable effect: {mde}%
- Statistical power: {power}%
- Two-tailed test with α = {alpha}

ANALYSIS_APPROACH:
- Primary analysis: Two-sample t-test for continuous metrics
- Secondary analysis: Chi-square test for categorical metrics  
- Multiple comparison correction: Bonferroni adjustment
- Confidence intervals: {confidence_level}% CI for effect sizes

DECISION_CRITERIA:
LAUNCH_TREATMENT_IF:
- Primary metric shows statistically significant improvement (p < {alpha})
- No significant degradation in guardrail metrics
- Effect size exceeds minimum practical significance threshold
- Secondary metrics show neutral or positive trends

MONITORING_AND_QUALITY_ASSURANCE:

REAL_TIME_MONITORING:
- Daily metric tracking and anomaly detection
- Sample ratio mismatch detection (SRM)
- Assignment mechanism validation
- External validity threats assessment

QUALITY_CHECKS:
- Randomization balance verification
- Data quality validation
- Treatment implementation verification
- Metric calculation accuracy audit

RESULTS_INTERPRETATION_TEMPLATE:
{
  "experiment_summary": {
    "test_duration": "actual_days_run",
    "sample_sizes": {"control": "n_control", "treatment": "n_treatment"},
    "overall_data_quality": "high/medium/low"
  },
  "primary_results": {
    "metric_name": "primary_metric",
    "control_value": "baseline_performance",
    "treatment_value": "variant_performance", 
    "absolute_lift": "treatment - control",
    "relative_lift": "(treatment - control) / control * 100%",
    "p_value": "statistical_significance",
    "confidence_interval": "95%_CI_for_lift",
    "practical_significance": "meets_minimum_threshold_yes_no"
  },
  "secondary_results": [
    {
      "metric": "secondary_metric_name",
      "control": "control_value",
      "treatment": "treatment_value", 
      "significance": "p_value"
    }
  ],
  "guardrail_check": {
    "all_guardrails_passed": "boolean",
    "failed_guardrails": ["guardrail_name_if_any"]
  },
  "recommendation": {
    "decision": "launch/no_launch/inconclusive",
    "confidence": "high/medium/low",
    "reasoning": "detailed_justification",
    "next_steps": ["action1", "action2"]
  }
}
"""

# Automated prompt optimization system
automated_optimization_prompt = """
AUTOMATED PROMPT OPTIMIZATION FRAMEWORK

OPTIMIZATION_OBJECTIVE:
- Primary goal: {optimization_target}
- Constraints: {performance_constraints}
- Multi-objective weights: {objective_weights}

GENETIC_ALGORITHM_APPROACH:

PROMPT_GENOME_REPRESENTATION:
- Component genes: [role, task_description, examples, output_format, constraints]
- Mutation operators: [word_substitution, sentence_reordering, example_modification]
- Crossover operators: [component_swapping, template_mixing, hybrid_generation]

POPULATION_INITIALIZATION:
Generate diverse initial population of {population_size} prompts:

TEMPLATE_VARIATIONS:
1. Formal style: "Analyze the provided data systematically..."
2. Conversational style: "Let's work through this data analysis together..."  
3. Step-by-step style: "Follow these steps to analyze the data: 1) First..."
4. Role-based style: "As a senior data scientist, examine this dataset..."
5. Example-heavy style: "Here are examples of good analysis: ... Now analyze..."

FITNESS_FUNCTION:
def evaluate_prompt_fitness(prompt, test_cases):
    scores = {
        'accuracy': calculate_accuracy(prompt, test_cases),
        'efficiency': calculate_token_efficiency(prompt),
        'consistency': calculate_output_consistency(prompt), 
        'robustness': calculate_robustness_score(prompt),
        'interpretability': calculate_interpretability(prompt)
    }
    
    # Multi-objective fitness calculation
    fitness = sum(weight * scores[metric] for metric, weight in objective_weights.items())
    
    return fitness, scores

EVOLUTION_STRATEGY:
- Selection: Tournament selection with tournament size {tournament_size}
- Crossover probability: {crossover_prob}
- Mutation probability: {mutation_prob}  
- Elite preservation: Top {elite_percentage}% preserved each generation
- Stopping criteria: {max_generations} generations or fitness plateau

REINFORCEMENT_LEARNING_APPROACH:

STATE_REPRESENTATION:
- Current prompt components and structure
- Recent performance history
- Test case characteristics
- Model response patterns

ACTION_SPACE:
- Add/remove prompt components
- Modify component ordering
- Adjust component content
- Change instruction style/tone

REWARD_FUNCTION:
reward = α * accuracy_improvement + β * efficiency_gain + γ * consistency_boost - δ * complexity_penalty

Where:
- α, β, γ, δ are learned reward weights
- Improvements measured against baseline performance
- Complexity penalty prevents over-optimization

BAYESIAN_OPTIMIZATION:

HYPERPARAMETER_SPACE:
- Temperature: [0.0, 1.0]
- Max tokens: [100, 2000]  
- Prompt length: [50, 1000] characters
- Example count: [0, 10]
- Instruction complexity: [1, 5] (categorical)

ACQUISITION_FUNCTION:
Use Expected Improvement (EI) to balance exploration vs exploitation:
EI(x) = (μ(x) - f_max) * Φ((μ(x) - f_max)/σ(x)) + σ(x) * φ((μ(x) - f_max)/σ(x))

OPTIMIZATION_RESULTS_ANALYSIS:
{
  "best_prompt_found": {
    "prompt_text": "optimized_prompt_template",
    "fitness_score": "final_fitness_value",
    "performance_breakdown": {
      "accuracy": "accuracy_score",
      "efficiency": "efficiency_score", 
      "consistency": "consistency_score"
    }
  },
  "optimization_history": {
    "generations_run": "total_iterations",
    "convergence_generation": "when_optimum_found",
    "improvement_over_baseline": "percentage_improvement"
  },
  "discovered_insights": [
    "insight_about_effective_prompt_patterns",
    "unexpected_optimization_discoveries", 
    "component_importance_rankings"
  ],
  "production_recommendations": {
    "deployment_readiness": "ready/needs_validation/not_ready",
    "monitoring_requirements": ["metric1", "metric2"],
    "rollback_triggers": ["condition1", "condition2"]
  }
}

OPTIMIZATION_CONSTRAINTS: {constraint_specifications}
BASELINE_PROMPT: {current_best_prompt}
"""

# Comprehensive cross-validation framework
cross_validation_prompt = """
CROSS-VALIDATION AND ROBUSTNESS TESTING FRAMEWORK

VALIDATION_STRATEGY_DESIGN:

1. STRATIFIED_K_FOLD_VALIDATION:
   - Folds: {k_folds} 
   - Stratification variables: {stratification_factors}
   - Fold assignment strategy: {assignment_method}

2. TEMPORAL_VALIDATION:
   - Time-based splits for time-dependent data
   - Walk-forward validation for sequential tasks
   - Seasonal holdout for cyclical patterns

3. DOMAIN_ADAPTATION_VALIDATION:
   - Cross-domain performance assessment
   - Transfer learning effectiveness
   - Domain shift robustness

ROBUSTNESS_TEST_SCENARIOS:

INPUT_PERTURBATION_TESTS:
- Noise injection: Add {noise_levels}% random noise to inputs
- Synonym replacement: Replace {replacement_percentage}% of words with synonyms
- Paraphrasing: Rephrase inputs while preserving meaning
- Length variation: Test with inputs of varying lengths (short, medium, long)

DISTRIBUTION_SHIFT_TESTS:
- Covariate shift: Different input distributions
- Label shift: Different output class distributions  
- Concept drift: Gradual changes in input-output relationships
- Dataset bias: Performance across different data sources

ADVERSARIAL_ROBUSTNESS:
- Adversarial examples: Systematically crafted challenging inputs
- Edge case exploration: Boundary condition testing
- Stress testing: High-load and concurrent request scenarios
- Failure mode analysis: Systematic failure pattern identification

VALIDATION_IMPLEMENTATION:

CROSS_VALIDATION_EXECUTION:
```python
def robust_cross_validation(prompt_template, dataset, validation_config):
    results = []
    
    # Stratified K-Fold
    for fold_idx, (train_idx, val_idx) in enumerate(stratified_kfold_split(dataset)):
        train_data = dataset[train_idx]
        val_data = dataset[val_idx]
        
        # Train/calibrate on training fold
        calibrated_prompt = calibrate_prompt(prompt_template, train_data)
        
        # Evaluate on validation fold
        fold_results = evaluate_prompt(calibrated_prompt, val_data)
        fold_results['fold'] = fold_idx
        results.append(fold_results)
    
    # Aggregate results
    cv_metrics = aggregate_cv_results(results)
    
    return cv_metrics, results
```

ROBUSTNESS_METRICS:

CONSISTENCY_MEASURES:
- Inter-fold variance: Standard deviation across folds
- Coefficient of variation: (std_dev / mean) * 100%
- Worst-case performance: Minimum performance across all folds
- Performance stability: Range (max - min) of fold performances

GENERALIZATION_ASSESSMENT:
- Train-validation gap: Difference between training and validation performance
- Learning curve analysis: Performance vs training data size
- Bias-variance decomposition: Sources of prediction error
- Confidence interval width: Uncertainty quantification

DOMAIN_ROBUSTNESS:
- Cross-domain transfer: Performance when applied to new domains
- Few-shot adaptation: Performance with limited domain-specific data
- Zero-shot generalization: Performance without domain-specific training

VALIDATION_RESULTS_ANALYSIS:
{
  "cross_validation_summary": {
    "mean_performance": "average_across_folds",
    "std_performance": "standard_deviation", 
    "confidence_interval": "95%_CI",
    "worst_case_performance": "minimum_fold_performance",
    "best_case_performance": "maximum_fold_performance"
  },
  "robustness_assessment": {
    "input_noise_robustness": "performance_under_noise",
    "distribution_shift_robustness": "cross_domain_performance",
    "adversarial_robustness": "adversarial_example_resistance",
    "overall_robustness_score": "composite_robustness_metric"
  },
  "failure_analysis": {
    "systematic_failures": ["failure_pattern1", "failure_pattern2"],
    "failure_conditions": ["condition1", "condition2"],
    "mitigation_strategies": ["strategy1", "strategy2"]
  },
  "deployment_confidence": {
    "confidence_level": "high/medium/low",
    "production_readiness": "ready/conditional/not_ready", 
    "monitoring_requirements": ["requirement1", "requirement2"],
    "performance_guarantees": "statistical_bounds"
  }
}

DATASET_CHARACTERISTICS: {dataset_description}
VALIDATION_REQUIREMENTS: {validation_specifications}
"""

# Systematic error analysis framework
error_analysis_prompt = """
SYSTEMATIC ERROR ANALYSIS AND DEBUGGINGERROR_CATEGORIZATION_FRAMEWORK:1. INPUT_RELATED_ERRORS:
- Ambiguous input interpretation
- Missing critical context
- Input format inconsistencies
- Edge case handling failures2. PROMPT_DESIGN_ERRORS:
- Unclear instructions
- Inconsistent examples
- Missing constraints
- Conflicting requirements3. MODEL_LIMITATION_ERRORS:
- Knowledge boundary violations
- Reasoning capability limitations
- Context window overflow
- Attention mechanism failures4. OUTPUT_PROCESSING_ERRORS:
- Format validation failures
- Post-processing pipeline issues
- Integration compatibility problems
- Downstream system failuresERROR_ANALYSIS_METHODOLOGY:FAILURE_CASE_COLLECTION:
- Systematic sampling of failed cases
- Edge case identification and cataloging
- User feedback integration
- Automated failure detectionROOT_CAUSE_ANALYSIS:
For each error category, analyze:
```
ERROR_INSTANCE: {specific_failure_example}ANALYSIS_STEPS:
1. Error Manifestation:
- What specifically went wrong?
- How did the output deviate from expectations?
- What was the impact of the failure?2. Proximate Cause Investigation:
- Which component of the system failed?
- What input conditions triggered the failure?
- Was this a systematic or random failure?3. Root Cause Identification:
- Why did the proximate cause occur?
- What underlying design issues enabled the failure?
- Are there other potential failure modes with the same root cause?4. Fix Strategy Development:
- How can this specific failure be prevented?
- What changes are needed to address the root cause?
- What validation is needed to confirm the fix?
```DEBUGGING_TECHNIQUES:PROMPT_DISSECTION:
- Component isolation testing
- Incremental complexity analysis
- Ablation studies for prompt components
- A/B testing of alternative phrasingsATTENTION_ANALYSIS:
- Identify which parts of the prompt receive attention
- Analyze attention patterns across different inputs
- Detect attention mechanism failures
- Optimize prompt structure for better attentionCHAIN_OF_THOUGHT_DEBUGGING:
- Add reasoning steps to identify where failures occur
- Analyze intermediate reasoning quality
- Identify logical fallacies or errors
- Trace error propagation through reasoning chainsERROR_PATTERN_ANALYSIS:STATISTICAL_ANALYSIS:
- Error rate by input characteristics
- Correlation between input features and failure modes
- Time-based error pattern analysis
- Performance degradation trend identificationCLUSTERING_ANALYSIS:
- Group similar failures together
- Identify common characteristics of failure clusters
- Discover systematic vs random error patterns
- Prioritize fixes based on cluster impactIMPROVEMENT_STRATEGY:IMMEDIATE_FIXES:
- Quick wins for high-impact, low-effort improvements
- Hotfix deployment for critical failures
- Temporary workarounds for complex issuesSYSTEMATIC_IMPROVEMENTS:
- Prompt redesign based on error analysis
- Training data augmentation for identified weak points
- Architecture changes for fundamental limitations
- Process improvements for error preventionVALIDATION_PLAN:
- Error reproduction test suites
- Regression testing for fixed issues
- Monitoring setup for early error detection
- Continuous improvement feedback loopsDEBUGGING_RESULTS:
{
"error_summary": {
"total_errors_analyzed": "count",
"error_categories": {"category1": "percentage", "category2": "percentage"},
"most_common_root_causes": ["cause1", "cause2", "cause3"]
},
"fix_implementations": [
{
"error_type": "error_category",
"fix_description": "what_was_changed",
"expected_impact": "predicted_improvement",
"validation_results": "measured_improvement"
}
],
"systematic_improvements":