def test_daulbasis_init():
db = DualBasis()
assert isinstance(db, DualBasis)
dbe = DualBasisElement(tensor_names=['A'] * 5,
tensor_coeffs=[1] * 5,
tensor_elements=[(i, i) for i in range(5)])
db = DualBasis(elements=[dbe])
assert db[0] == dbe
assert len(db) == 1
for tdbe in db:
assert tdbe == dbe
db2 = db + dbe
assert isinstance(db2, DualBasis)
assert len(db2) == 2
tdbe = DualBasisElement(tensor_names=['B'] * 5,
tensor_coeffs=[1] * 5,
tensor_elements=[(i, i) for i in range(5)])
tdb = DualBasis(elements=[tdbe])
db3 = db + tdb
assert isinstance(db3, DualBasis)
assert len(db3) == 2
db4 = tdbe + db
assert len(db4) == 2
with pytest.raises(TypeError):
_ = DualBasis(elements=[tdbe, 4])
with pytest.raises(TypeError):
db = DualBasis(elements=[tdbe])
_ = db + 4
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 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 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 __init__(self, tensors, dual_basis=DualBasis()):
"""
A collection of tensor objects with maps from name to tensor
Args:
tensors: a dictionary or tuple of tensors and their associated call
name.
DualBasisElement dual_basis: the set of linear operators restricting
the feasible elements of the linear
space generated by vectorizing the
tensors.
"""
if not isinstance(tensors, list):
raise TypeError("MultiTensor accepts a list")
# this preserves the order the user passes with the tensors
self.tensors = TMap(tensors)
# since all the tensors are indexed from zero...I need to know their
# numbering offset when combined with everything.
self.off_set_map = self.make_offset_dict(self.tensors)
# An iterable object that provides access to the dual basis elements
self.dual_basis = dual_basis
self.vec_dim = sum([vec.size for vec in self.tensors])
def test_dual_basis_element():
de = DualBasisElement()
de_2 = DualBasisElement()
db_0 = de + de_2
assert isinstance(db_0, DualBasis)
db_1 = db_0 + db_0
assert isinstance(db_1, DualBasis)
dim = 2
opdm = np.random.random((dim, dim))
opdm = (opdm.T + opdm) / 2
opdm = Tensor(tensor=opdm, name='opdm')
rdm = MultiTensor([opdm])
def generate_dual_basis_element(i, j):
element = DualBasisElement(tensor_names=["opdm"],
tensor_elements=[(i, j)],
tensor_coeffs=[-1.0],
bias=1 if i == j else 0,
scalar=0)
return element
opdm_to_oqdm_map = DualBasis()
for _, idx in opdm.all_iterator():
i, j = idx
opdm_to_oqdm_map += generate_dual_basis_element(i, j)
rdm.dual_basis = opdm_to_oqdm_map
A, b, _ = rdm.synthesize_dual_basis()
Adense = A.todense()
opdm_flat = opdm.data.reshape((-1, 1))
oqdm = Adense.dot(opdm_flat)
test_oqdm = oqdm + b.todense()
assert np.allclose(test_oqdm.reshape((dim, dim)), np.eye(dim) - opdm.data)
def spin_orbital_linear_constraints(
dim: int,
num_alpha: Union[int, float],
num_beta: Union[int, float],
constraint_list: List[str],
sz: Optional[Union[None, float, int]] = None) -> DualBasis:
"""
Construct dual basis constraints for 2-positivity in a spin-orbital
basis
Args:
dim: Dimension of the spin-orbital basis
num_alpha: number of spin-up electrons.
num_beta: number of spin-down electrons.
constraint_list: list of which matrices to include in the 2-pos set.
sz: target magnetic quantum number.
Returns:
DualBasis element.
"""
N = num_alpha + num_beta
dual_basis = DualBasis()
if 'cckk' in constraint_list:
# Natural constraints on particle-conserving 2-RDMs
# trace constraint on D2
dual_basis += tpdm_trace_constraint(dim, N * (N - 1))
# antisymmetry constraint
dual_basis += tpdm_antisymmetry_constraint(dim)
if 'ck' in constraint_list:
dual_basis += tpdm_to_opdm_mapping(dim, N - 1)
if sz is not None:
dual_basis += sz_constraint(dim, sz)
dual_basis += na_constraint(dim, num_alpha)
dual_basis += nb_constraint(dim, num_beta)
if 'kc' in constraint_list:
dual_basis += opdm_to_ohdm_mapping(dim)
# d2 -> q2
if 'kkcc' in constraint_list:
print('tqdm constraints')
dual_basis += tpdm_to_thdm_mapping(dim)
# d2 -> g2
if "ckck" in constraint_list:
print('phdm constraints')
dual_basis += tpdm_to_phdm_mapping(dim)
return dual_basis
def tpdm_to_thdm_mapping(dim: int) -> DualBasis:
"""
Generate the dual basis elements for a mapping of the 2-RDM to the
two-hole-RDM
Args:
dim: Dimension of the spin-orbital basis
Returns:
DualBasis representing the equality constraint.
"""
dbe_list = []
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
for i, j, k, l in product(range(dim), repeat=4):
if i * dim + j <= k * dim + l:
db_element = d2q2element(i, j, k, l, 0.5)
db_element_2 = d2q2element(k, l, i, j, 0.5)
dbe_list.append(db_element.join_elements(db_element_2))
return DualBasis(elements=dbe_list)
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 tpdm_to_phdm_mapping(dim: int) -> DualBasis:
"""
Args:
dim: Dimension of the spin-orbital basis
Returns:
DualBasis representing the equality constraint
"""
dbe_list = []
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
for i, j, k, l in product(range(dim), repeat=4):
if i * dim + j <= k * dim + l:
db_element = g2d2map(i, j, k, l, factor=0.5)
db_element_2 = g2d2map(k, l, i, j, factor=0.5)
dbe_list.append(db_element.join_elements(db_element_2))
return DualBasis(elements=dbe_list)
