ffsim 0.0.73__tar.gz → 0.0.74__tar.gz

{ffsim-0.0.73 → ffsim-0.0.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ffsim
-Version: 0.0.73
+Version: 0.0.74
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only

{ffsim-0.0.73 → ffsim-0.0.74}/docs/conf.py

@@ -52,7 +52,7 @@ intersphinx_mapping = {
     "python": ("https://docs.python.org/3", None),
     "numpy": ("https://numpy.org/doc/stable", None),
     "scipy": ("https://docs.scipy.org/doc/scipy", None),
-    "qiskit": ("https://docs.quantum.ibm.com/api/qiskit", None),
+    "qiskit": ("https://quantum.cloud.ibm.com/docs/api/qiskit", None),
 }
 
 # nbsphinx options (for tutorials)

{ffsim-0.0.73 → ffsim-0.0.74}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "ffsim"
 requires-python = ">=3.10"
-version = "0.0.73"
+version = "0.0.74"
 description = "Faster simulation of fermionic quantum circuits."
 readme = "README.md"
 license = { file = "LICENSE" }

{ffsim-0.0.73 → ffsim-0.0.74}/python/ffsim/_lib.pyi

@@ -39,6 +39,9 @@ def apply_phase_shift_in_place(
 def apply_givens_rotation_in_place(
     vec: np.ndarray, c: float, s: complex, slice1: np.ndarray, slice2: np.ndarray
 ) -> None: ...
+def givens_decomposition(
+    mat: np.ndarray,
+) -> tuple[list[tuple[float, complex, int, int]], np.ndarray]: ...
 def apply_num_op_sum_evolution_in_place(
     vec: np.ndarray,
     phases: np.ndarray,

{ffsim-0.0.73 → ffsim-0.0.74}/python/ffsim/gates/orbital_rotation.py

@@ -20,7 +20,7 @@ import numpy as np
 from pyscf.fci import cistring
 
 from ffsim._lib import apply_givens_rotation_in_place, apply_phase_shift_in_place
-from ffsim.linalg import GivensRotation, givens_decomposition
+from ffsim.linalg import givens_decomposition
 
 
 @overload
@@ -157,8 +157,8 @@ def _apply_orbital_rotation_spinful(
 def _get_givens_decomposition(
     mat: np.ndarray | tuple[np.ndarray | None, np.ndarray | None],
 ) -> tuple[
-    tuple[list[GivensRotation], np.ndarray] | None,
-    tuple[list[GivensRotation], np.ndarray] | None,
+    tuple[list[tuple[float, complex, int, int]], np.ndarray] | None,
+    tuple[list[tuple[float, complex, int, int]], np.ndarray] | None,
 ]:
     if isinstance(mat, np.ndarray) and mat.ndim == 2:
         decomp = givens_decomposition(mat)

{ffsim-0.0.73 → ffsim-0.0.74}/python/ffsim/linalg/double_factorized_decomposition.py

@@ -1131,3 +1131,51 @@ def _double_factorized_t2_alpha_beta_explicit(
 
 def _quadrature(mat: np.ndarray, sign: int):
     return 0.5 * (1 - sign * 1j) * (mat + sign * 1j * mat.T.conj())
+
+
+def reconstruct_t2(
+    diag_coulomb_mats: np.ndarray, orbital_rotations: np.ndarray, nocc: int
+) -> np.ndarray:
+    """Reconstruct t2 amplitudes from double factorization tensors."""
+    return (
+        1j
+        * contract(
+            "kpq,kap,kip,kbq,kjq->ijab",
+            diag_coulomb_mats,
+            orbital_rotations,
+            orbital_rotations.conj(),
+            orbital_rotations,
+            orbital_rotations.conj(),
+        )[:nocc, :nocc, nocc:, nocc:]
+    )
+
+
+def reconstruct_t2_alpha_beta(
+    diag_coulomb_mats: np.ndarray,
+    orbital_rotations: np.ndarray,
+    norb: int,
+    nocc_a: int,
+    nocc_b: int,
+) -> np.ndarray:
+    """Reconstruct alpha-beta t2 amplitudes from double factorization tensors."""
+    n_terms = diag_coulomb_mats.shape[0]
+    expanded_diag_coulomb_mats = np.zeros((n_terms, 2 * norb, 2 * norb))
+    expanded_orbital_rotations = np.zeros((n_terms, 2 * norb, 2 * norb), dtype=complex)
+    for k in range(n_terms):
+        (mat_aa, mat_ab, mat_bb) = diag_coulomb_mats[k]
+        expanded_diag_coulomb_mats[k] = np.block([[mat_aa, mat_ab], [mat_ab.T, mat_bb]])
+        orbital_rotation_a, orbital_rotation_b = orbital_rotations[k]
+        expanded_orbital_rotations[k] = scipy.linalg.block_diag(
+            orbital_rotation_a, orbital_rotation_b
+        )
+    return (
+        1j
+        * contract(
+            "kpq,kap,kip,kbq,kjq->ijab",
+            expanded_diag_coulomb_mats,
+            expanded_orbital_rotations,
+            expanded_orbital_rotations.conj(),
+            expanded_orbital_rotations,
+            expanded_orbital_rotations.conj(),
+        )[:nocc_a, norb : norb + nocc_b, nocc_a:norb, norb + nocc_b :]
+    )

{ffsim-0.0.73 → ffsim-0.0.74}/python/ffsim/linalg/givens.py

@@ -17,7 +17,8 @@ from typing import NamedTuple
 
 import numpy as np
 from scipy.linalg.blas import zrotg as zrotg_
-from scipy.linalg.lapack import zrot
+
+from ffsim import _lib
 
 
 class GivensRotation(NamedTuple):
@@ -92,7 +93,7 @@ def zrotg(a: complex, b: complex, tol=1e-12) -> tuple[float, complex]:
 
 def givens_decomposition(
     mat: np.ndarray,
-) -> tuple[list[GivensRotation], np.ndarray]:
+) -> tuple[list[tuple[float, complex, int, int]], np.ndarray]:
     r"""Givens rotation decomposition of a unitary matrix.
 
     The Givens rotation decomposition of an :math:`n \times n` unitary matrix :math:`U`
@@ -145,76 +146,4 @@ def givens_decomposition(
 
     .. _Clements et al., "Optimal design for universal multiport interferometers" (2016): https://doi.org/10.1364/OPTICA.3.001460
     """  # noqa: E501
-    n, _ = mat.shape
-    current_matrix = mat.astype(complex, copy=True)
-    left_rotations = []
-    right_rotations = []
-
-    # compute left and right Givens rotations
-    for i in range(n - 1):
-        if i % 2 == 0:
-            # rotate columns by right multiplication
-            for j in range(i + 1):
-                target_index = i - j
-                row = n - j - 1
-                if not cmath.isclose(current_matrix[row, target_index], 0.0):
-                    # zero out element at target index in given row
-                    c, s = zrotg(
-                        current_matrix[row, target_index + 1],
-                        current_matrix[row, target_index],
-                    )
-                    right_rotations.append(
-                        GivensRotation(c, s, target_index + 1, target_index)
-                    )
-                    (
-                        current_matrix[:, target_index + 1],
-                        current_matrix[:, target_index],
-                    ) = zrot(
-                        current_matrix[:, target_index + 1],
-                        current_matrix[:, target_index],
-                        c,
-                        s,
-                    )
-        else:
-            # rotate rows by left multiplication
-            for j in range(i + 1):
-                target_index = n - i + j - 1
-                col = j
-                if not cmath.isclose(current_matrix[target_index, col], 0.0):
-                    # zero out element at target index in given column
-                    c, s = zrotg(
-                        current_matrix[target_index - 1, col],
-                        current_matrix[target_index, col],
-                    )
-                    left_rotations.append(
-                        GivensRotation(c, s, target_index - 1, target_index)
-                    )
-                    (
-                        current_matrix[target_index - 1],
-                        current_matrix[target_index],
-                    ) = zrot(
-                        current_matrix[target_index - 1],
-                        current_matrix[target_index],
-                        c,
-                        s,
-                    )
-
-    # convert left rotations to right rotations
-    for c, s, i, j in reversed(left_rotations):
-        c, s = zrotg(c * current_matrix[j, j], s.conjugate() * current_matrix[i, i])
-        right_rotations.append(
-            # clamp c between -1 and 1 to account for floating point error
-            GivensRotation(min(1.0, max(-1.0, c)), -s.conjugate(), i, j)
-        )
-
-        givens_mat = np.array([[c, -s], [s.conjugate(), c]])
-        givens_mat[:, 0] *= current_matrix[i, i]
-        givens_mat[:, 1] *= current_matrix[j, j]
-        c, s = zrotg(givens_mat[1, 1], givens_mat[1, 0])
-        new_givens_mat = np.array([[c, s], [-s.conjugate(), c]])
-        phase_matrix = givens_mat @ new_givens_mat
-        current_matrix[i, i] = phase_matrix[0, 0]
-        current_matrix[j, j] = phase_matrix[1, 1]
-
-    # return decomposition
-    return right_rotations, np.diagonal(current_matrix)
+    return _lib.givens_decomposition(np.asarray(mat, dtype=complex))

{ffsim-0.0.73 → ffsim-0.0.74}/python/ffsim/operators/fermion_action.py

@@ -14,7 +14,13 @@ from typing import NamedTuple
 
 
 class FermionAction(NamedTuple):
-    """A fermionic action."""
+    """A fermionic action.
+
+    Args:
+        action: ``False`` = destroy (annihilate), ``True`` = create
+        spin: ``False`` = alpha (spin up), ``True`` = beta (spin down)
+        orb: Index of the orbital to act on
+    """
 
     action: bool  # False = destroy (annihilate), True = create
     spin: bool  # False = alpha, True = beta

{ffsim-0.0.73 → ffsim-0.0.74}/python/ffsim/variational/ucj_spin_balanced.py

@@ -13,10 +13,12 @@
 from __future__ import annotations
 
 import itertools
+import math
 from dataclasses import InitVar, dataclass
 from typing import cast
 
 import numpy as np
+import pyscf.ci
 
 from ffsim import gates, linalg, protocols
 from ffsim.linalg.util import unitary_from_parameters, unitary_to_parameters
@@ -532,6 +534,130 @@ class UCJOpSpinBalanced(
             final_orbital_rotation=final_orbital_rotation,
         )
 
+    @staticmethod
+    def from_cisd_vec(
+        cisd_vec: np.ndarray,
+        *,
+        norb: int,
+        nocc: int,
+        c0_threshold: float = 1e-12,
+        n_reps: int | None = None,
+        interaction_pairs: tuple[
+            list[tuple[int, int]] | None, list[tuple[int, int]] | None
+        ]
+        | None = None,
+        tol: float = 1e-8,
+        optimize: bool = False,
+        method: str = "L-BFGS-B",
+        callback=None,
+        options: dict | None = None,
+        regularization: float = 0,
+        multi_stage_start: int | None = None,
+        multi_stage_step: int | None = None,
+    ) -> UCJOpSpinBalanced:
+        r"""Initialize the UCJ operator from a CISD vector.
+
+        The CISD amplitudes are converted to CC-style amplitudes using
+
+        .. math::
+
+            t_{1,ia} = \frac{c^{(1)}_{ia}}{c_0},
+            \qquad
+            t_{2,ijab} = \frac{c^{(2)}_{ijab}}{c_0} - \frac{t_{1,ia} t_{1,jb}}{2},
+
+        and the resulting amplitudes are then passed to
+        :meth:`from_t_amplitudes`.
+
+        Args:
+            cisd_vec: The CISD vector. This is a one-dimensional array containing the
+                reference coefficient :math:`c_0` in the first entry, followed by the
+                singles and then doubles coefficients.
+            norb: The number of spatial orbitals.
+            nocc: The number of occupied orbitals.
+            c0_threshold: Absolute value threshold for the reference coefficient. An
+                error is raised if the absolute value of :math:`c_0` is smaller than
+                this threshold.
+            n_reps: The number of ansatz repetitions. If not specified, then it is set
+                to the number of terms resulting from the double factorization of the
+                t2 amplitudes. If the specified number of repetitions is larger than the
+                number of terms resulting from the double factorization, then the ansatz
+                is padded with additional identity operators up to the specified number
+                of repetitions.
+            interaction_pairs: Optional restrictions on allowed orbital interactions
+                for the diagonal Coulomb operators.
+                If specified, `interaction_pairs` should be a pair of lists,
+                for alpha-alpha and alpha-beta interactions, in that order.
+                Either list can be substituted with ``None`` to indicate no restrictions
+                on interactions.
+                Each list should contain pairs of integers representing the orbitals
+                that are allowed to interact. These pairs can also be interpreted as
+                indices of diagonal Coulomb matrix entries that are allowed to be
+                nonzero.
+                Each integer pair must be upper triangular, that is, of the form
+                :math:`(i, j)` where :math:`i \leq j`.
+            tol: Tolerance for error in the double-factorized decomposition of the
+                converted t2 amplitudes.
+                The error is defined as the maximum absolute difference between
+                an element of the original tensor and the corresponding element of
+                the reconstructed tensor.
+            optimize: Whether to optimize the tensors returned by the decomposition to
+                to minimize the error in the factorization.
+            method: The optimization method. See the documentation of
+                `scipy.optimize.minimize`_ for possible values.
+                This argument is ignored if `optimize` is set to ``False``.
+            callback: Callback function for the optimization. See the documentation of
+                `scipy.optimize.minimize`_ for usage.
+                This argument is ignored if `optimize` is set to ``False``.
+            options: Options for the optimization. See the documentation of
+                `scipy.optimize.minimize`_ for usage.
+                This argument is ignored if `optimize` is set to ``False``.
+            regularization: See :func:`ffsim.linalg.double_factorized_t2` for a
+                description of this argument.
+                This argument is ignored if `optimize` is set to ``False``.
+            multi_stage_start: See :func:`ffsim.linalg.double_factorized_t2` for a
+                description of this argument.
+                This argument is ignored if `optimize` is set to ``False``.
+            multi_stage_step: See :func:`ffsim.linalg.double_factorized_t2` for a
+                description of this argument.
+                This argument is ignored if `optimize` is set to ``False``.
+
+        Returns:
+            The UCJ operator with parameters initialized from the CISD amplitudes.
+
+        Raises:
+            ValueError: The CISD reference coefficient is smaller than the
+                specified threshold c0_tol.
+
+        .. _scipy.optimize.minimize: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
+        """
+        c0, c1, c2 = pyscf.ci.cisd.cisdvec_to_amplitudes(
+            cisd_vec, norb, nocc, copy=False
+        )
+
+        if math.isclose(c0, 0.0, abs_tol=c0_threshold):
+            raise ValueError(
+                f"CISD reference coefficient c0={c0} is smaller than the"
+                f"specified threshold, c0_tol={c0_threshold}."
+            )
+
+        t1 = c1 / c0
+        t2 = c2 / c0 - 0.5 * np.einsum("ia,jb->ijab", t1, t1)
+
+        return UCJOpSpinBalanced.from_t_amplitudes(
+            t2,
+            t1=t1,
+            n_reps=n_reps,
+            interaction_pairs=interaction_pairs,
+            tol=tol,
+            optimize=optimize,
+            method=method,
+            callback=callback,
+            options=options,
+            regularization=regularization,
+            multi_stage_start=multi_stage_start,
+            multi_stage_step=multi_stage_step,
+        )
+
     def _apply_unitary_(
         self, vec: np.ndarray, norb: int, nelec: int | tuple[int, int], copy: bool
     ) -> np.ndarray:

{ffsim-0.0.73 → ffsim-0.0.74}/src/gates/orbital_rotation.rs

@@ -8,10 +8,6 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
-extern crate blas_src;
-
-use blas::zdrot;
-use blas::zscal;
 use numpy::Complex64;
 use numpy::PyReadonlyArray1;
 
@@ -36,11 +32,6 @@ pub fn apply_givens_rotation_in_place(
     let slice1 = slice1.as_array();
     let slice2 = slice2.as_array();
     let dim_b = vec.shape()[1];
-    let dim_b_i32 = dim_b as i32;
-    let s_abs = s.norm();
-    let angle = s.arg();
-    let phase = Complex64::new(angle.cos(), angle.sin());
-    let phase_conj = phase.conj();
 
     let n_pairs = slice1.len();
     let n_threads = std::env::var("RAYON_NUM_THREADS")
@@ -61,9 +52,7 @@ pub fn apply_givens_rotation_in_place(
         let vec_ptr = vec.as_mut_ptr();
         for (&i, &j) in slice1_slice.iter().zip(slice2_slice) {
             unsafe {
-                _apply_givens_rotation_to_pair(
-                    vec_ptr, i, j, dim_b, dim_b_i32, c, s_abs, phase, phase_conj,
-                );
+                _apply_givens_rotation_to_pair(vec_ptr, i, j, dim_b, c, s);
             }
         }
         return;
@@ -85,9 +74,7 @@ pub fn apply_givens_rotation_in_place(
                 let vec_ptr = vec_ptr as *mut Complex64;
                 for (&i, &j) in slice1_chunk.iter().zip(slice2_chunk) {
                     unsafe {
-                        _apply_givens_rotation_to_pair(
-                            vec_ptr, i, j, dim_b, dim_b_i32, c, s_abs, phase, phase_conj,
-                        );
+                        _apply_givens_rotation_to_pair(vec_ptr, i, j, dim_b, c, s);
                     }
                 }
             });
@@ -96,23 +83,20 @@ pub fn apply_givens_rotation_in_place(
 }
 
 /// Apply Givens rotation to a pair of rows
-#[allow(clippy::too_many_arguments)]
 unsafe fn _apply_givens_rotation_to_pair(
     vec_ptr: *mut Complex64,
     i: usize,
     j: usize,
     dim_b: usize,
-    dim_b_i32: i32,
     c: f64,
-    s_abs: f64,
-    phase: Complex64,
-    phase_conj: Complex64,
+    s: Complex64,
 ) {
     let row_i = std::slice::from_raw_parts_mut(vec_ptr.add(i * dim_b), dim_b);
     let row_j = std::slice::from_raw_parts_mut(vec_ptr.add(j * dim_b), dim_b);
-    // Use zdrot and zscal because zrot is not currently available
-    // See https://github.com/qiskit-community/ffsim/issues/28
-    zscal(dim_b_i32, phase_conj, row_i, 1);
-    zdrot(dim_b_i32, row_i, 1, row_j, 1, c, s_abs);
-    zscal(dim_b_i32, phase, row_i, 1);
+    for k in 0..dim_b {
+        let i_old = row_i[k];
+        let j_old = row_j[k];
+        row_i[k] = c * i_old + s * j_old;
+        row_j[k] = c * j_old - s.conj() * i_old;
+    }
 }

{ffsim-0.0.73 → ffsim-0.0.74}/src/lib.rs

@@ -14,6 +14,7 @@ mod contract;
 mod fermion_operator;
 mod gates;
 mod jordan_wigner;
+mod linalg;
 
 /// Python module exposing Rust extensions.
 #[pymodule]
@@ -38,6 +39,7 @@ fn _lib(m: &Bound<'_, PyModule>) -> PyResult<()> {
         gates::diag_coulomb::apply_diag_coulomb_evolution_in_place_z_rep,
         m
     )?)?;
+    m.add_function(wrap_pyfunction!(linalg::givens::givens_decomposition, m)?)?;
     m.add_function(wrap_pyfunction!(
         contract::diag_coulomb::contract_diag_coulomb_into_buffer_num_rep,
         m

ffsim-0.0.74/src/linalg/givens.rs

@@ -0,0 +1,148 @@
+// (C) Copyright IBM 2026
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+use blas::zrotg as zrotg_blas;
+use ndarray::Array2;
+use numpy::{Complex64, IntoPyArray, PyArray1, PyReadonlyArray2};
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+type GivensRotationTuple = (f64, Complex64, usize, usize);
+type GivensDecompositionResult = (Vec<GivensRotationTuple>, Py<PyArray1<Complex64>>);
+
+fn zrotg_safe(a: Complex64, b: Complex64, tol: f64) -> (f64, Complex64) {
+    if a.norm() <= tol {
+        return (0.0, Complex64::new(1.0, 0.0));
+    }
+    if b.norm() <= tol {
+        return (1.0, Complex64::new(0.0, 0.0));
+    }
+    let mut a_mut = a;
+    let mut c = 0.0;
+    let mut s = Complex64::new(0.0, 0.0);
+    unsafe {
+        zrotg_blas(&mut a_mut, b, &mut c, &mut s);
+    }
+    (c, s)
+}
+
+fn rotate_columns_in_place(
+    mat: &mut Array2<Complex64>,
+    col_x: usize,
+    col_y: usize,
+    c: f64,
+    s: Complex64,
+) {
+    let n_rows = mat.nrows();
+    for row in 0..n_rows {
+        let x_old = mat[[row, col_x]];
+        let y_old = mat[[row, col_y]];
+        mat[[row, col_x]] = c * x_old + s * y_old;
+        mat[[row, col_y]] = c * y_old - s.conj() * x_old;
+    }
+}
+
+fn rotate_rows_in_place(
+    mat: &mut Array2<Complex64>,
+    row_x: usize,
+    row_y: usize,
+    c: f64,
+    s: Complex64,
+) {
+    let n_cols = mat.ncols();
+    for col in 0..n_cols {
+        let x_old = mat[[row_x, col]];
+        let y_old = mat[[row_y, col]];
+        mat[[row_x, col]] = c * x_old + s * y_old;
+        mat[[row_y, col]] = c * y_old - s.conj() * x_old;
+    }
+}
+
+/// Givens rotation decomposition of a unitary matrix.
+#[pyfunction]
+pub fn givens_decomposition(
+    py: Python<'_>,
+    mat: PyReadonlyArray2<Complex64>,
+) -> PyResult<GivensDecompositionResult> {
+    let mat_view = mat.as_array();
+    let shape = mat_view.shape();
+    if shape[0] != shape[1] {
+        return Err(PyValueError::new_err("mat must be a square matrix"));
+    }
+    let n = shape[0];
+    let mut current_matrix: Array2<Complex64> = mat_view.to_owned();
+    let mut left_rotations: Vec<GivensRotationTuple> = Vec::new();
+    let mut right_rotations: Vec<GivensRotationTuple> = Vec::new();
+    let tol = 1e-12;
+
+    for i in 0..n.saturating_sub(1) {
+        if i % 2 == 0 {
+            for j in 0..=i {
+                let target_index = i - j;
+                let row = n - j - 1;
+                if current_matrix[[row, target_index]] != Complex64::new(0.0, 0.0) {
+                    let (c, s) = zrotg_safe(
+                        current_matrix[[row, target_index + 1]],
+                        current_matrix[[row, target_index]],
+                        tol,
+                    );
+                    right_rotations.push((c, s, target_index + 1, target_index));
+                    rotate_columns_in_place(
+                        &mut current_matrix,
+                        target_index + 1,
+                        target_index,
+                        c,
+                        s,
+                    );
+                }
+            }
+        } else {
+            for j in 0..=i {
+                let target_index = n - i + j - 1;
+                let col = j;
+                if current_matrix[[target_index, col]] != Complex64::new(0.0, 0.0) {
+                    let (c, s) = zrotg_safe(
+                        current_matrix[[target_index - 1, col]],
+                        current_matrix[[target_index, col]],
+                        tol,
+                    );
+                    left_rotations.push((c, s, target_index - 1, target_index));
+                    rotate_rows_in_place(&mut current_matrix, target_index - 1, target_index, c, s);
+                }
+            }
+        }
+    }
+
+    for &(c_left, s_left, i, j) in left_rotations.iter().rev() {
+        let (c, s) = zrotg_safe(
+            Complex64::new(c_left, 0.0) * current_matrix[[j, j]],
+            s_left.conj() * current_matrix[[i, i]],
+            tol,
+        );
+
+        right_rotations.push((c.clamp(-1.0, 1.0), -s.conj(), i, j));
+
+        let diag_i = current_matrix[[i, i]];
+        let diag_j = current_matrix[[j, j]];
+        let g00 = Complex64::new(c, 0.0) * diag_i;
+        let g01 = -s * diag_j;
+        let g10 = s.conj() * diag_i;
+        let g11 = Complex64::new(c, 0.0) * diag_j;
+        let (c_new, s_new) = zrotg_safe(g11, g10, tol);
+
+        let phase00 = g00 * Complex64::new(c_new, 0.0) + g01 * (-s_new.conj());
+        let phase11 = g10 * s_new + g11 * Complex64::new(c_new, 0.0);
+        current_matrix[[i, i]] = phase00;
+        current_matrix[[j, j]] = phase11;
+    }
+
+    let diagonal = current_matrix.diag().to_owned();
+    Ok((right_rotations, diagonal.into_pyarray(py).unbind()))
+}

ffsim-0.0.74/src/linalg/mod.rs

@@ -0,0 +1,11 @@
+// (C) Copyright IBM 2026
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+pub mod givens;