Struct DiscreteLehmannRepresentation 

pub struct DiscreteLehmannRepresentation<S>
where
    S: StatisticsType,
{
    pub poles: Vec<f64>,
    pub beta: f64,
    pub wmax: f64,
    pub accuracy: f64,
    pub regularizers: Vec<f64>,
    /* private fields */
}

Discrete Lehmann Representation (DLR)

The DLR is a variant of the IR basis based on a “sketching” of the analytic continuation kernel K. Instead of using singular value expansion, it represents Green’s functions as a linear combination of poles on the real-frequency axis:

G(iν) = Σ_i a[i] * reg[i] / (iν - ω[i])

where:

• ω[i] are pole positions on the real axis
• a[i] are expansion coefficients
• reg[i] are regularization factors (1 for fermions, tanh(βω/2) for bosons)

Note: DLR always uses LogisticKernel-type weights, regardless of the IR basis kernel type.

Type Parameters

• S - Statistics type (Fermionic or Bosonic)

Fields

poles: Vec<f64>

Pole positions on the real-frequency axis ω ∈ [-ωmax, ωmax]

beta: f64

Inverse temperature β

wmax: f64

Maximum frequency ωmax

accuracy: f64

Accuracy of the representation

regularizers: Vec<f64>

Regularizers for each pole: regularizer[i] = w(β, ω_i) Always computed using LogisticKernel:

• Fermionic: regularizer = 1.0
• Bosonic: regularizer = tanh(β·ω/2)

Implementations

impl<S> DiscreteLehmannRepresentation<S>

where S: StatisticsType,

pub fn with_poles<K>(basis: &impl Basis<S, Kernel = K>, poles: Vec<f64>) -> Self

where S: 'static, K: KernelProperties + Clone,

Create DLR from IR basis with custom poles

Note: Always uses LogisticKernel-type weights, regardless of the basis kernel type.

Arguments

• basis - The IR basis to construct DLR from
• poles - Pole positions on the real-frequency axis

Returns

A new DLR representation

pub fn new<K>(basis: &impl Basis<S, Kernel = K>) -> Self

where S: 'static, K: KernelProperties + Clone,

Create DLR from IR basis with default pole locations

Uses the default omega sampling points from the basis.

Arguments

• basis - The IR basis to construct DLR from

Returns

A new DLR representation with default poles

Panics

Panics if the number of default poles is less than the basis size. This can happen with certain kernel types (e.g., RegularizedBoseKernel) due to numerical precision limitations in root finding.

pub fn from_ir_nd<T>( &self, backend: Option<&GemmBackendHandle>, gl: &Tensor<T, DynRank>, dim: usize, ) -> Tensor<T, DynRank>

where T: ComplexFloat + ComplexField + From<f64> + Copy + Default + 'static,

Convert IR coefficients to DLR (N-dimensional, generic over real/complex)

Type Parameters

• T - Element type (f64 or Complex)

Arguments

• gl - IR coefficients as N-D tensor
• dim - Dimension along which to transform

Returns

DLR coefficients as N-D tensor

pub fn to_ir_nd<T>( &self, backend: Option<&GemmBackendHandle>, g_dlr: &Tensor<T, DynRank>, dim: usize, ) -> Tensor<T, DynRank>

where T: ComplexFloat + ComplexField + From<f64> + Copy + Default + 'static,

Convert DLR coefficients to IR (N-dimensional, generic over real/complex)

Type Parameters

• T - Element type (f64 or Complex)

Arguments

• g_dlr - DLR coefficients as N-D tensor
• dim - Dimension along which to transform

Returns

IR coefficients as N-D tensor

Trait Implementations

impl<S> Basis<S> for DiscreteLehmannRepresentation<S>

where S: StatisticsType + 'static,

type Kernel = LogisticKernel

Associated kernel type

fn kernel(&self) -> &Self::Kernel

Get reference to the kernel

fn beta(&self) -> f64

Inverse temperature β

fn wmax(&self) -> f64

Maximum frequency ωmax

fn lambda(&self) -> f64

Kernel parameter Λ = β × ωmax

fn size(&self) -> usize

Number of basis functions

fn accuracy(&self) -> f64

Accuracy of the basis

fn significance(&self) -> Vec<f64>

Significance of each basis function

fn svals(&self) -> Vec<f64>

Get singular values (non-normalized)

fn default_tau_sampling_points(&self) -> Vec<f64>

Get default tau sampling points

fn default_matsubara_sampling_points( &self, _positive_only: bool, ) -> Vec<MatsubaraFreq<S>>

Get default Matsubara sampling points

fn evaluate_tau(&self, tau: &[f64]) -> DTensor<f64, 2>

Evaluate basis functions at imaginary time points

fn evaluate_matsubara( &self, freqs: &[MatsubaraFreq<S>], ) -> DTensor<Complex<f64>, 2>

Evaluate basis functions at Matsubara frequencies

fn evaluate_omega(&self, omega: &[f64]) -> DTensor<f64, 2>

Evaluate spectral basis functions at real frequencies

fn default_omega_sampling_points(&self) -> Vec<f64>

Get default omega (real frequency) sampling points