refactor: remove anti-cheat weight manipulation for pure pass-through

- Remove weight caps (max_weight_fraction: 0.5 -> 1.0)
- Disable softmax, use simple linear normalization
- Add BURN_UID constant for UID 0 (burn address)
- Mark anti_cheat_weights module as LEGACY/DEPRECATED
- Challenges now receive pure weights based on emission percentage
- Unused weight goes to UID 0

Author: echobt

crates/challenge-runtime/src/anti_cheat_weights.rs

@@ -1,17 +1,20 @@
-//! Anti-Cheat Weight Calculation
+//! Anti-Cheat Weight Calculation (LEGACY/DEPRECATED)
 //!
-//! Calculates weights for agents in a way that prevents validator manipulation:
+//! **NOTE: This module is deprecated. Weight manipulation has been removed from the platform.**
 //!
+//! The platform now uses pure pass-through weights:
+//! - Challenges receive weights based directly on their emission percentage
+//! - No outlier detection, no weight caps, no manipulation
+//! - Unused weight is sent to UID 0 (burn address)
+//!
+//! This module is kept for reference but should not be used in production.
+//!
+//! Original design (no longer active):
 //! 1. **Outlier Detection**: Remove scores that deviate significantly from median
 //! 2. **Consensus Requirement**: Agent must have valid scores from ≥50% of validators
 //! 3. **Top Position Requirement**: Agent must be #1 on ≥50% of validators (by count, not stake)
 //! 4. **Stake-Weighted Average**: Final score uses stake weights (after outlier removal)
 //! 5. **Slashing Detection**: Flag validators whose scores consistently deviate
-//!
-//! This prevents:
-//! - Single high-stake validator from manipulating results
-//! - Colluding minority from pushing bad agents
-//! - Validators from lying about evaluation results
 
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};

crates/challenge-runtime/src/weight_calculator.rs

@@ -1,24 +1,29 @@
 //! Weight Calculator
 //!
 //! Converts challenge leaderboard scores to Bittensor weights.
-//! Handles normalization, edge cases, and commit-reveal protocol.
+//! Pure pass-through of challenge weights - no manipulation.
+//! Unused weight automatically goes to UID 0 (burn address).
 
 use serde::{Deserialize, Serialize};
 use tracing::{info, warn};
 
 /// Maximum weight value for Bittensor (u16 max)
 pub const MAX_WEIGHT: u16 = 65535;
 
+/// UID 0 is the burn address - receives all unused weight
+pub const BURN_UID: u16 = 0;
+
 /// Weight calculator configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct WeightCalculatorConfig {
-    /// Minimum score to receive any weight
+    /// Minimum score to receive any weight (default: 0.0 = no threshold)
     pub min_score_threshold: f64,
     /// Temperature for softmax (higher = more distributed weights)
     pub temperature: f64,
     /// Whether to use softmax or linear normalization
     pub use_softmax: bool,
-    /// Maximum weight any single UID can receive (as fraction)
+    /// Maximum weight any single UID can receive (as fraction) - DISABLED (set to 1.0)
+    /// NOTE: Weight cap removed - challenges receive pure weights based on emission %
     pub max_weight_fraction: f64,
     /// Mechanism ID for this challenge
     pub mechanism_id: u8,
@@ -29,8 +34,8 @@ impl Default for WeightCalculatorConfig {
         Self {
             min_score_threshold: 0.0,
             temperature: 1.0,
-            use_softmax: true,
-            max_weight_fraction: 0.5, // No single UID gets > 50%
+            use_softmax: false, // Use simple linear normalization
+            max_weight_fraction: 1.0, // No cap - pure weights
             mechanism_id: 0,
         }
     }
@@ -185,52 +190,14 @@ impl WeightCalculator {
             .collect()
     }
 
