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)