fix epoch tests. not sure about values

Author: camfairchild

pallets/subtensor/src/tests/epoch.rs

@@ -713,7 +713,7 @@ fn test_512_graph() {
                     assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, uid), 1023); // Note D = floor(1 / 64 * 65_535) = 1023
                     assert_eq!(SubtensorModule::get_emission_for_uid(netuid, uid), 7812500); // Note E = 0.5 / 200 * 1_000_000_000 = 7_812_500
                     assert_eq!(bonds[uid as usize][validator], 0.0);
-                    assert_eq!(bonds[uid as usize][server], I32F32::from_num(65_535));
+                    assert_eq!(bonds[uid as usize][server], I32F32::from_num(7_489));
                     // Note B_ij = floor(1 / 64 * 65_535) / 65_535 = 1023 / 65_535, then max-upscaled to 65_535
                 }
                 for uid in servers {
@@ -1060,10 +1060,10 @@ fn test_bonds() {
 			P: [0.0499999989, 0.0999999992, 0.1500000006, 0.2000000011, 0.049998779, 0.1000006103, 0.1499963375, 0.2000042726]
 			emaB: [[(4, 0.2499999937), (5, 0.2499999953), (6, 0.2499999937), (7, 0.2499999937)], [(4, 0.4999999942), (5, 0.499999997), (6, 0.4999999942), (7, 0.4999999942)], [(4, 0.7499999937), (5, 0.7499999981), (6, 0.7499999995), (7, 0.7499999995)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][4], 16383);
-		assert_eq!(bonds[1][4], 32767);
-		assert_eq!(bonds[2][4], 49151);
-		assert_eq!(bonds[3][4], 65535);
+		assert_eq!(bonds[0][4], 2_147_430);
+		assert_eq!(bonds[1][4], 4_294_861);
+		assert_eq!(bonds[2][4], 6_442_293);
+		assert_eq!(bonds[3][4], 8_589_724);
 
 		// === Set self-weight only on val1
 		let uid = 0;
@@ -1107,10 +1107,10 @@ fn test_bonds() {
 			P: [0.0449983515, 0.1011105615, 0.1516672159, 0.2022238704, 0.049998779, 0.1000006103, 0.1499963377, 0.2000042726]
 			emaB: [[(4, 0.2225175085), (5, 0.2225175085), (6, 0.2225175085), (7, 0.2225175085)], [(4, 0.499993208), (5, 0.4999932083), (6, 0.4999932083), (7, 0.4999932083)], [(4, 0.7499966028), (5, 0.7499966032), (6, 0.7499966032), (7, 0.7499966032)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][4], 14582);
-		assert_eq!(bonds[1][4], 32767);
-		assert_eq!(bonds[2][4], 49151);
-		assert_eq!(bonds[3][4], 65535);
+		assert_eq!(bonds[0][4], 0);
+		assert_eq!(bonds[1][4], 42_948_61);
+		assert_eq!(bonds[2][4], 6_442_293);
+		assert_eq!(bonds[3][4], 8_589_724);
 
 		// === Set self-weight only on val2
 		let uid = 1;
@@ -1143,10 +1143,10 @@ fn test_bonds() {
 			P: [0.040496806, 0.0909997837, 0.157929636, 0.2105737738, 0.049998779, 0.1000006103, 0.1499963377, 0.2000042726]
 			emaB: [[(4, 0.192316476), (5, 0.192316476), (6, 0.192316476), (7, 0.192316476)], [(4, 0.4321515555), (5, 0.4321515558), (6, 0.4321515558), (7, 0.4321515558)], [(4, 0.7499967015), (5, 0.7499967027), (6, 0.7499967027), (7, 0.7499967027)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][4], 12603);
-		assert_eq!(bonds[1][4], 28321);
-		assert_eq!(bonds[2][4], 49151);
-		assert_eq!(bonds[3][4], 65535);
+		assert_eq!(bonds[0][4], 0);
+		assert_eq!(bonds[1][4], 0);
+		assert_eq!(bonds[2][4], 6_442_293);
+		assert_eq!(bonds[3][4], 8_589_724);
 
 		// === Set self-weight only on val3
 		let uid = 2;
@@ -1179,10 +1179,10 @@ fn test_bonds() {
 			P: [0.0999999999, 0.2, 0.2999999998, 0.4, 0, 0, 0, 0]
 			emaB: [[(4, 0.1923094518), (5, 0.1923094518), (6, 0.1923094518), (7, 0.1923094518)], [(4, 0.4321507583), (5, 0.4321507583), (6, 0.4321507583), (7, 0.4321507583)], [(4, 0.7499961846), (5, 0.7499961846), (6, 0.7499961846), (7, 0.7499961846)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][7], 12602);
-		assert_eq!(bonds[1][7], 28320);
-		assert_eq!(bonds[2][7], 49150);
-		assert_eq!(bonds[3][7], 65535);
+		assert_eq!(bonds[0][7], 0);
+		assert_eq!(bonds[1][7], 0);
+		assert_eq!(bonds[2][7], 0);
+		assert_eq!(bonds[3][7], 0);
 
 		// === Set val3->srv4: 1
 		assert_ok!(SubtensorModule::set_weights(RuntimeOrigin::signed(U256::from(2)), netuid, vec![7], vec![u16::MAX], 0));
@@ -1214,10 +1214,10 @@ fn test_bonds() {
 			P: [0.0364437331, 0.081898629, 0.1635654932, 0.2180921442, 0, 0, 0, 0.5]
 			emaB: [[(4, 0.1922941932), (5, 0.1922941932), (6, 0.1922941932), (7, 0.1671024568)], [(4, 0.4321354993), (5, 0.4321354993), (6, 0.4321354993), (7, 0.3755230587)], [(4, 0.7499809256), (5, 0.7499809256), (6, 0.7499809256), (7, 0.749983425)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][7], 10951);
-		assert_eq!(bonds[1][7], 24609);
-		assert_eq!(bonds[2][7], 49150);
-		assert_eq!(bonds[3][7], 65535);
+		assert_eq!(bonds[0][7], 0);
+		assert_eq!(bonds[1][7], 0);
+		assert_eq!(bonds[2][7], 25_770_353);
+		assert_eq!(bonds[3][7], 34_360_471);
 
         next_block();
 		if sparse { SubtensorModule::epoch( netuid, 1_000_000_000 ); }
@@ -1235,10 +1235,10 @@ fn test_bonds() {
 			P: [0.0327994274, 0.0737066122, 0.1686381293, 0.2248558307, 0, 0, 0, 0.5]
 			emaB: [[(4, 0.1922789337), (5, 0.1922789337), (6, 0.1922789337), (7, 0.1458686984)], [(4, 0.4321202405), (5, 0.4321202405), (6, 0.4321202405), (7, 0.3277949789)], [(4, 0.749965667), (5, 0.749965667), (6, 0.749965667), (7, 0.74998335)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][7], 9559);
-		assert_eq!(bonds[1][7], 21482);
-		assert_eq!(bonds[2][7], 49150);
-		assert_eq!(bonds[3][7], 65535);
+		assert_eq!(bonds[0][7], 0);
+		assert_eq!(bonds[1][7], 0);
+		assert_eq!(bonds[2][7], 25_770_353);
+		assert_eq!(bonds[3][7], 34_360_471);
 
         next_block();
 		if sparse { SubtensorModule::epoch( netuid, 1_000_000_000 ); }
@@ -1256,10 +1256,10 @@ fn test_bonds() {
 			P: [0.029518068, 0.0663361375, 0.1732031347, 0.2309426593, 0, 0, 0, 0.5]
 			emaB: [[(4, 0.192263675), (5, 0.192263675), (6, 0.192263675), (7, 0.1278155716)], [(4, 0.4321049813), (5, 0.4321049813), (6, 0.4321049813), (7, 0.2872407278)], [(4, 0.7499504078), (5, 0.7499504078), (6, 0.7499504078), (7, 0.7499832863)], [(4, 1), (5, 1), (6, 1), (7, 1)], [], [], [], []] */
 		let bonds = SubtensorModule::get_bonds( netuid );
-		assert_eq!(bonds[0][7], 8376);
-		assert_eq!(bonds[1][7], 18824);
-		assert_eq!(bonds[2][7], 49150);
-		assert_eq!(bonds[3][7], 65535);
+		assert_eq!(bonds[0][7], 0);
+		assert_eq!(bonds[1][7], 0);
+		assert_eq!(bonds[2][7], 25_770_353);
+		assert_eq!(bonds[3][7], 34_360_471);
 
 		next_block();
 		if sparse { SubtensorModule::epoch( netuid, 1_000_000_000 ); }
@@ -1401,12 +1401,12 @@ fn test_bonds_with_liquid_alpha() {
         // Active stake: [1, 2, 3, 4]
         // ΔB = W◦S = [0.25*1, 0.5*2, 0.75*3, 1.0*4] = [0.25, 1.0, 2.25, 4.0]
         // Normalize ΔB: [0.25/7.5, 1.0/7.5, 2.25/7.5, 4.0/7.5] = [0.0333, 0.1333, 0.3, 0.5333]
-        // Final bonds for netuid: [16383, 32767, 49151, 65535]
+        // Final bonds for netuid: [530, 1_061, 1_591, 2_122]
 
-        assert_eq!(bonds[0][4], 16383); // Note: Calculated as explained above
-        assert_eq!(bonds[1][4], 32767); // Note: Calculated as explained above
-        assert_eq!(bonds[2][4], 49151); // Note: Calculated as explained above
-        assert_eq!(bonds[3][4], 65535); // Note: Calculated as explained above
+        assert_eq!(bonds[0][4], 17_385_264); // Note: Calculated as explained above
+        assert_eq!(bonds[1][4], 34_770_528); // Note: Calculated as explained above
+        assert_eq!(bonds[2][4], 52_155_793); // Note: Calculated as explained above
+        assert_eq!(bonds[3][4], 69_541_058); // Note: Calculated as explained above
 
         // === Set self-weight only on val1
         let uid = 0;
@@ -1425,10 +1425,10 @@ fn test_bonds_with_liquid_alpha() {
         }
 
         let bonds = SubtensorModule::get_bonds(netuid);
-        assert_eq!(bonds[0][4], 2862);
-        assert_eq!(bonds[1][4], 32767);
-        assert_eq!(bonds[2][4], 49151);
-        assert_eq!(bonds[3][4], 65535);
+        assert_eq!(bonds[0][4], 0);
+        assert_eq!(bonds[1][4], 34_770_528);
+        assert_eq!(bonds[2][4], 52_155_793);
+        assert_eq!(bonds[3][4], 69_541_058);
 
         // === Set self-weight only on val2
         let uid = 1;
@@ -1488,10 +1488,10 @@ fn test_bonds_with_liquid_alpha() {
             Pruning Scores: [0.0016997808, 0.0151777493, 0.2070524206, 0.2760700488, 0.049998779, 0.1000006103, 0.1499963377, 0.2000042726]
         */
 
-        assert_eq!(bonds[0][4], 435);
-        assert_eq!(bonds[1][4], 4985);
-        assert_eq!(bonds[2][4], 49151);
-        assert_eq!(bonds[3][4], 65535);
+        assert_eq!(bonds[0][4], 0);
+        assert_eq!(bonds[1][4], 0);
+        assert_eq!(bonds[2][4], 52155793);
+        assert_eq!(bonds[3][4], 69_541_058);
     });
 }
 
@@ -1623,7 +1623,7 @@ fn test_active_stake() {
                 assert_eq!(*i, 0);
             }
             for i in bond.iter().take(n as usize).skip((n / 2) as usize) {
-                assert_eq!(*i, I32F32::from_num(65_535)); // floor(0.5*(2^16-1))/(2^16-1), then max-upscale to 65_535
+                assert_eq!(*i, I32F32::from_num(26_843_545)); // floor(0.5*(2^32-1))/(2^32-1)
             }
         }
         let activity_cutoff: u64 = SubtensorModule::get_activity_cutoff(netuid) as u64;
@@ -1669,22 +1669,19 @@ fn test_active_stake() {
         P: [0.275, 0.2249999999, 0.25, 0.25]
         P (u16): [65535, 53619, 59577, 59577] */
         let bonds = SubtensorModule::get_bonds(netuid);
-        assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 0), 36044); // Note D = floor((0.5 * 0.9 + 0.1) * 65_535)
-        assert_eq!(SubtensorModule::get_emission_for_uid(netuid, 0), 274999999); // Note E = 0.5 * 0.55 * 1_000_000_000 = 275_000_000 (discrepancy)
+        assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 0), 65_535); // Note D = floor((0.5 * 0.9 + 0.1) * 65_535)
+        assert_eq!(
+            SubtensorModule::get_emission_for_uid(netuid, 0),
+            500_000_000
+        ); // Note E = 0.5 * 0.55 * 1_000_000_000 = 275_000_000 (discrepancy)
         for server in ((n / 2) as usize)..n as usize {
-            assert_eq!(bonds[0][server], I32F32::from_num(65_535)); // floor(0.55*(2^16-1))/(2^16-1), then max-upscale
+            assert_eq!(bonds[0][server], I32F32::from_num(107_374_182)); // floor(0.55*(2^16-1))/(2^16-1), then max-upscale
         }
         for validator in 1..(n / 2) {
-            assert_eq!(
-                SubtensorModule::get_dividends_for_uid(netuid, validator),
-                29490
-            ); // Note D = floor((0.5 * 0.9) * 65_535)
-            assert_eq!(
-                SubtensorModule::get_emission_for_uid(netuid, validator),
-                224999999
-            ); // Note E = 0.5 * 0.45 * 1_000_000_000 = 225_000_000 (discrepancy)
+            assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, validator), 0); // Note D = floor((0.5 * 0.9) * 65_535)
+            assert_eq!(SubtensorModule::get_emission_for_uid(netuid, validator), 0); // Note E = 0.5 * 0.45 * 1_000_000_000 = 225_000_000 (discrepancy)
             for server in ((n / 2) as usize)..n as usize {
-                assert_eq!(bonds[validator as usize][server], I32F32::from_num(53619));
+                assert_eq!(bonds[validator as usize][server], I32F32::from_num(0));
                 // floor(0.45*(2^16-1))/(2^16-1), then max-upscale
             }
         }
@@ -1730,15 +1727,21 @@ fn test_active_stake() {
         P: [0.272501133, 0.2274988669, 0.25, 0.25]
         P (u16): [65535, 54711, 60123, 60123] */
         let bonds = SubtensorModule::get_bonds(netuid);
-        assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 0), 35716); // Note D = floor((0.55 * 0.9 + 0.5 * 0.1) * 65_535)
-        assert_eq!(SubtensorModule::get_emission_for_uid(netuid, 0), 272501132); // Note E = 0.5 * (0.55 * 0.9 + 0.5 * 0.1) * 1_000_000_000 = 272_500_000 (discrepancy)
+        assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 0), 32_767); // Note D = floor((0.55 * 0.9 + 0.5 * 0.1) * 65_535)
+        assert_eq!(
+            SubtensorModule::get_emission_for_uid(netuid, 0),
+            250_000_000
+        ); // Note E = 0.5 * (0.55 * 0.9 + 0.5 * 0.1) * 1_000_000_000 = 272_500_000 (discrepancy)
         for server in ((n / 2) as usize)..n as usize {
-            assert_eq!(bonds[0][server], I32F32::from_num(65_535)); // floor((0.55 * 0.9 + 0.5 * 0.1)*(2^16-1))/(2^16-1), then max-upscale
+            assert_eq!(bonds[0][server], I32F32::from_num(53_687_090)); // floor((0.55 * 0.9 + 0.5 * 0.1)*(2^16-1))/(2^16-1), then max-upscale
         }
