def tpdm_antisymmetry_constraint(dim: int) -> DualBasis: """ The dual basis elements representing the antisymmetry constraints :param dim: spinless Fermion basis rank :return: the dual basis of antisymmetry_constraints :rtype: DualBasis """ # dual_basis = DualBasis() dbe_list = [] for p, q, r, s in product(range(dim), repeat=4): if p * dim + q <= r * dim + s: if p < q and r < s: tensor_elements = [ tuple(indices) for indices in _coord_generator(p, q, r, s) ] tensor_names = ['cckk'] * len(tensor_elements) tensor_coeffs = [0.5] * len(tensor_elements) dbe = DualBasisElement() for n, e, c in zip(tensor_names, tensor_elements, tensor_coeffs): dbe.add_element(n, e, c) # dual_basis += dbe dbe_list.append(dbe) return DualBasis(elements=dbe_list)
def tpdm_to_opdm_mapping(dim: int, normalization: Union[float, int]) -> DualBasis: """ Construct the DualBasis for mapping of the tpdm to the opdm Args: dim: dimension of the spin-orbital basis. normalization: Scalar for mapping tpdm to opdm. Generally, this is 1 / (N - 1) where N is the number of electrons. Returns: DualBasis for all dim^2 """ db_basis = DualBasis() for i in range(dim): for j in range(i, dim): dbe = DualBasisElement() # contract over tpdm terms for r in range(dim): # duplicate entries get summed in DualBasisElement dbe.add_element('cckk', (i, r, j, r), 0.5) dbe.add_element('cckk', (j, r, i, r), 0.5) # opdm terms dbe.add_element('ck', (i, j), -0.5 * normalization) dbe.add_element('ck', (j, i), -0.5 * normalization) dbe.simplify() db_basis += dbe return db_basis
def d2q2element(p: int, q: int, r: int, s: int, factor: Union[float, int])\ -> DualBasisElement: """ Build the dual basis element for symmetric form of 2-marginal :param p: tensor index :param q: tensor index :param r: tensor index :param s: tensor index :param factor: scaling coeff for a symmetric constraint :return: the dual basis of the mapping """ dbe = DualBasisElement() dbe.add_element('cckk', (p, q, r, s), -1.0 * factor) dbe.add_element('kkcc', (r, s, p, q), +1.0 * factor) if q == s: dbe.add_element('ck', (p, r), factor) if p == r: dbe.add_element('ck', (q, s), factor) if q == r: dbe.add_element('ck', (p, s), -1. * factor) if p == s: dbe.add_element('ck', (q, r), -1. * factor) dbe.dual_scalar = ( kronecker_delta(q, s) * kronecker_delta(p, r) - kronecker_delta(q, r) * kronecker_delta(p, s)) * factor return dbe
def test_add_dualelement(): a = np.random.random((5, 5, 5, 5)) b = np.random.random((4, 4, 4)) c = np.random.random((3, 3)) at = Tensor(tensor=a, name='a') bt = Tensor(tensor=b, name='b') ct = Tensor(tensor=c, name='c') mt = MultiTensor([at, bt, ct]) assert isinstance(mt.dual_basis, DualBasis) dbe = DualBasisElement() dbe.add_element('a', (0, 1, 2, 3), 4) mt.add_dual_elements(dbe) assert len(mt.dual_basis) == 1
def nb_constraint(dim, nb): """ Constraint the trace of the alpha block of the opdm to equal the number of spin-down electrons Args: dim: Dimension of the spin-orbital basis. na: Number of spin down electrons Returns: DualBasis representing the cosntraint that is length 1 """ dbe = DualBasisElement() for i in range(dim // 2): dbe.add_element('ck', (2 * i + 1, 2 * i + 1), 1.0) dbe.dual_scalar = nb return DualBasis(elements=[dbe])
def sz_constraint(dim: int, sz: Union[float, int]) -> DualBasis: """ Constraint on the 1-RDM Args: dim: dimension of the spin-orbital basis. sz: expectation value of the magnetic quantum number. Returns: DualBasis """ dbe = DualBasisElement() for i in range(dim // 2): dbe.add_element('ck', (2 * i, 2 * i), 0.5) dbe.add_element('ck', (2 * i + 1, 2 * i + 1), -0.5) dbe.dual_scalar = sz return DualBasis(elements=[dbe])
def na_constraint(dim: int, na: Union[float, int]) -> DualBasis: """ Constraint the trace of the alpha block of the opdm to equal the number of spin-up electrons Args: dim: Dimension of the spin-orbital basis. na: Number of spin up electrons Returns: DualBasis representing the cosntraint that is length 1 """ dbe = DualBasisElement() for i in range(dim // 2): dbe.add_element('ck', (2 * i, 2 * i), 1.0) dbe.dual_scalar = na return DualBasis(elements=[dbe])
def test_synthesis_dualbasis(): a = np.random.random((5, 5)) b = np.random.random((4, 4)) c = np.random.random((3, 3)) at = Tensor(tensor=a, name='a') bt = Tensor(tensor=b, name='b') ct = Tensor(tensor=c, name='c') dbe = DualBasisElement() dbe.add_element('a', (0, 1), 4) dbe.add_element('a', (1, 0), 4) mt = MultiTensor([at, bt, ct], DualBasis(elements=[dbe])) A, c, b = mt.synthesize_dual_basis() assert isinstance(A, sp.sparse.csr_matrix) assert isinstance(c, sp.sparse.csr_matrix) assert isinstance(b, sp.sparse.csr_matrix) assert A.shape == (1, 50) assert b.shape == (1, 1) assert c.shape == (1, 1)
def opdm_to_ohdm_mapping(dim: int) -> DualBasis: """ Map the ck to kc D1 + Q1 = I Args: dim: dimension of the spin-orbital basis Returns: DualBasis for the 1-RDM representability constraint """ dbe_list = [] for i in range(dim): for j in range(i, dim): dbe = DualBasisElement() if i != j: dbe.add_element('ck', (i, j), 0.5) dbe.add_element('ck', (j, i), 0.5) dbe.add_element('kc', (j, i), 0.5) dbe.add_element('kc', (i, j), 0.5) dbe.dual_scalar = 0.0 else: dbe.add_element('ck', (i, j), 1.0) dbe.add_element('kc', (i, j), 1.0) dbe.dual_scalar = 1.0 # db += dbe dbe_list.append(dbe) return DualBasis(elements=dbe_list) # db
def g2d2map(p: int, q: int, r: int, s: int, factor: Optional[Union[float, int]] = 1) -> DualBasisElement: """ Build the dual basis element for a symmetric 2-marginal :param p: tensor index :param q: tensor index :param r: tensor index :param s: tensor index :param factor: weighting of the element :return: the dual basis element """ dbe = DualBasisElement() if q == s: dbe.add_element('ck', (p, r), -1. * factor) dbe.add_element('ckck', (p, s, r, q), 1.0 * factor) dbe.add_element('cckk', (p, q, r, s), 1.0 * factor) dbe.dual_scalar = 0 return dbe
def test_synthesis_element(): a = np.random.random((5, 5)) b = np.random.random((4, 4)) c = np.random.random((3, 3)) at = Tensor(tensor=a, name='a') bt = Tensor(tensor=b, name='b') ct = Tensor(tensor=c, name='c') mt = MultiTensor([at, bt, ct]) dbe = DualBasisElement() dbe.add_element('a', (0, 1), 4) dbe.add_element('a', (1, 0), 4) with pytest.raises(TypeError): dbe.add_element(5) with pytest.raises(TypeError): mt.add_dual_elements(5) mt.add_dual_elements(dbe) colidx, data_vals = mt.synthesize_element(dbe) assert data_vals == [4, 4] assert colidx == [1, 5] assert [at.data[0, 1], at.data[1, 0]] == [at(0, 1), at(1, 0)]
def test_add_element(): with pytest.raises(TypeError): dbe = DualBasisElement() dbe.add_element('cckk', [1, 2, 3, 4], 0.5) with pytest.raises(TypeError): dbe = DualBasisElement() dbe.add_element(5, (1, 2, 3, 4), 0.5) with pytest.raises(TypeError): dbe = DualBasisElement() dbe.add_element('a', (1, 2, 3, 4), 'a') dbe = DualBasisElement() dbe.add_element('cckk', (1, 2, 3, 4), 0.5) dbe.constant_bias = 0.33 assert dbe.primal_coeffs == [0.5] assert dbe.primal_tensors_names == ['cckk'] assert dbe.primal_elements == [(1, 2, 3, 4)] dbe.add_element('ck', (0, 1), 1) assert dbe.primal_coeffs == [0.5, 1] assert dbe.primal_tensors_names == ['cckk', 'ck'] assert dbe.primal_elements == [(1, 2, 3, 4), (0, 1)] dbe2 = DualBasisElement() with pytest.raises(TypeError): dbe2.join_elements((1, 1)) dbe2.constant_bias = 0.25 dbe2.add_element('cckk', (1, 2, 3, 4), 0.5) dbe3 = dbe2.join_elements(dbe) assert np.isclose(dbe3.constant_bias, 0.58) assert set(dbe3.primal_elements) == {(0, 1), (1, 2, 3, 4)} assert np.allclose(dbe3.primal_coeffs, [1, 1]) assert set(dbe3.primal_tensors_names) == {'ck', 'cckk'}