def _calculate_register_samples(self):
qubit_map = self.result.qubit_map
samples = self.result.samples(True)
results = {}
for name, qubit_tuple in self.register_qubits.items():
slicer = tuple(qubit_map[q] for q in qubit_tuple)
register_samples = K.gather(samples, slicer, axis=-1)
results[name] = MeasurementResult(qubit_tuple)
results[name].binary = register_samples
return results
def entropy(self, rho):
"""Calculates entropy of a density matrix via exact diagonalization."""
# Diagonalize
eigvals = K.real(K.eigvalsh(rho))
# Treating zero and negative eigenvalues
drop_condition = eigvals > EIGVAL_CUTOFF
masked_eigvals = K.gather(eigvals, condition=drop_condition)
spectrum = -1 * K.log(masked_eigvals)
if self.compute_spectrum:
self.spectrum.append(spectrum)
entropy = K.sum(masked_eigvals * spectrum)
return entropy / self._log2
def density_matrix_call(self, state):
state = K.reshape(state, self.tensor_shape)
if self.is_controlled_by:
ncontrol = len(self.control_qubits)
nactive = self.nqubits - ncontrol
n = 2**ncontrol
state = K.transpose(state, self.control_cache.order(True))
state = K.reshape(state, 2 * (n, ) + 2 * nactive * (2, ))
state01 = K.gather(state, indices=range(n - 1), axis=0)
state01 = K.squeeze(K.gather(state01, indices=[n - 1], axis=1),
axis=1)
state01 = self.einsum(self.calculation_cache.right0, state01,
K.conj(self.matrix))
state10 = K.gather(state, indices=range(n - 1), axis=1)
state10 = K.squeeze(K.gather(state10, indices=[n - 1], axis=0),
axis=0)
state10 = self.einsum(self.calculation_cache.left0, state10,
self.matrix)
state11 = K.squeeze(K.gather(state, indices=[n - 1], axis=0),
axis=0)
state11 = K.squeeze(K.gather(state11, indices=[n - 1], axis=0),
axis=0)
state11 = self.einsum(self.calculation_cache.right, state11,
K.conj(self.matrix))
state11 = self.einsum(self.calculation_cache.left, state11,
self.matrix)
state00 = K.gather(state, indices=range(n - 1), axis=0)
state00 = K.gather(state00, indices=range(n - 1), axis=1)
state01 = K.concatenate([state00, state01[:, K.newaxis]], axis=1)
state10 = K.concatenate([state10, state11[K.newaxis]], axis=0)
state = K.concatenate([state01, state10[K.newaxis]], axis=0)
state = K.reshape(state, 2 * self.nqubits * (2, ))
state = K.transpose(state, self.control_cache.reverse(True))
else:
state = self.einsum(self.calculation_cache.right, state,
K.conj(self.matrix))
state = self.einsum(self.calculation_cache.left, state,
self.matrix)
return K.reshape(state, self.flat_shape)
