debugging

Author: dpaiton

crates/hyperdrive-math/src/short/max.rs

@@ -60,6 +60,8 @@ impl State {
         Ok(spot_price * (fixed!(1e18) - weight) + min_price * weight)
     }
 
+    /// Use SGD with rate reduction to find the amount of bonds shorted for a
+    /// given base deposit amount.
     pub fn calculate_short_bonds_given_deposit(
         &self,
         base_deposit_amount: FixedPoint<U256>,
@@ -71,21 +73,24 @@ impl State {
         let mut learning_rate = fixed!(1e18);
         let max_iterations = maybe_max_iterations.unwrap_or(1_000);
         let tolerance = maybe_tolerance.unwrap_or(fixed!(1e5));
+        let min_learning_rate = fixed!(1e2);
+
         // Start with a conservative estimate of the bonds shorted & base paid.
+        // Assuming the LP short principal is equal to some relized price times
+        // the bond amount, we can calculate a lower bound using a conservative
+        // price.
         let conservative_price = self.calculate_conservative_short_price(base_deposit_amount)?;
-        // let close_vault_share_price = open_vault_share_price.max(self.vault_share_price());
-        // We ignore the short principal so that we have a closed-form inversion
-        // of the short deposit equation.
-        // let mut last_good_bond_amount = base_deposit_amount
-        //     / (((fixed!(1e18) / self.vault_share_price())
-        //         * (close_vault_share_price / open_vault_share_price)
-        //         + self.flat_fee())
-        //         + self.curve_fee() * (fixed!(1e18) - conservative_price));
-        let mut last_good_bond_amount = self.minimum_transaction_amount();
+        println!("conservative_price = {:#?}", conservative_price);
+        let close_vault_share_price = open_vault_share_price.max(self.vault_share_price());
+        let mut last_good_bond_amount = base_deposit_amount
+            / ((close_vault_share_price / open_vault_share_price)
+                + self.flat_fee()
+                + (self.curve_fee() * (fixed!(1e18) - self.calculate_spot_price()?))
+                - conservative_price);
+
         let mut last_good_base_amount =
             self.calculate_open_short(last_good_bond_amount, open_vault_share_price)?;
         println!("base_deposit_amount = {:#?}", base_deposit_amount);
-        println!("conservative_price = {:#?}", conservative_price);
         println!("last_good_bond_amount = {:#?}", last_good_bond_amount);
         println!("last_good_base_amount = {:#?}", last_good_base_amount);
         println!(
@@ -103,71 +108,68 @@ impl State {
         // Short circuit if we somehow hit it with the guess.
         else if (base_deposit_amount - last_good_base_amount) <= tolerance {
             // Within tolerance, but bond amount must be >= 0.
-            return Ok(last_good_bond_amount.max(fixed!(0)).change_type::<U256>()?);
+            return Ok(last_good_bond_amount.max(fixed!(0)));
         }
         // Run Stochastic Gradient Descent to adjust the bond amount.
         for iter in 0..max_iterations {
             println!("\n----\niter {:#?}", iter);
-            println!("learning_rate {:#?}", learning_rate);
+            println!("learning_rate={:#?}", learning_rate);
             // Calculate the current deposit.
             let base_amount =
                 self.calculate_open_short(last_good_bond_amount, open_vault_share_price)?;
-            // Calculate the current gradient.
-            let base_amount_derivative = self.calculate_open_short_derivative(
-                last_good_bond_amount,
-                open_vault_share_price,
-                Some(self.calculate_spot_price()?),
-            )?;
-            // If we overshot here, we set the error to zero and then the
-            // new_bond_amount = last_good_bond_amount.
+            // If we overshot here, we throw an error.
             println!("last_good_bond_amount={:#?}", last_good_bond_amount);
             println!("base_amount={:#?}", base_amount);
             println!("base_deposit_amount={:#?}", base_deposit_amount);
             let error = if base_amount < base_deposit_amount {
                 base_deposit_amount - base_amount
             } else {
-                fixed!(0)
+                return Err(eyre!("Overshot target."));
             };
             println!("error={:#?}", error);
+            // Calculate the current gradient.
+            let base_amount_derivative = self.calculate_open_short_derivative(
+                last_good_bond_amount,
+                open_vault_share_price,
+                Some(self.calculate_spot_price()?),
+            )?;
+            println!("base_amount_derivative={:#?}", base_amount_derivative);
             // Calculate the new bond amount.
+            // FIXME: swap x & y so it's bonds & base
             // The update rule is: x_1 = x_0 - \eta * L(y,y_t) * dL(y,y_t)/dx,
-            // where \eta is the learning rate, L is the error, y is
-            // open_short(x), and y_t is the target deposit. The derivative of
-            // L(y,y_t) wrt x is -base_amount_derivative. So we add here instead
-            // of subtracting a negative.
+            // where x is the deposit in base, \eta is the learning rate, y is
+            // open_short(x), y_t is the target deposit, and L is (y_t - y).
+            // The derivative of L(y,y_t) wrt x is -base_amount_derivative,
+            // so we add here instead of subtracting a negative.
             let new_bond_amount =
                 last_good_bond_amount + learning_rate * error * base_amount_derivative;
+            println!("new_bond_amount={:#?}", new_bond_amount);
             // If we overshot, lower the learning rate and try again.
             // Otherwise, check convergence to either return or continue.
             match self.calculate_open_short(new_bond_amount, open_vault_share_price) {
                 Ok(new_base_amount) => {
-                    println!(
-                        "new_base_amount={:#?}; base_deposit_amount={:#?}",
-                        new_base_amount, base_deposit_amount
-                    );
-                    if new_base_amount > base_deposit_amount {
-                        let error_magnitude = new_base_amount / base_deposit_amount;
-                        println!("error_magnitude={:#?}", error_magnitude);
-                        // If the values are too close then the error magnitude
-                        // will round to 1.0 and the rate will not change.
-                        learning_rate = if error_magnitude <= fixed!(1e18) {
-                            (learning_rate / fixed!(2e18)).max(fixed!(1))
-                        } else {
-                            (learning_rate / error_magnitude).max(fixed!(1))
-                        };
-                    } else {
-                        last_good_bond_amount = new_bond_amount;
+                    println!("new_base_amount={:#?}", new_base_amount);
+                    if new_base_amount <= base_deposit_amount {
                         last_good_base_amount = new_base_amount;
+                        last_good_bond_amount = new_bond_amount;
                         // Check for convergence.
                         if (base_deposit_amount - last_good_base_amount) <= tolerance {
                             // Within tolerance, but bond amount must be >= 0.
                             return Ok(last_good_bond_amount.max(fixed!(0)));
                         }
-                        // Amount was good but we did not converge; keep going.
+                        // else, amount was good but we did not converge; keep going.
+                    } else {
+                        // Scale the learning rate reduction by the error.
+                        // If the values are too close then the error magnitude
+                        // will be small and the rate will not change enough.
+                        let error_magnitude =
+                            (new_base_amount / base_deposit_amount).max(fixed!(1.0001e18));
+                        println!("error_magnitude={:#?}", error_magnitude);
+                        learning_rate = (learning_rate / error_magnitude).max(min_learning_rate);
                     }
                 }
                 Err(_) => {
-                    learning_rate = (learning_rate / fixed!(10e18)).max(fixed!(1));
+                    learning_rate = (learning_rate / fixed!(1.0001e18)).max(min_learning_rate);
                 }
             }
         }
@@ -720,10 +722,11 @@ mod tests {
 
     #[tokio::test]
     async fn fuzz_calculate_short_bonds_given_deposit() -> Result<()> {
-        let test_tolerance = fixed!(1e6);
+        let test_tolerance = fixed!(1e9);
         let max_iterations = 10_000;
         let mut rng = thread_rng();
-        for _ in 0..*SLOW_FUZZ_RUNS {
+        for fuzz_iter in 0..*SLOW_FUZZ_RUNS {
+            println!("fuzz_iter {:#?}", fuzz_iter);
             let state = rng.gen::<State>();
             let open_vault_share_price = rng.gen_range(fixed!(0)..=state.vault_share_price());
             let checkpoint_exposure = {
@@ -734,7 +737,10 @@ mod tests {
                     I256::try_from(value)?
                 }
             };
-            let max_short_trade = get_max_short(state.clone(), checkpoint_exposure, None)?;
+            let max_short_trade = match get_max_short(state.clone(), checkpoint_exposure, None) {
+                Ok(max_short_trade) => max_short_trade,
+                Err(_) => continue,
+            };
             let target_base_amount =
                 rng.gen_range(state.minimum_transaction_amount()..=max_short_trade);
             let bond_amount = state.calculate_short_bonds_given_deposit(