use super::*;
use crate::error::{Error, Result};
use crate::linalg::{CMat, Mat, RMat};
fn check_gradient<'a, F>(name: &str, f: F, x: &[f64], tol: f64)
where
F: Fn(&mut Tape<'a, f64>, Var) -> Result<Var>,
{
let eval = |xs: &[f64]| {
let mut t = Tape::no_grad();
let v = t.constant(Value::R(RMat::column(xs.to_vec())));
let out = f(&mut t, v).unwrap();
t.scalar(out).unwrap()
};
let mut t = Tape::new();
let v = t.leaf(Value::R(RMat::column(x.to_vec())));
let out = f(&mut t, v).unwrap();
let grads = t.backward(out).unwrap();
let g = grads.wrt_real(v, x.len());
let h = 1e-6;
for i in 0..x.len() {
let mut p = x.to_vec();
let mut m = x.to_vec();
p[i] += h;
m[i] -= h;
let fd = (eval(&p) - eval(&m)) / (2.0 * h);
let scale = fd.abs().max(g[i].abs()).max(1.0);
assert!(
(fd - g[i]).abs() <= tol * scale,
"{name}: d/dx{i} tape {} vs fd {fd}",
g[i]
);
}
}
fn numbers(n: usize, seed: u64) -> Vec<f64> {
let mut s = seed.wrapping_add(0x9E3779B97F4A7C15);
(0..n)
.map(|_| {
s ^= s << 13;
s ^= s >> 7;
s ^= s << 17;
(s >> 11) as f64 / (1u64 << 53) as f64 * 2.0 - 1.0
})
.collect()
}
fn hermitian(n: usize, seed: u64, scale: f64) -> CMat<f64> {
let v = numbers(2 * n * n, seed);
let m = Mat::from_fn(n, n, |r, c| C::new(v[2 * (r * n + c)], v[2 * (r * n + c) + 1]));
m.add(&m.adjoint()).unwrap().scale_re(0.5 * scale)
}
fn unit_vector(n: usize, seed: u64) -> CMat<f64> {
let v = numbers(2 * n, seed);
let m = Mat::from_fn(n, 1, |r, _| C::new(v[2 * r], v[2 * r + 1]));
let norm = m.data.iter().map(|z| z.norm_sqr()).sum::<f64>().sqrt();
m.scale_re(1.0 / norm)
}
fn pure_density(n: usize, seed: u64) -> CMat<f64> {
let psi = unit_vector(n, seed);
psi.matmul(&psi.adjoint()).unwrap()
}
#[test]
fn real_elementwise_ops() {
let x = [0.3, -0.7, 1.2, 0.05];
check_gradient(
"square-sin-cos",
|t, v| {
let a = t.square(v)?;
let b = t.sin(a)?;
let c = t.cos(v)?;
let d = t.mul(b, c)?;
let e = t.add(d, v)?;
let f = t.sub(e, a)?;
let g = t.scale(f, 1.7)?;
t.sum(g)
},
&x,
1e-6,
);
check_gradient(
"sqrt-atan2",
|t, v| {
let a = t.square(v)?;
let s = t.sqrt(a)?;
let y = t.sin(v)?;
let z = t.cos(v)?;
let at = t.atan2(y, z)?;
let m = t.mul(s, at)?;
t.mean(m)
},
&x,
1e-6,
);
}
#[test]
fn structural_ops() {
let x = numbers(8, 3);
let basis = RMat::from_vec(5, 4, numbers(20, 4)).unwrap();
check_gradient(
"slice-matmul-hstack-col",
|t, v| {
let a = t.slice(v, 0, 4)?;
let b = t.slice(v, 4, 4)?;
let ma = t.matmul_const(&basis, a)?;
let mb = t.matmul_const(&basis, b)?;
let sq = t.square(mb)?;
let h = t.hstack(&[ma, sq])?;
let c1 = t.col(h, 1)?;
let c0 = t.col(h, 0)?;
let p = t.mul(c0, c1)?;
t.sum(p)
},
&x,
1e-6,
);
}
#[test]
fn amplitude_penalty_above_and_below_one() {
check_gradient("penalty-active", |t, v| t.amp_penalty(v), &[0.2, -1.6, 0.9], 1e-6);
check_gradient("penalty-inactive", |t, v| t.amp_penalty(v), &[0.2, -0.6, 0.9], 1e-6);
let mut t: Tape<'_, f64> = Tape::new();
let v = t.leaf(Value::R(RMat::column(vec![0.5, -2.0])));
let p = t.amp_penalty(v).unwrap();
assert_eq!(t.scalar(p).unwrap(), 1.0);
}
#[test]
fn complex_elementwise_ops() {
let x = numbers(6, 5);
let c = Mat::from_fn(3, 1, |r, _| C::new(0.3 * r as f64 + 0.1, -0.2 * r as f64 + 0.5));
check_gradient(
"complex-mulconst-real-imag",
|t, v| {
let a = t.slice(v, 0, 3)?;
let b = t.slice(v, 3, 3)?;
let z = t.complex(a, b)?;
let w = t.mul_const_c(z, &c)?;
let re = t.real(w)?;
let im = t.imag(w)?;
let r2 = t.square(re)?;
let p = t.mul(r2, im)?;
t.sum(p)
},
&x,
1e-6,
);
}
fn hilbert_propagation(dim: usize) {
let n_ctrl = 2;
let steps = 3;
let h0 = hermitian(dim, 11, 2.0);
let ops: Vec<CMat<f64>> = (0..n_ctrl).map(|k| hermitian(dim, 20 + k as u64, 1.0)).collect();
let psi0 = unit_vector(dim, 30);
let target = unit_vector(dim, 31);
let x = numbers(steps * n_ctrl, 7);
check_gradient(
&format!("hilbert D={dim}"),
|t, v| {
let cols: Vec<Var> = (0..n_ctrl)
.map(|k| t.slice(v, k * steps, steps))
.collect::<Result<_>>()?;
let umat = t.hstack(&cols)?;
let mut psi = t.constant(Value::C(psi0.clone()));
for s in 0..steps {
let h = t.lincomb_row(&h0, umat, s, &ops)?;
let uu = t.expm_mi_dt(h, 0.4)?;
psi = t.matmul(uu, psi)?;
}
t.fidelity(&target, psi)
},
&x,
1e-5,
);
}
#[test]
fn gate_fidelity_gradients() {
for (dim, k) in [(2, 2), (4, 4), (3, 2)] {
let h0 = hermitian(dim, 11, 2.0);
let ops = vec![hermitian(dim, 20, 1.0)];
let columns: Vec<CMat<f64>> = (0..k).map(|c| unit_vector(dim, 30 + c as u64)).collect();
let psi0 = CMat::from_fn(dim, k, |r, c| columns[c].get(r, 0));
let target = CMat::from_fn(dim, k, |r, c| unit_vector(dim, 40 + c as u64).get(r, 0));
let x = numbers(3, 7);
check_gradient(
&format!("gate fidelity D={dim} k={k}"),
|t, v| {
let mut psi = t.constant(Value::C(psi0.clone()));
for s in 0..3 {
let h = t.lincomb_row(&h0, v, s, &ops)?;
let uu = t.expm_mi_dt(h, 0.4)?;
psi = t.matmul(uu, psi)?;
}
t.fidelity(&target, psi)
},
&x,
1e-5,
);
}
}
#[test]
fn hilbert_propagation_gradients() {
hilbert_propagation(2);
hilbert_propagation(4);
hilbert_propagation(3);
}
#[test]
fn liouville_and_lindblad_gradients() {
let dim = 2;
let h0 = hermitian(dim, 41, 2.0);
let ops: Vec<CMat<f64>> = (0..2).map(|k| hermitian(dim, 50 + k as u64, 1.0)).collect();
let rho0 = pure_density(dim, 60);
let sigma = pure_density(dim, 61);
let collapse = vec![hermitian(dim, 70, 0.3), {
let mut m = CMat::<f64>::zeros(2, 2);
m.set(0, 1, C::new(0.5, 0.0));
m
}];
let lops = LindbladOps::new(&collapse, 0.3).unwrap();
let x = numbers(4, 9);
for dissipative in [false, true] {
check_gradient(
&format!("liouville dissipative={dissipative}"),
|t, v| {
let a = t.slice(v, 0, 2)?;
let b = t.slice(v, 2, 2)?;
let u = t.hstack(&[a, b])?;
let mut rho = t.constant(Value::C(rho0.clone()));
for s in 0..2 {
let h = t.lincomb_row(&h0, u, s, &ops)?;
let uu = t.expm_mi_dt(h, 0.3)?;
rho = t.sandwich(uu, rho)?;
if dissipative {
rho = t.lindblad_step(rho, &lops, if s == 0 { Step::Half } else { Step::Full })?;
}
}
t.re_trace_product(&sigma, rho)
},
&x,
1e-5,
);
}
}
#[test]
fn batch_mean_matches_the_sequential_sum() {
let h0s: Vec<CMat<f64>> = (0..7).map(|b| hermitian(2, 100 + b, 1.5)).collect();
let op = vec![hermitian(2, 200, 1.0)];
let psi0 = unit_vector(2, 201);
let target = unit_vector(2, 202);
let x = numbers(3, 13);
fn element<'a>(
t: &mut Tape<'a, f64>,
u: Var,
b: usize,
h0s: &[CMat<f64>],
op: &'a [CMat<f64>],
psi0: &CMat<f64>,
target: &'a CMat<f64>,
) -> Result<Var> {
let mut psi = t.constant(Value::C(psi0.clone()));
for s in 0..3 {
let h = t.lincomb_row(&h0s[b], u, s, op)?;
let uu = t.expm_mi_dt(h, 0.5)?;
psi = t.matmul(uu, psi)?;
}
t.fidelity(target, psi)
}
let mut t = Tape::new();
let v = t.leaf(Value::R(RMat::column(x.clone())));
let m = t
.batch_mean(&[v], h0s.len(), |sub, inputs, b| {
element(sub, inputs[0], b, &h0s, &op, &psi0, &target)
})
.unwrap();
let batched = t.scalar(m).unwrap();
let g_batched = t.backward(m).unwrap().wrt_real(v, 3);
let mut t2 = Tape::new();
let v2 = t2.leaf(Value::R(RMat::column(x.clone())));
let mut acc: Option<Var> = None;
for b in 0..h0s.len() {
let f = element(&mut t2, v2, b, &h0s, &op, &psi0, &target).unwrap();
acc = Some(match acc {
None => f,
Some(a) => t2.add(a, f).unwrap(),
});
}
let mean = t2.scale(acc.unwrap(), 1.0 / h0s.len() as f64).unwrap();
let seq = t2.scalar(mean).unwrap();
let g_seq = t2.backward(mean).unwrap().wrt_real(v2, 3);
assert!((batched - seq).abs() < 1e-14);
for i in 0..3 {
assert!((g_batched[i] - g_seq[i]).abs() < 1e-13);
}
let mut t3: Tape<'_, f64> = Tape::no_grad();
let v3 = t3.constant(Value::R(RMat::column(x.clone())));
let m3 = t3
.batch_mean(&[v3], h0s.len(), |sub, inputs, b| {
element(sub, inputs[0], b, &h0s, &op, &psi0, &target)
})
.unwrap();
assert_eq!(t3.scalar(m3).unwrap(), batched);
}
#[test]
fn dual_reverse_pass_gives_hessian_vector_products() {
let h0 = hermitian(2, 300, 2.0);
let ops = vec![hermitian(2, 301, 1.0), hermitian(2, 302, 1.0)];
let psi0 = unit_vector(2, 303);
let target = unit_vector(2, 304);
let x = numbers(4, 17);
let dir = numbers(4, 18);
fn build<'t, T: Scalar>(
t: &mut Tape<'t, T>,
v: Var,
h0: &CMat<f64>,
ops: &'t [CMat<f64>],
psi0: &CMat<f64>,
target: &'t CMat<f64>,
) -> Result<Var> {
let a = t.slice(v, 0, 2)?;
let b = t.slice(v, 2, 2)?;
let u = t.hstack(&[a, b])?;
let mut psi = t.constant(Value::C(CMat::<T>::lift(psi0)));
for s in 0..2 {
let h = t.lincomb_row(h0, u, s, ops)?;
let uu = t.expm_mi_dt(h, 0.6)?;
psi = t.matmul(uu, psi)?;
}
let f = t.fidelity(target, psi)?;
let sq = t.square(v)?;
let reg = t.sum(sq)?;
let r = t.scale(reg, 0.1)?;
t.add(f, r)
}
let grad_at = |xs: &[f64]| {
let mut t = Tape::new();
let v = t.leaf(Value::R(RMat::column(xs.to_vec())));
let out = build(&mut t, v, &h0, &ops, &psi0, &target).unwrap();
t.backward(out).unwrap().wrt_real(v, 4)
};
let mut td: Tape<'_, Dual> = Tape::new();
let seeded: Vec<Dual> = x.iter().zip(&dir).map(|(&a, &d)| Dual::new(a, d)).collect();
let vd = td.leaf(Value::R(RMat::column(seeded)));
let out = build(&mut td, vd, &h0, &ops, &psi0, &target).unwrap();
let gd = td.backward(out).unwrap().wrt_real(vd, 4);
let g0 = grad_at(&x);
let h = 1e-6;
let plus: Vec<f64> = x.iter().zip(&dir).map(|(a, d)| a + h * d).collect();
let minus: Vec<f64> = x.iter().zip(&dir).map(|(a, d)| a - h * d).collect();
let (gp, gm) = (grad_at(&plus), grad_at(&minus));
for i in 0..4 {
assert!((gd[i].re - g0[i]).abs() < 1e-14, "gradient value part");
let fd = (gp[i] - gm[i]) / (2.0 * h);
assert!(
(gd[i].eps - fd).abs() < 1e-6 * fd.abs().max(1.0),
"Hv[{i}]: dual {} vs fd {fd}",
gd[i].eps
);
}
}
#[test]
fn misuse_is_reported() {
let mut t: Tape<'_, f64> = Tape::no_grad();
let v = t.constant(Value::R(RMat::column(vec![1.0])));
let s = t.sum(v).unwrap();
assert!(matches!(t.backward(s), Err(Error::NotSupported(_))));
let mut t: Tape<'_, f64> = Tape::new();
let a = t.leaf(Value::R(RMat::column(vec![1.0, 2.0])));
let b = t.leaf(Value::R(RMat::column(vec![1.0, 2.0, 3.0])));
assert!(matches!(t.add(a, b), Err(Error::Dimension(_))));
assert!(matches!(t.backward(a), Err(Error::Dimension(_))));
assert!(matches!(t.real(a), Err(Error::Dimension(_))));
}