use super::e_variable::{ACTION_EPSILON, BernoulliHypotheses};
use super::grid::{self, WealthGrid};
use super::reward::RewardSchedule;
use crate::error::VeridictError;
const BISECTION_TOLERANCE: f64 = 1e-10;
const BISECTION_MAX_ITERATIONS: u32 = 200;
const ETA_MAX: f64 = 1.0 - 1e-12;
fn ln_odds_a(eta: f64, ln_odds0: f64, ln_ratio: f64) -> f64 {
ln_odds0 + ln_ratio / (1.0 - eta)
}
const ODDS_OVERFLOW_GUARD: f64 = 40.0;
fn a_star(eta: f64, ln_odds0: f64, ln_ratio: f64) -> f64 {
let ln_oa = ln_odds_a(eta, ln_odds0, ln_ratio);
if ln_oa > ODDS_OVERFLOW_GUARD {
return 1.0 - ACTION_EPSILON;
}
let oa = ln_oa.exp();
oa / (1.0 + oa)
}
fn m(a: f64, eta: f64, p0: f64, p1: f64) -> f64 {
p1 * (a / p0).powf(eta) + (1.0 - p1) * ((1.0 - a) / (1.0 - p0)).powf(eta)
}
pub(crate) fn solve_eta(
hypotheses: &BernoulliHypotheses,
time_scale: f64,
) -> Result<f64, VeridictError> {
let BernoulliHypotheses { p0, p1 } = *hypotheses;
let ratio = p1 / p0;
let target = (1.0 / time_scale).exp();
let min_time_scale = 1.0 / ratio.ln();
let existence_error = || VeridictError::EdoRootDoesNotExist {
p0,
p1,
time_scale,
ratio,
min_time_scale,
};
if target >= ratio {
return Err(existence_error());
}
let ln_odds0 = (p0 / (1.0 - p0)).ln();
let ln_odds1 = (p1 / (1.0 - p1)).ln();
let ln_ratio = ln_odds1 - ln_odds0;
let f = |eta: f64| m(a_star(eta, ln_odds0, ln_ratio), eta, p0, p1) - target;
debug_assert!(
f(0.0) < 0.0,
"target = exp(1/time_scale) > 1 always for time_scale > 0"
);
let mut lo = 0.0_f64;
let mut hi = ETA_MAX;
if f(hi) < 0.0 {
return Err(existence_error());
}
for _ in 0..BISECTION_MAX_ITERATIONS {
let mid = 0.5 * (lo + hi);
let f_mid = f(mid);
if f_mid.abs() < BISECTION_TOLERANCE {
return Ok(mid);
}
if f_mid < 0.0 {
lo = mid;
} else {
hi = mid;
}
}
Ok(0.5 * (lo + hi))
}
pub(crate) struct EdoPolicy {
action: f64,
eta: f64,
planned_value: f64,
}
impl EdoPolicy {
pub(crate) fn build(
hypotheses: &BernoulliHypotheses,
alpha: f64,
reward: &RewardSchedule,
wealth_grid_size: usize,
) -> Result<Self, VeridictError> {
let time_scale = match reward {
RewardSchedule::ExponentialDecay { time_scale, .. } => *time_scale,
_ => panic!("EdoPolicy::build requires RewardSchedule::ExponentialDecay"),
};
let eta = solve_eta(hypotheses, time_scale)?;
let ln_odds0 = (hypotheses.p0 / (1.0 - hypotheses.p0)).ln();
let ln_odds1 = (hypotheses.p1 / (1.0 - hypotheses.p1)).ln();
let action = a_star(eta, ln_odds0, ln_odds1 - ln_odds0);
let grid = WealthGrid::new(alpha, wealth_grid_size);
let planned_value =
grid::evaluate_fixed_action(hypotheses.p0, hypotheses.p1, reward, &grid, action);
Ok(Self {
action,
eta,
planned_value,
})
}
pub(crate) fn action(&self) -> f64 {
self.action
}
pub(crate) fn eta(&self) -> f64 {
self.eta
}
pub(crate) fn planned_value(&self) -> f64 {
self.planned_value
}
}
#[cfg(test)]
mod tests {
use super::*;
fn hyp() -> BernoulliHypotheses {
BernoulliHypotheses { p0: 0.5, p1: 0.55 }
}
#[test]
fn eta_to_zero_recovers_gro() {
let h = hyp();
let ln_odds0 = (h.p0 / (1.0 - h.p0)).ln();
let ln_odds1 = (h.p1 / (1.0 - h.p1)).ln();
let a = a_star(0.0, ln_odds0, ln_odds1 - ln_odds0);
assert!((a - h.p1).abs() < 1e-9);
}
#[test]
fn eta_in_open_interval_gives_action_above_p1() {
let h = hyp();
let ln_odds0 = (h.p0 / (1.0 - h.p0)).ln();
let ln_odds1 = (h.p1 / (1.0 - h.p1)).ln();
for &eta in &[0.1, 0.3, 0.5, 0.7, 0.9] {
let a = a_star(eta, ln_odds0, ln_odds1 - ln_odds0);
assert!(a > h.p1, "eta={eta}, a*={a}, expected > p1={}", h.p1);
}
}
#[test]
fn a_star_never_overflows_to_nan_near_eta_one() {
let h = hyp();
let ln_odds0 = (h.p0 / (1.0 - h.p0)).ln();
let ln_odds1 = (h.p1 / (1.0 - h.p1)).ln();
for &eta in &[0.999, 0.9999, 0.999999, ETA_MAX] {
let a = a_star(eta, ln_odds0, ln_odds1 - ln_odds0);
assert!(a.is_finite() && a > 0.0 && a < 1.0, "eta={eta}, a*={a}");
}
}
#[test]
fn solve_eta_rejects_time_scale_below_existence_threshold() {
let h = hyp();
let min_time_scale = 1.0 / (h.p1 / h.p0).ln();
assert!(matches!(
solve_eta(&h, min_time_scale * 0.5),
Err(VeridictError::EdoRootDoesNotExist { .. })
));
}
#[test]
fn solve_eta_finds_a_root_for_a_comfortable_time_scale() {
let h = hyp();
let eta = solve_eta(&h, 800.0).unwrap();
assert!((0.0..1.0).contains(&eta));
let ln_odds0 = (h.p0 / (1.0 - h.p0)).ln();
let ln_odds1 = (h.p1 / (1.0 - h.p1)).ln();
let target = (1.0_f64 / 800.0).exp();
let value = m(a_star(eta, ln_odds0, ln_odds1 - ln_odds0), eta, h.p0, h.p1);
assert!((value - target).abs() < 1e-6);
}
#[test]
fn action_approaches_gro_as_time_scale_grows() {
let h = hyp();
let eta_small_urgency = solve_eta(&h, 1.0e9).unwrap();
let ln_odds0 = (h.p0 / (1.0 - h.p0)).ln();
let ln_odds1 = (h.p1 / (1.0 - h.p1)).ln();
let a = a_star(eta_small_urgency, ln_odds0, ln_odds1 - ln_odds0);
assert!(
(a - h.p1).abs() < 1e-4,
"a={a}, expected close to p1={}",
h.p1
);
}
}