def _pauli_expansion_(self) -> value.LinearDict[str]: if protocols.is_parameterized(self): return NotImplemented global_phase = 1j**(2 * self._exponent * self._global_shift) cnot_phase = 1j**self._exponent c = -1j * cnot_phase * np.sin(np.pi * self._exponent / 2) / 2 return value.LinearDict({ 'II': global_phase * (1 - c), 'IX': global_phase * c, 'ZI': global_phase * c, 'ZX': global_phase * -c, })
def _pauli_expansion_(self) -> value.LinearDict[str]: if protocols.is_parameterized(self): return NotImplemented global_phase = 1j**(2 * self._exponent * self._global_shift) angle = np.pi * self._exponent / 4 c, s = np.cos(angle), np.sin(angle) return value.LinearDict({ 'II': global_phase * c * c, 'XX': global_phase * c * s * 1j, 'YY': global_phase * s * c * 1j, 'ZZ': global_phase * s * s, })
def _pauli_expansion_(self) -> value.LinearDict[str]: return value.LinearDict( { 'III': 3 / 4, 'IXX': 1 / 4, 'IYY': 1 / 4, 'IZZ': 1 / 4, 'ZII': 1 / 4, 'ZXX': -1 / 4, 'ZYY': -1 / 4, 'ZZZ': -1 / 4, } )
def _pauli_expansion_(self) -> value.LinearDict[str]: if self._is_parameterized_(): return NotImplemented phase_angle = np.pi * self._phase_exponent / 2 angle = np.pi * self._exponent / 2 phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5)) return value.LinearDict( { 'I': phase * np.cos(angle), 'X': -1j * phase * np.sin(angle) * np.cos(2 * phase_angle), 'Y': -1j * phase * np.sin(angle) * np.sin(2 * phase_angle), } )
def _pauli_expansion_(self) -> value.LinearDict[str]: if protocols.is_parameterized(self): return NotImplemented x = [np.exp(1j * angle) for angle in self._diag_angles_radians] return value.LinearDict({ 'III': (x[0] + x[1] + x[2] + x[3] + x[4] + x[5] + x[6] + x[7]) / 8, 'IIZ': (x[0] - x[1] + x[2] - x[3] + x[4] - x[5] + x[6] - x[7]) / 8, 'IZI': (x[0] + x[1] - x[2] - x[3] + x[4] + x[5] - x[6] - x[7]) / 8, 'IZZ': (x[0] - x[1] - x[2] + x[3] + x[4] - x[5] - x[6] + x[7]) / 8, 'ZII': (x[0] + x[1] + x[2] + x[3] - x[4] - x[5] - x[6] - x[7]) / 8, 'ZIZ': (x[0] - x[1] + x[2] - x[3] - x[4] + x[5] - x[6] + x[7]) / 8, 'ZZI': (x[0] + x[1] - x[2] - x[3] - x[4] - x[5] + x[6] + x[7]) / 8, 'ZZZ': (x[0] - x[1] - x[2] + x[3] - x[4] + x[5] + x[6] - x[7]) / 8, })
def _pauli_expansion_(self) -> value.LinearDict[str]: if protocols.is_parameterized(self): return NotImplemented a = math.cos(self.theta) b = -1j * math.sin(self.theta) c = cmath.exp(-1j * self.phi) return value.LinearDict({ 'II': (1 + c) / 4 + a / 2, 'IZ': (1 - c) / 4, 'ZI': (1 - c) / 4, 'ZZ': (1 + c) / 4 - a / 2, 'XX': b / 2, 'YY': b / 2, })
def __init__( self, linear_dict: Optional[value.LinearDict[FrozenSet[Tuple[raw_types.Qid, int]]]] = None): """Constructor for ProjectorSum Args: linear_dict: A linear dictionary from a set of tuples of (Qubit, integer) to a complex number. The tuple is a projector onto the qubit and the complex number is the weight of these projections. """ self._linear_dict: value.LinearDict[FrozenSet[Tuple[ raw_types.Qid, int]]] = (linear_dict if linear_dict is not None else value.LinearDict({}))
def expand_matrix_in_orthogonal_basis( m: np.ndarray, basis: Dict[str, np.ndarray], ) -> value.LinearDict[str]: """Computes coefficients of expansion of m in basis. We require that basis be orthogonal w.r.t. the Hilbert-Schmidt inner product. We do not require that basis be orthonormal. Note that Pauli basis (I, X, Y, Z) is orthogonal, but not orthonormal. """ return value.LinearDict({ name: (hilbert_schmidt_inner_product(b, m) / hilbert_schmidt_inner_product(b, b)) for name, b in basis.items() })
def _pauli_expansion_(self) -> 'cirq.LinearDict[str]': if protocols.is_parameterized(self): return NotImplemented x_angle = np.pi * self._x_exponent / 2 z_angle = np.pi * self._z_exponent / 2 axis_angle = np.pi * self._axis_phase_exponent phase = np.exp(1j * (x_angle + z_angle)) cx = np.cos(x_angle) sx = np.sin(x_angle) return value.LinearDict({ 'I': phase * cx * np.cos(z_angle), 'X': -1j * phase * sx * np.cos(z_angle + axis_angle), 'Y': -1j * phase * sx * np.sin(z_angle + axis_angle), 'Z': -1j * phase * cx * np.sin(z_angle), }) # yapf: disable
def _pauli_expansion_(self) -> value.LinearDict[str]: if self._is_parameterized_(): return NotImplemented expansion = protocols.pauli_expansion(self._iswap) assert set(expansion.keys()).issubset({'II', 'XX', 'YY', 'ZZ'}) assert np.isclose(expansion['XX'], expansion['YY']) v = (expansion['XX'] + expansion['YY']) / 2 phase_angle = np.pi * self.phase_exponent c, s = np.cos(2 * phase_angle), np.sin(2 * phase_angle) return value.LinearDict({ 'II': expansion['II'], 'XX': c * v, 'YY': c * v, 'XY': s * v, 'YX': -s * v, 'ZZ': expansion['ZZ'], })
def from_projector_strings( cls, terms: Union[ProjectorString, List[ProjectorString]]) -> 'ProjectorSum': """Builds a ProjectorSum from one or more ProjectorString(s). Args: terms: Either a single ProjectorString or a list of ProjectorStrings. Returns: A ProjectorSum. """ if isinstance(terms, ProjectorString): terms = [terms] termdict: DefaultDict[FrozenSet[Tuple[raw_types.Qid, int]], value.Scalar] = defaultdict(lambda: 0.0) for pstring in terms: key = frozenset(pstring.projector_dict.items()) termdict[key] += pstring.coefficient return cls(linear_dict=value.LinearDict(termdict))
def _pauli_expansion_(self) -> value.LinearDict[str]: return value.LinearDict({'I' * self.num_qubits(): 1.0})
def _pauli_expansion_(self) -> value.LinearDict[str]: if not all(d == 2 for d in self._qid_shape): return NotImplemented return value.LinearDict({'I' * self.num_qubits(): 1.0})
def _pauli_expansion_(self) -> value.LinearDict[str]: result = value.LinearDict({}) # type: value.LinearDict[str] for gate, coefficient in self.items(): result += protocols.pauli_expansion(gate) * coefficient return result
def _from_json_dict_(cls, items, **kwargs): mapping = { frozenset(tuple(qid_pauli) for qid_pauli in unit_pauli_string): val for unit_pauli_string, val in items } return cls(linear_dict=value.LinearDict(mapping))
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Protocol for obtaining expansion of linear operators in Pauli basis.""" from typing import Any, TypeVar, Union from typing_extensions import Protocol from cirq import value from cirq._doc import doc_private from cirq.linalg import operator_spaces from cirq.protocols import qid_shape_protocol, unitary_protocol TDefault = TypeVar('TDefault') RaiseTypeErrorIfNotProvided: value.LinearDict[str] = value.LinearDict({}) class SupportsPauliExpansion(Protocol): """An object that knows its expansion in the Pauli basis.""" @doc_private def _pauli_expansion_(self) -> value.LinearDict[str]: """Efficiently obtains expansion of self in the Pauli basis. Returns: Linear dict keyed by name of Pauli basis element. The names consist of n captal letters from the set 'I', 'X', 'Y', 'Z' where n is the number of qubits. For example, 'II', 'IX' and 'XY' are valid Pauli names in the two-qubit case. """
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Protocol for obtaining expansion of linear operators in Pauli basis.""" from typing import Any, TypeVar, Union from typing_extensions import Protocol from cirq import value from cirq.linalg import operator_spaces from cirq.protocols import qid_shape_protocol, unitary_protocol TDefault = TypeVar('TDefault') RaiseTypeErrorIfNotProvided = (value.LinearDict({}) ) # type: value.LinearDict[str] class SupportsPauliExpansion(Protocol): """An object that knows its expansion in the Pauli basis.""" def _pauli_expansion_(self) -> value.LinearDict[str]: """Efficiently obtains expansion of self in the Pauli basis. Returns: Linear dict keyed by name of Pauli basis element. The names consist of n captal letters from the set 'I', 'X', 'Y', 'Z' where n is the number of qubits. For example, 'II', 'IX' and 'XY' are valid Pauli names in the two-qubit case. """
def _pauli_expansion_(self) -> value.LinearDict[str]: return value.LinearDict({'I' * len(self._qubits): 1.0})