-    /// Apply max weight cap and redistribute
-    fn apply_weight_cap(&self, mut weights: Vec<(u16, f64, f64)>) -> Vec<(u16, f64, f64)> {
-        let max = self.config.max_weight_fraction;
-
-        // Sort by weight descending
-        weights.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
-
-        let mut excess = 0.0;
-        let mut capped_count = 0;
-
-        // Cap weights that exceed max
-        for (_, weight, _) in weights.iter_mut() {
-            if *weight > max {
-                excess += *weight - max;
-                *weight = max;
-                capped_count += 1;
-            }
-        }
-
-        if excess > 0.0 && capped_count < weights.len() {
-            // Redistribute excess to non-capped weights
-            let uncapped: Vec<usize> = weights
-                .iter()
-                .enumerate()
-                .filter(|(_, (_, w, _))| *w < max)
-                .map(|(i, _)| i)
-                .collect();
-
-            let extra_per = excess / uncapped.len() as f64;
-            for i in uncapped {
-                weights[i].1 += extra_per;
-                // Re-cap if needed
-                if weights[i].1 > max {
-                    weights[i].1 = max;
-                }
-            }
-        }
-
-        // Normalize to ensure sum = 1.0
-        let sum: f64 = weights.iter().map(|(_, w, _)| w).sum();
-        if sum > 0.0 {
-            for (_, w, _) in weights.iter_mut() {
-                *w /= sum;
-            }
-        }
-
+    /// Apply weight cap (DISABLED - pure pass-through)
+    /// 
+    /// NOTE: Weight caps have been removed for simpler, more transparent weight distribution.
+    /// Challenges receive weights purely based on their emission percentage.
+    /// Unused weight is sent to UID 0 (burn address).
+    fn apply_weight_cap(&self, weights: Vec<(u16, f64, f64)>) -> Vec<(u16, f64, f64)> {
+        // No cap applied - return weights as-is
+        // Normalization already done in normalize_scores()
         weights
     }
 
@@ -385,15 +352,16 @@ mod tests {
     }
 
     #[test]
-    fn test_weight_cap() {
+    fn test_no_weight_cap() {
+        // Weight caps are DISABLED - pure pass-through
         let config = WeightCalculatorConfig {
             use_softmax: false,
-            max_weight_fraction: 0.5, // 50% max
+            max_weight_fraction: 1.0, // No cap (default)
             ..Default::default()
         };
         let calc = WeightCalculator::new(config);
 
-        // One score dominates
+        // One score dominates - should get proportional weight
         let scores = vec![
             MinerScore {
                 uid: 1,
@@ -415,10 +383,13 @@ mod tests {
 
         let result = calc.calculate(&scores, 1);
 
-        // Verify cap is applied - no weight should exceed 50%
-        for w in &result.weights {
-            assert!(w.normalized <= 0.51, "Weight {} exceeds cap", w.normalized);
-        }
+        // With pure pass-through, weights should be proportional to scores
+        // Score 0.9 / 1.0 = 90% weight, Score 0.1 / 1.0 = 10% weight
+        let uid1_weight = result.weights.iter().find(|w| w.uid == 1).unwrap();
+        let uid2_weight = result.weights.iter().find(|w| w.uid == 2).unwrap();
+        
+        assert!(uid1_weight.normalized > 0.85, "UID 1 should get ~90% weight: {}", uid1_weight.normalized);
+        assert!(uid2_weight.normalized < 0.15, "UID 2 should get ~10% weight: {}", uid2_weight.normalized);
 
         // Verify weights still sum to 1.0
         let sum: f64 = result.weights.iter().map(|w| w.normalized).sum();

crates/core/src/message.rs

@@ -475,7 +475,8 @@ pub struct MechanismWeightConfig {
     pub equal_distribution: bool,
     /// Minimum weight per miner (prevents dust weights)
     pub min_weight_threshold: f64,
-    /// Maximum weight cap per miner (0.0 = no cap, 0.5 = max 50%)
+    /// Maximum weight cap per miner (DEPRECATED - set to 1.0)
+    /// NOTE: Weight caps have been removed. Challenges receive pure weights.
     pub max_weight_cap: f64,
     /// Whether this mechanism is active
     pub active: bool,
@@ -488,7 +489,7 @@ impl MechanismWeightConfig {
             base_burn_rate: 0.0,
             equal_distribution: true,
             min_weight_threshold: 0.0001,
-            max_weight_cap: 0.5,
+            max_weight_cap: 1.0, // No cap - pure weights
             active: true,
         }
     }