def test_vbc_svd_decomps():
molecule = build_h4square_moleculardata()
oei, tei = molecule.get_integrals()
nele = 4
nalpha = 2
nbeta = 2
sz = 0
norbs = oei.shape[0]
nso = 2 * norbs
fqe_wf = fqe.Wavefunction([[nele, sz, norbs]])
fqe_wf.set_wfn(strategy='random')
fqe_wf.normalize()
_, tpdm = fqe_wf.sector((nele, sz)).get_openfermion_rdms()
d3 = fqe_wf.sector((nele, sz)).get_three_pdm()
adapt = VBC(oei, tei, nalpha, nbeta, iter_max=50)
acse_residual = two_rdo_commutator_symm(adapt.reduced_ham.two_body_tensor,
tpdm, d3)
new_residual = np.zeros_like(acse_residual)
for p, q, r, s in product(range(nso), repeat=4):
new_residual[p, q, r, s] = (acse_residual[p, q, r, s] -
acse_residual[s, r, q, p]) / 2
sos_op = adapt.get_svd_tensor_decomp(new_residual, None)
# reconstruct tensor from sop
test_tensor = np.zeros_like(new_residual)
for v, cc in zip(sos_op.basis_rotation, sos_op.charge_charge):
vc = v.conj()
test_tensor += np.einsum('pi,si,ij,qj,rj->pqrs', v, vc, -1j * cc, v,
vc)
assert np.allclose(test_tensor, new_residual)
def test_solver_via_rdms():
molecule = build_lih_moleculardata()
n_electrons = molecule.n_electrons
sz = 0
oei, tei = molecule.get_integrals()
elec_hamil = fqe.restricted_hamiltonian.RestrictedHamiltonian(
(oei, np.einsum("ijlk", -0.5 * tei)))
soei, stei = spinorb_from_spatial(oei, tei)
astei = np.einsum('ijkl', stei) - np.einsum('ijlk', stei)
molecular_hamiltonian = of.InteractionOperator(0, soei, 0.25 * astei)
reduced_ham = of.chem.make_reduced_hamiltonian(molecular_hamiltonian,
molecule.n_electrons)
fqe_wf = fqe.Wavefunction([[n_electrons, sz, molecule.n_orbitals]])
graph = fqe_wf.sector((n_electrons, sz)).get_fcigraph()
fci_coeffs = np.zeros((graph.lena(), graph.lenb()), dtype=np.complex128)
fci_coeffs[0, 0] = 1.0
fqe_wf.set_wfn(strategy="from_data",
raw_data={(n_electrons, sz): fci_coeffs})
bcsolve = BrillouinCondition(molecule, run_parallel=False)
assert bcsolve.reduced_ham == reduced_ham
for pp, qq in zip(elec_hamil.tensors(), bcsolve.elec_hamil.tensors()):
assert np.allclose(pp, qq)
bcsolve.iter_max = 1
bcsolve.bc_solve_rdms(fqe_wf)
assert np.allclose(bcsolve.acse_energy,
[-8.957417182801088, -8.969256797233033])
def davidson_diagonalization(
hamiltonian: fqe.restricted_hamiltonian.RestrictedHamiltonian,
n_alpha: int,
n_beta: int,
nroots=1,
guess_vecs=None):
norb = hamiltonian.dim() # this should be the num_orbitals
nele = n_alpha + n_beta
sz = n_alpha - n_beta
wfn = fqe.Wavefunction([[nele, sz, norb]])
graph = wfn.sector((nele, sz)).get_fcigraph()
# Generate Guess Vecs for Davidson-Liu
if guess_vecs is None:
guess_vec1_coeffs = np.zeros((graph.lena(), graph.lenb()))
guess_vec2_coeffs = np.zeros((graph.lena(), graph.lenb()))
alpha_hf = fqe.util.init_bitstring_groundstate(n_alpha)
beta_hf = fqe.util.init_bitstring_groundstate(n_beta)
guess_vec1_coeffs[graph.index_alpha(alpha_hf),
graph.index_beta(beta_hf)] = 1.0
guess_vec2_coeffs[graph.index_alpha(alpha_hf << 1),
graph.index_beta(beta_hf << 1)] = 1.0
guess_wfn1 = copy.deepcopy(wfn)
guess_wfn2 = copy.deepcopy(wfn)
guess_wfn1.set_wfn(
strategy="from_data",
raw_data={(nele, sz): guess_vec1_coeffs},
)
guess_wfn2.set_wfn(
strategy="from_data",
raw_data={(nele, sz): guess_vec2_coeffs},
)
fqe_random = fqe.Wavefunction([[nele, sz, norb]])
fqe_random.set_wfn(strategy='random')
fqe_random.sector((nele, sz)).coeff.imag = 0
fqe_random.normalize()
guess_vecs = [guess_wfn1, guess_wfn2, fqe_random]
# run FQE-DL
dl_w, dl_v = davidsonliu_fqe(hamiltonian,
nroots,
guess_vecs,
nele=nele,
sz=sz,
norb=norb)
return dl_w, dl_v
def test_double_factorization_trotter():
norbs = 4
n_elec = norbs
sz = 0
time = 0.126
fqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])
fqe_wfn.set_wfn(strategy="random")
fqe_wfn.print_wfn()
initial_wf = fqe.to_cirq_ncr(fqe_wfn).reshape((-1, 1))
basis_change_unitaries = []
for ii in range(2):
basis_change_unitaries.append(
random_unitary_matrix(4, real=False, seed=ii))
vij_mats = []
for ii in range(1):
vij_mats.append(random_hermitian_matrix(norbs, real=True, seed=ii))
with pytest.raises(ValueError):
_ = double_factor_trotter_evolution(fqe_wfn,
basis_change_unitaries + [0],
vij_mats=vij_mats,
deltat=0)
final_wfn = double_factor_trotter_evolution(
initial_wfn=fqe_wfn,
basis_change_unitaries=basis_change_unitaries,
vij_mats=vij_mats,
deltat=time,
)
intermediate_wfn = evolve_wf_givens(initial_wf.copy(),
basis_change_unitaries[0])
for step in range(1, len(basis_change_unitaries)):
intermediate_wfn = evolve_wf_diagonal_coulomb(intermediate_wfn,
vij_mats[step - 1], time)
intermediate_wfn = evolve_wf_givens(intermediate_wfn,
basis_change_unitaries[step])
test_final_wfn = fqe.from_cirq(intermediate_wfn.flatten(), 1.0e-12)
assert np.allclose(final_wfn.rdm("i^ j"), test_final_wfn.rdm("i^ j"))
assert np.allclose(final_wfn.rdm("i^ j^ k l"),
test_final_wfn.rdm("i^ j^ k l"))
test_final_wfn = double_factor_trotter_wf_evolution(
initial_wf.copy(), basis_change_unitaries, vij_mats, time)
test_final_wfn = fqe.from_cirq(test_final_wfn.flatten(), 1.0e-12)
assert np.allclose(final_wfn.rdm("i^ j"), test_final_wfn.rdm("i^ j"))
assert np.allclose(final_wfn.rdm("i^ j^ k l"),
test_final_wfn.rdm("i^ j^ k l"))
def test_vbc():
molecule = build_lih_moleculardata()
n_electrons = molecule.n_electrons
oei, tei = molecule.get_integrals()
nalpha = molecule.n_electrons // 2
nbeta = nalpha
sz = nalpha - nbeta
fqe_wf = fqe.Wavefunction([[n_electrons, sz, molecule.n_orbitals]])
fqe_wf.set_wfn(strategy='hartree-fock')
adapt = VBC(oei, tei, nalpha, nbeta, iter_max=1, verbose=False)
adapt.vbc(fqe_wf)
assert np.isclose(adapt.energies[0], -8.957417182801091)
assert np.isclose(adapt.energies[-1], -8.97304439380826)
def test_fqe_givens():
"""Test Givens Rotation evolution for correctness."""
# set up
norbs = 4
n_elec = norbs
sz = 0
n_qubits = 2 * norbs
time = 0.126
fqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])
fqe_wfn.set_wfn(strategy="random")
ikappa = random_quadratic_hamiltonian(
norbs,
conserves_particle_number=True,
real=False,
expand_spin=False,
seed=2,
)
fqe_ham = RestrictedHamiltonian((ikappa.n_body_tensors[1, 0], ))
u = expm(-1j * ikappa.n_body_tensors[1, 0] * time)
# time-evolve
final_fqe_wfn = fqe_wfn.time_evolve(time, fqe_ham)
spin_ham = np.kron(ikappa.n_body_tensors[1, 0], np.eye(2))
assert of.is_hermitian(spin_ham)
ikappa_spin = of.InteractionOperator(
constant=0,
one_body_tensor=spin_ham,
two_body_tensor=np.zeros((n_qubits, n_qubits, n_qubits, n_qubits)),
)
bigU = expm(-1j * of.get_sparse_operator(ikappa_spin).toarray() * time)
initial_wf = fqe.to_cirq(fqe_wfn).reshape((-1, 1))
final_wf = bigU @ initial_wf
final_wfn_test = fqe.from_cirq(final_wf.flatten(), 1.0e-12)
assert np.allclose(final_fqe_wfn.rdm("i^ j"), final_wfn_test.rdm("i^ j"))
assert np.allclose(final_fqe_wfn.rdm("i^ j^ k l"),
final_wfn_test.rdm("i^ j^ k l"))
final_wfn_test2 = fqe.from_cirq(
evolve_wf_givens(initial_wf.copy(), u.copy()).flatten(), 1.0e-12)
givens_fqe_wfn = evolve_fqe_givens(fqe_wfn, u.copy())
assert np.allclose(givens_fqe_wfn.rdm("i^ j"), final_wfn_test2.rdm("i^ j"))
assert np.allclose(givens_fqe_wfn.rdm("i^ j^ k l"),
final_wfn_test2.rdm("i^ j^ k l"))
def test_adapt():
molecule = build_lih_moleculardata()
n_electrons = molecule.n_electrons
oei, tei = molecule.get_integrals()
norbs = molecule.n_orbitals
nalpha = molecule.n_electrons // 2
nbeta = nalpha
sz = nalpha - nbeta
occ = list(range(nalpha))
virt = list(range(nalpha, norbs))
soei, stei = spinorb_from_spatial(oei, tei)
astei = np.einsum('ijkl', stei) - np.einsum('ijlk', stei)
molecular_hamiltonian = of.InteractionOperator(0, soei, 0.25 * astei)
reduced_ham = of.chem.make_reduced_hamiltonian(molecular_hamiltonian,
molecule.n_electrons)
fqe_wf = fqe.Wavefunction([[n_electrons, sz, molecule.n_orbitals]])
fqe_wf.set_wfn(strategy='hartree-fock')
sop = OperatorPool(norbs, occ, virt)
sop.two_body_sz_adapted() # initialize pool
adapt = ADAPT(oei, tei, sop, nalpha, nbeta, iter_max=1, verbose=False)
assert np.isclose(
np.linalg.norm(adapt.reduced_ham.two_body_tensor -
reduced_ham.two_body_tensor), 0)
adapt.adapt_vqe(fqe_wf)
assert np.isclose(adapt.energies[0], -8.957417182801091)
assert np.isclose(adapt.energies[-1], -8.970532463968661)
sop = OperatorPool(norbs, occ, virt)
sop.one_body_sz_adapted()
adapt = ADAPT(oei,
tei,
sop,
nalpha,
nbeta,
iter_max=10,
stopping_epsilon=10,
verbose=True)
adapt.adapt_vqe(fqe_wf)
assert np.isclose(adapt.energies[-1], -8.957417182801091)
assert np.isclose(adapt.energies[0], -8.95741717733075)
def test_vbc_time_evolve():
molecule = build_h4square_moleculardata()
oei, tei = molecule.get_integrals()
nele = molecule.n_electrons
nalpha = nele // 2
nbeta = nele // 2
sz = 0
norbs = oei.shape[0]
nso = 2 * norbs
fqe_wf = fqe.Wavefunction([[nele, sz, norbs]])
fqe_wf.set_wfn(strategy='random')
fqe_wf.normalize()
nfqe_wf = fqe.get_number_conserving_wavefunction(nele, norbs)
nfqe_wf.sector((nele, sz)).coeff = fqe_wf.sector((nele, sz)).coeff
_, tpdm = nfqe_wf.sector((nele, sz)).get_openfermion_rdms()
d3 = nfqe_wf.sector((nele, sz)).get_three_pdm()
adapt = VBC(oei, tei, nalpha, nbeta, iter_max=50)
acse_residual = two_rdo_commutator_symm(adapt.reduced_ham.two_body_tensor,
tpdm, d3)
sos_op = adapt.get_takagi_tensor_decomp(acse_residual, None)
test_wf = copy.deepcopy(nfqe_wf)
test_wf = sos_op.time_evolve(test_wf)
true_wf = copy.deepcopy(nfqe_wf)
for v, cc in zip(sos_op.basis_rotation, sos_op.charge_charge):
vc = v.conj()
new_tensor = np.einsum('pi,si,ij,qj,rj->pqrs', v, vc, -1j * cc, v, vc)
if np.isclose(np.linalg.norm(new_tensor), 0):
continue
fop = of.FermionOperator()
for p, q, r, s in product(range(nso), repeat=4):
op = ((p, 1), (s, 0), (q, 1), (r, 0))
fop += of.FermionOperator(op, coefficient=new_tensor[p, q, r, s])
fqe_op = build_hamiltonian(1j * fop, conserve_number=True)
true_wf = true_wf.time_evolve(1, fqe_op)
true_wf = evolve_fqe_givens_unrestricted(true_wf, sos_op.one_body_rotation)
assert np.isclose(abs(fqe.vdot(true_wf, test_wf))**2, 1)
def test_charge_charge_evolution():
norbs = 4
n_elec = norbs
sz = 0
time = 0.126
fqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])
fqe_wfn.set_wfn(strategy="random")
initial_fqe_wfn = copy.deepcopy(fqe_wfn)
initial_wf = fqe.to_cirq(fqe_wfn).reshape((-1, 1))
# time-evolve
vij = np.random.random((norbs, norbs))
vij = vij + vij.T
final_fqe_wfn = evolve_fqe_diagaonal_coulomb(initial_fqe_wfn, vij, time)
test_wfn = evolve_wf_diagonal_coulomb(wf=initial_wf,
vij_mat=vij,
time=time)
test_wfn = fqe.from_cirq(test_wfn.flatten(), 1.0e-12)
assert np.allclose(final_fqe_wfn.rdm("i^ j"), test_wfn.rdm("i^ j"))
assert np.allclose(final_fqe_wfn.rdm("i^ j^ k l"),
test_wfn.rdm("i^ j^ k l"))
def test_generalized_doubles_takagi():
molecule = build_lih_moleculardata()
oei, tei = molecule.get_integrals()
nele = 4
nalpha = 2
nbeta = 2
sz = 0
norbs = oei.shape[0]
nso = 2 * norbs
fqe_wf = fqe.Wavefunction([[nele, sz, norbs]])
fqe_wf.set_wfn(strategy='hartree-fock')
fqe_wf.normalize()
_, tpdm = fqe_wf.sector((nele, sz)).get_openfermion_rdms()
d3 = fqe_wf.sector((nele, sz)).get_three_pdm()
soei, stei = spinorb_from_spatial(oei, tei)
astei = np.einsum('ijkl', stei) - np.einsum('ijlk', stei)
molecular_hamiltonian = of.InteractionOperator(0, soei, 0.25 * astei)
reduced_ham = make_reduced_hamiltonian(molecular_hamiltonian,
nalpha + nbeta)
acse_residual = two_rdo_commutator_symm(reduced_ham.two_body_tensor, tpdm,
d3)
for p, q, r, s in product(range(nso), repeat=4):
if p == q or r == s:
continue
assert np.isclose(acse_residual[p, q, r, s],
-acse_residual[s, r, q, p].conj())
Zlp, Zlm, _, one_body_residual = doubles_factorization_takagi(acse_residual)
test_fop = get_fermion_op(one_body_residual)
# test the first four factors
for ll in range(4):
test_fop += 0.25 * get_fermion_op(Zlp[ll])**2
test_fop += 0.25 * get_fermion_op(Zlm[ll])**2
op1mat = Zlp[ll]
op2mat = Zlm[ll]
w1, v1 = sp.linalg.schur(op1mat)
w1 = np.diagonal(w1)
assert np.allclose(v1 @ np.diag(w1) @ v1.conj().T, op1mat)
v1c = v1.conj()
w2, v2 = sp.linalg.schur(op2mat)
w2 = np.diagonal(w2)
assert np.allclose(v2 @ np.diag(w2) @ v2.conj().T, op2mat)
oww1 = np.outer(w1, w1)
fqe_wf = fqe.Wavefunction([[nele, sz, norbs]])
fqe_wf.set_wfn(strategy='hartree-fock')
fqe_wf.normalize()
nfqe_wf = fqe.get_number_conserving_wavefunction(nele, norbs)
nfqe_wf.sector((nele, sz)).coeff = fqe_wf.sector((nele, sz)).coeff
this_generatory = np.einsum('pi,si,ij,qj,rj->pqrs', v1, v1c, oww1, v1,
v1c)
fop = of.FermionOperator()
for p, q, r, s in product(range(nso), repeat=4):
op = ((p, 1), (s, 0), (q, 1), (r, 0))
fop += of.FermionOperator(op,
coefficient=this_generatory[p, q, r, s])
fqe_fop = build_hamiltonian(1j * fop, norb=norbs, conserve_number=True)
exact_wf = fqe.apply_generated_unitary(nfqe_wf, 1, 'taylor', fqe_fop)
test_wf = fqe.algorithm.low_rank.evolve_fqe_givens_unrestricted(
nfqe_wf,
v1.conj().T)
test_wf = fqe.algorithm.low_rank.evolve_fqe_charge_charge_unrestricted(
test_wf, -oww1.imag)
test_wf = fqe.algorithm.low_rank.evolve_fqe_givens_unrestricted(
test_wf, v1)
assert np.isclose(abs(fqe.vdot(test_wf, exact_wf))**2, 1)
import numpy
import fqe
from fqe.unittest_data import build_lih_data, build_hamiltonian
numpy.set_printoptions(floatmode='fixed',
precision=6,
linewidth=80,
suppress=True)
numpy.random.seed(seed=409)
h1e, h2e, wfn = build_lih_data.build_lih_data('energy')
lih_hamiltonian = fqe.get_restricted_hamiltonian(([ # type: ignore
h1e, h2e
]))
print(lih_hamiltonian._tensor)
lihwfn = fqe.Wavefunction([[4, 0, 6]])
lihwfn.set_wfn(strategy='from_data', raw_data={(4, 0): wfn})
time = 0.01
ops = FermionOperator('2^ 0', 3.0 - 1.j)
ops += FermionOperator('0^ 2', 3.0 + 1.j)
print(ops)
sham = fqe.get_sparse_hamiltonian(ops, conserve_spin=False)
evolved = fqe.time_evolve(lihwfn, time, sham)
evolved.print_wfn()
nbody_evol = lihwfn.apply_generated_unitary(time,
'taylor',
sham,
accuracy=1.0e-8)
evolved.ax_plus_y(-1.0, nbody_evol)
print(evolved.norm() < 1.e-8)
def evolve_cirq_givens(initial_wf: np.ndarray, u: np.ndarray):
n_qubits = int(np.log2(initial_wf.shape[0]))
qubits = cirq.LineQubit.range(n_qubits)
circuit = cirq.Circuit(optimal_givens_decomposition(qubits, u.copy()))
final_state = circuit.final_wavefunction(initial_state=initial_wf.flatten())
return final_state
if __name__ == "__main__":
norbs = 10
sz = 0
nelec = norbs
start_time = time.time()
initial_wfn = fqe.Wavefunction([[nelec, sz, norbs]])
print("Wavefunction Initialization ", time.time() - start_time)
graph = initial_wfn.sector((nelec, sz)).get_fcigraph()
hf_wf = np.zeros((graph.lena(), graph.lenb()), dtype=np.complex128)
hf_wf[0, 0] = 1
start_time = time.time()
cirq_wf = of.jw_hartree_fock_state(nelec, 2 * norbs)
print("Cirq wf initialization time ", time.time() - start_time)
initial_wfn.set_wfn(strategy='from_data',
raw_data={(nelec, sz): hf_wf})
# set up Hamiltonian
ikappa = random_quadratic_hamiltonian(norbs, conserves_particle_number=True,
real=True, expand_spin=False, seed=5)
ikappa_matrix = ikappa.n_body_tensors[1, 0]
diagonal_coulomb = fqe.diagonal_coulomb.DiagonalCoulomb(ikappa_matrix)
def davidsonliu_fqe(
hmat: Hamiltonian,
nroots: int,
guess_vecs,
nele,
sz,
norb,
epsilon: float = 1.0e-8,
verbose=False,
):
"""TODO: Add docstring."""
if nroots < 1 or nroots > 2**(hmat.dim() - 1):
raise ValueError("Number of roots is incorrectly specified")
gv_sector = list(guess_vecs[0].sectors())[0]
for gv in guess_vecs:
if list(gv.sectors())[0] != gv_sector:
raise TypeError("Sectors don't match for guess vectors")
# get diagonal Hamiltonian as the preconditioner.
# TODO: This should be changed to Slater-Condon rules construction and not
# this hack!
diagonal_ham = np.zeros_like(guess_vecs[0].sector(gv_sector).coeff)
graph = guess_vecs[0].sector(gv_sector).get_fcigraph()
empty_vec = np.zeros_like(diagonal_ham)
comp_basis = fqe.Wavefunction([[nele, sz, norb]])
old_ia, old_ib = None, None
for ia in graph.string_alpha_all():
for ib in graph.string_beta_all():
# empty_vec = np.zeros_like(diagonal_ham)
if old_ia is not None and old_ib is not None:
empty_vec[old_ia, old_ib] = 0.0
empty_vec[graph.index_alpha(ia), graph.index_beta(ib)] = 1.0
assert np.isclose(np.sum(empty_vec), 1)
old_ia, old_ib = graph.index_alpha(ia), graph.index_beta(ib)
comp_basis.set_wfn(strategy="from_data",
raw_data={(nele, sz): empty_vec})
diagonal_ham[graph.index_alpha(ia),
graph.index_beta(ib)] = comp_basis.expectationValue(
hmat).real
old_thetas = np.array([np.infty] * nroots)
while len(guess_vecs) <= graph.lena() * graph.lenb() / 2:
if verbose:
print()
current_num_gv = len(guess_vecs)
start_time = time.time()
subspace_mat = np.zeros((len(guess_vecs), len(guess_vecs)),
dtype=np.complex128)
for i, j in product(range(len(guess_vecs)), repeat=2):
if i >= j:
subspace_mat[i, j] = guess_vecs[j].expectationValue(
hmat, brawfn=guess_vecs[i])
subspace_mat[j, i] = subspace_mat[i, j]
if verbose:
print("subspace mat problem formation ", time.time() - start_time)
# for nroots residuals
start_time = time.time()
w, v = np.linalg.eigh(subspace_mat)
if verbose:
print("subsapce eig problem time: ", time.time() - start_time)
# if converged return
if verbose:
print(
"eig convergence {}, ".format(
np.linalg.norm(w[:nroots] - old_thetas)),
w[:nroots] - old_thetas,
)
if np.linalg.norm(w[:nroots] - old_thetas) < epsilon:
# build eigenvectors
eigenvectors = []
for i in range(nroots):
eigenvectors.append(
sum([
v[j, i] * guess_vecs[j].sector(gv_sector).coeff
for j in range(current_num_gv)
]))
eigfuncs = []
for eg in eigenvectors:
new_wfn = copy.deepcopy(guess_vecs[0])
new_wfn.set_wfn(strategy='from_data', raw_data={gv_sector: eg})
eigfuncs.append(new_wfn)
return w[:nroots], eigfuncs
# else set new roots to the old roots
old_thetas = w[:nroots]
if verbose:
print("Old Thetas: ", old_thetas)
# update the subspace vecs with the vecs of the subspace problem with
# the nroots lowest eigenvalues
for i in range(nroots):
# expand in the space of all existing guess_vecs
subspace_eigvec_expanded = sum([
v[j, i] * guess_vecs[j].sector(gv_sector).coeff
for j in range(current_num_gv)
])
subspace_eigvec = copy.deepcopy(guess_vecs[0])
subspace_eigvec.set_wfn(
strategy="from_data",
raw_data={gv_sector: subspace_eigvec_expanded},
)
# this should return a fresh wavefunction copy.deepcop
residual = subspace_eigvec.apply(hmat)
subspace_eigvec.scale(-w[i])
residual = residual + subspace_eigvec
preconditioner = copy.deepcopy(residual)
preconditioner.set_wfn(
strategy="from_data",
raw_data={gv_sector: np.reciprocal(w[i] - diagonal_ham)},
)
f_k_coeffs = np.multiply(
preconditioner.sector(gv_sector).coeff,
residual.sector(gv_sector).coeff,
)
f_k = copy.deepcopy(residual)
f_k.set_wfn(strategy="from_data", raw_data={gv_sector: f_k_coeffs})
# orthogonalize preconditioned_residual
overlaps = []
# print(len(guess_vecs))
for idx in range(len(guess_vecs)):
overlaps.append(
np.sum(
np.multiply(
guess_vecs[idx].get_coeff(gv_sector),
f_k.get_coeff(gv_sector),
)))
for idx in range(len(guess_vecs)):
f_k.sector(gv_sector).coeff -= (
overlaps[idx] * guess_vecs[idx].sector(gv_sector).coeff)
f_k.normalize()
guess_vecs.append(f_k)
eigenvectors = []
for i in range(nroots):
eigenvectors.append(
sum([
v[j, i] * guess_vecs[j].sector(gv_sector).coeff
for j in range(current_num_gv)
]))
eigfuncs = []
for eg in eigenvectors:
new_wfn = copy.deepcopy(guess_vecs[0])
new_wfn.set_wfn(strategy='from_data', raw_data={gv_sector: eg})
eigfuncs.append(new_wfn)
return w[:nroots], eigfuncs
norb=norb)
return dl_w, dl_v
# TODO: Make this a unit test?
if __name__ == "__main__":
eref = -8.877719570384043
norb = 6
nalpha = 2
nbeta = 2
sz = nalpha - nbeta
nele = nalpha + nbeta
h1e, h2e, lih_ground = build_lih_data("energy")
h2e_zeros = np.zeros_like(h2e)
elec_hamil = fqe.restricted_hamiltonian.RestrictedHamiltonian((h1e, h2e))
wfn = fqe.Wavefunction([[nele, nalpha - nbeta, norb]])
wfn.set_wfn(strategy="from_data",
raw_data={(nele, nalpha - nbeta): lih_ground})
graph = wfn.sector((4, 0)).get_fcigraph()
ecalc = wfn.expectationValue(elec_hamil)
# Generate Guess Vecs for Davidson-Liu
guess_vec1_coeffs = np.zeros((graph.lena(), graph.lenb()))
guess_vec2_coeffs = np.zeros((graph.lena(), graph.lenb()))
alpha_hf = fqe.util.init_bitstring_groundstate(2)
beta_hf = fqe.util.init_bitstring_groundstate(2)
alpha_hf_idx = fqe.util.init_bitstring_groundstate(2)
beta_hf_idx = fqe.util.init_bitstring_groundstate(2)
guess_vec1_coeffs[graph.index_alpha(alpha_hf),
graph.index_beta(beta_hf)] = 1.0
guess_vec2_coeffs[graph.index_alpha(alpha_hf << 1),
