def test_general_mpo_sbm():
mol = get_mol()
mol_list = MolList([mol], Quantity(0))
mol_list.mol_list2_para()
mpo = Mpo.general_mpo(mol_list,
const=Quantity(-mol_list[0].gs_zpe *
mol_list.mol_num))
mpo_std = Mpo(mol_list)
check_result(mpo, mpo_std)
def check_reduced_density_matrix(order, basis):
mol_list = MolList2(order, basis, {}, ModelTranslator.general_model)
mps = Mps.random(mol_list, 1, 20)
rdm = mps.calc_reduced_density_matrix().real
assert np.allclose(np.diag(rdm), mps.e_occupations)
# only test a sample. Should be enough.
mpo = Mpo.general_mpo(mol_list,
model={
(f"e_0", f"e_3"): [(Op(r"a^\dagger",
1), Op("a", -1), 1.0)]
},
model_translator=ModelTranslator.general_model)
assert rdm[-1][0] == pytest.approx(mps.expectation(mpo))
def test_general_mpo_MolList(mol_list, scheme):
if scheme == 4:
mol_list1 = mol_list.switch_scheme(4)
else:
mol_list1 = mol_list
mol_list1.mol_list2_para()
mpo = Mpo.general_mpo(mol_list1,
const=Quantity(-mol_list1[0].gs_zpe *
mol_list1.mol_num))
mpo_std = Mpo(mol_list1)
check_result(mpo, mpo_std)
def x_square_average(mol_list: MolList2):
"""
<x^2> of vibrational DoF
"""
assert isinstance(mol_list, MolList2)
mpos = []
for v_dof in mol_list.v_dofs:
model = {(v_dof,):[(Op("x^2",0),1.0)]}
mpo = Mpo.general_mpo(mol_list, model=model,
model_translator=ModelTranslator.general_model)
mpos.append(mpo)
return {r"x^2": mpos}
def test_general_mpo_MolList2(mol_list, scheme, formula):
if scheme == 4:
mol_list1 = mol_list.switch_scheme(4)
else:
mol_list1 = mol_list
# scheme123
mol_list2 = MolList2.MolList_to_MolList2(mol_list1, formula=formula)
mpo_std = Mpo(mol_list1)
# classmethod method
mpo = Mpo.general_mpo(mol_list2,
const=Quantity(-mol_list[0].gs_zpe *
mol_list.mol_num))
check_result(mpo, mpo_std)
# __init__ method, same api
mpo = Mpo(mol_list2,
offset=Quantity(mol_list[0].gs_zpe * mol_list.mol_num))
check_result(mpo, mpo_std)
def _construct_flux_operator(self):
# construct flux operator
logger.info("constructing 1-d Holstein model flux operator ")
if isinstance(self.mol_list, MolList):
if self.mol_list.periodic:
itera = range(len(self.mol_list))
else:
itera = range(len(self.mol_list) - 1)
j_list = []
for i in itera:
conne = (i + 1) % len(self.mol_list) # connect site index
j1 = Mpo.intersite(self.mol_list, {
i: r"a",
conne: r"a^\dagger"
}, {}, Quantity(self.mol_list.j_matrix[i, conne]))
j1.compress_config.threshold = 1e-8
j2 = j1.conj_trans().scale(-1)
j_list.extend([j1, j2])
j_oper = compressed_sum(j_list, batchsize=10)
elif isinstance(self.mol_list, MolList2):
e_nsite = self.mol_list.n_edofs
model = {}
for i in range(e_nsite):
conne = (i + 1) % e_nsite # connect site index
model[(f"e_{i}", f"e_{conne}")] = [
(Op(r"a^\dagger",
1), Op("a", -1), -self.mol_list.j_matrix[i, conne]),
(Op(r"a", -1), Op(r"a^\dagger",
1), self.mol_list.j_matrix[conne, i])
]
j_oper = Mpo.general_mpo(
self.mol_list,
model=model,
model_translator=ModelTranslator.general_model)
else:
assert False
logger.debug(f"flux operator bond dim: {j_oper.bond_dims}")
return j_oper
def max_entangled_ex(cls, mol_list, normalize=True):
"""
T = \\infty locally maximal entangled EX state
"""
mps = Mps.gs(mol_list, max_entangled=True)
# the creation operator \\sum_i a^\\dagger_i
if isinstance(mol_list, MolList):
ex_mpo = Mpo.onsite(mol_list, r"a^\dagger")
else:
model = {}
for dof in mol_list.e_dofs:
model[(dof, )] = [(Op("a^\dagger", 1), 1.0)]
ex_mpo = Mpo.general_mpo(
mol_list,
model=model,
model_translator=ModelTranslator.general_model)
ex_mps = ex_mpo @ mps
if normalize:
ex_mps.normalize(1.0)
return cls.from_mps(ex_mps)
def test_general_mpo_others():
mol_list2 = MolList2.MolList_to_MolList2(mol_list)
# onsite
mpo_std = Mpo.onsite(mol_list, r"a^\dagger", mol_idx_set=[0])
mpo = Mpo.onsite(mol_list2, r"a^\dagger", mol_idx_set=[0])
check_result(mpo, mpo_std)
# general method
mpo = Mpo.general_mpo(mol_list2,
model={("e_0", ): [(Op(r"a^\dagger", 0), 1.0)]},
model_translator=ModelTranslator.general_model)
check_result(mpo, mpo_std)
mpo_std = Mpo.onsite(mol_list, r"a^\dagger a", dipole=True)
mpo = Mpo.onsite(mol_list2, r"a^\dagger a", dipole=True)
check_result(mpo, mpo_std)
mpo = Mpo.general_mpo(mol_list2,
model={
("e_0", ):
[(Op(r"a^\dagger a",
0), mol_list2.dipole[("e_0", )])],
("e_1", ):
[(Op(r"a^\dagger a",
0), mol_list2.dipole[("e_1", )])],
("e_2", ): [(Op(r"a^\dagger a",
0), mol_list2.dipole[("e_2", )])]
},
model_translator=ModelTranslator.general_model)
check_result(mpo, mpo_std)
# intersite
mpo_std = Mpo.intersite(mol_list, {
0: r"a^\dagger",
2: "a"
}, {(0, 1): "b^\dagger"}, Quantity(2.0))
mpo = Mpo.intersite(mol_list2, {
0: r"a^\dagger",
2: "a"
}, {(0, 1): r"b^\dagger"}, Quantity(2.0))
check_result(mpo, mpo_std)
mpo = Mpo.general_mpo(mol_list2,
model={
("e_0", "e_2", "v_1"):
[(Op(r"a^\dagger",
1), Op(r"a", -1), Op(r"b^\dagger", 0), 2.0)]
},
model_translator=ModelTranslator.general_model)
check_result(mpo, mpo_std)
# phsite
mpo_std = Mpo.ph_onsite(mol_list, r"b^\dagger", 0, 0)
mpo = Mpo.ph_onsite(mol_list2, r"b^\dagger", 0, 0)
check_result(mpo, mpo_std)
mpo = Mpo.general_mpo(mol_list2,
model={
(mol_list2.map[(0, 0)], ): [(Op(r"b^\dagger",
0), 1.0)]
},
model_translator=ModelTranslator.general_model)
check_result(mpo, mpo_std)