现代物理前沿之：量子生物学与生物量子系统

    import numpy as np
    from scipy import linalg
    
    # define the number of particles and maximum degree of the polynomial in terms of kinetic energy (K = 2n + 1)
    N = 4 
    Kmax = int((np.floor(N/2))*(np.floor(N/2)+1))
    
    # construct an array that contains all possible combinations of two particle indices i and j where i < j 
    indices = []
    for n in range(int(N/2)):
    for m in range(n):
        indices.append([m,n])
    
    # randomly generate a random density matrix rho
    rho = np.zeros((N, N), dtype='complex')
    for [i, j] in indices:
    delta = np.random.uniform(-1., 1.) * (2*np.pi)**(2./3)
    phi = np.random.uniform(0, 2*np.pi)
    expI = np.exp(delta*1.j*phi)
    
    rho[i, j] += expI / np.sqrt(N - abs(m - n)/2)
    rho[j, i] -= expI / np.sqrt(N - abs(m - n)/2)
    
    rho /= np.trace(rho).real    # normalize to trace 1
    
    
    def QD(rho):
    # construct the kinetic operator 
    T = np.array([[0., 0], [0, 1]])
    
    # construct the potential operator V
    pot_vals = [abs(rho[i, j])*T[[i, j]] for [i, j] in indices]
    V = sum(pot_vals[:Kmax])
    
    # construct the Hamiltonian H
    H = V + T + (2/3)*np.eye(N)
    
    # diagonalize H to obtain eigenvectors psi and eigenvalues lamda
    lamda, psi = np.linalg.eig(H)
    
    # sort eigenvectors and eigenvalues by increasing value of lambda
    idx = np.argsort(lamda)
    lamda = lamda[idx]
    psi = psi[:, idx]
    
    return lamda, psi, V
    
    
    # apply QD method to rho
    lamda, psi, V = QD(rho)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    % initialize system parameters
    N = 4;
    Kmax = floor((N/2)*(N/2)+1); % maximum degree of polynomial in terms of kinetic energy
    
    % generate an array containing all valid pairs of particle indices i < j with i <= j < N
    indices = cell(1, N*(N-1)/2);
    ii = 1;
    for n = 1:ceil(N/2)-1
    for m = 1:n
        indices{ii} = {m,n};
        ii = ii+1;
    end
    end
    
    % randomly generate a random density matrix rho
    rho = zeros(N,N);
    for jj = 1:length(indices)
    [i, j] = indices{jj};
    if rand() > 0.5 
        delta = rand()-0.5 ;
    else 
        delta = rand()+0.5 ;
    end
    phi = rand()*2*pi;
    rms = sqrt((N-abs(i-j))/2);
    xi = delta.*rms.* exp(i*phi);
    yi = delta.*rms.* exp(j*phi);
    rho(i,j) = xi+yi;
    rho(j,i) = conj(xi)-conj(yi);
    end
    
    rho = rho./ trace(rho(:)); 
    
    function [lambda, psi, V] = qd(rho)
    % constructs the quantum dephasing spectrum from given input density matrix rho
    % returns arrays lambda and psi, which contain the sorted eigenvalues and eigenvectors of the Hamiltonian H, respectively,
    % where H = V + T + 2/3 I is the Hamiltonian describing the free fermion problem in a box of width L, coupled to
    % a harmonic oscillator at its center using interactions U(t) = sum_{ij}(v_ji + v_ij)*a^\dag_ia^\dag_ja_ib_i, where each
    % interaction term represents an exchange between nearest neighbors i and j
    % parameter lambdamax specifies the upper bound of the frequency band considered in the calculation (default is pi/L)
    
    % first we need to build the kinetic operator T
    T = [0 0;
     0 1];
    
    % next, we need to build the potential operator V, whose elements are products of corresponding diagonal elements of rho multiplied by T
    Vvals = [];
    for kk = 1:length(indices)
    [i, j] = indices{kk};
    vi = real(rho(i,i))*T([i,i])+imag(rho(i,i))*T([i,j]);
    vj = real(rho(j,j))*T([j,j])+imag(rho(j,j))*T([j,i]);
    Vvals(kk,:) = {vi+vj, vi-vj}; % concatenate vi+vj and vi-vj into single vector entry since these form two independent pairwise interations
    end
    V = zeros(N,N);
    for kk = 1:min(Kmax, length(indices))
    V = V + Vvals(kk,:);
    end
    
    % finally, we can construct the full Hamiltonian H and diagonalize it to obtain the spectrum of eigenvalues and vectors
    H = diag(diag(rho))+V+T+(2/3)*speye(N);
    [evals, evecs] = eig(H);
    idx = sortrows(evals);
    evals = evals(idx);
    evecs = evecs(:,idx);
    
    end
    
    % call function to perform QD on rho
    [lambda, psi, V] = qd(rho);
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读