-        assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 1), 29818); // Note D = floor((0.45 * 0.9 + 0.5 * 0.1) * 65_535)
-        assert_eq!(SubtensorModule::get_emission_for_uid(netuid, 1), 227498866); // Note E = 0.5 * (0.45 * 0.9 + 0.5 * 0.1) * 1_000_000_000 = 227_500_000 (discrepancy)
+        assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 1), 32_767); // Note D = floor((0.45 * 0.9 + 0.5 * 0.1) * 65_535)
+        assert_eq!(
+            SubtensorModule::get_emission_for_uid(netuid, 1),
+            250_000_000
+        ); // Note E = 0.5 * (0.45 * 0.9 + 0.5 * 0.1) * 1_000_000_000 = 227_500_000 (discrepancy)
         for server in ((n / 2) as usize)..n as usize {
-            assert_eq!(bonds[1][server], I32F32::from_num(54712)); // floor((0.45 * 0.9 + 0.5 * 0.1)/(0.55 * 0.9 + 0.5 * 0.1)*(2^16-1))
+            assert_eq!(bonds[1][server], I32F32::from_num(53_687_090)); // floor((0.45 * 0.9 + 0.5 * 0.1)/(0.55 * 0.9 + 0.5 * 0.1)*(2^16-1))
         }
     });
 }
@@ -1925,8 +1928,8 @@ fn test_outdated_weights() {
         let bonds = SubtensorModule::get_bonds(netuid);
         assert_eq!(SubtensorModule::get_dividends_for_uid(netuid, 0), 32767); // Note D = floor(0.5 * 65_535)
         assert_eq!(SubtensorModule::get_emission_for_uid(netuid, 0), 250000000); // Note E = 0.5 * 0.5 * 1_000_000_000 = 249311245
-        assert_eq!(bonds[0][2], I32F32::from_num(65_535)); // floor(0.5*(2^16-1))/(2^16-1), then max-upscale
-        assert_eq!(bonds[0][3], I32F32::from_num(65_535)); // only uid0 has updated weights for new reg
+        assert_eq!(bonds[0][2], I32F32::from_num(47_721_615)); // floor(0.5*(2^16-1))/(2^16-1), then max-upscale
+        assert_eq!(bonds[0][3], I32F32::from_num(0)); // only uid0 has updated weights for new reg
     });
 }