Did I find the right examples for you? yes no      Crawl my project      Python Jobs

# sympy.physics.quantum.identitysearch.generate_equivalent_ids

All Samples(19)  |  Call(18)  |  Derive(0)  |  Import(1)
```Returns a set of equivalent gate identities.

A gate identity is a quantum circuit such that the product
of the gates in the circuit is equal to a scalar value.
For example, XYZ = i, where X, Y, Z are the Pauli gates and
i is the imaginary value, is considered a gate identity.

This function uses the four operations (LL, LR, RL, RR)
to generate the gate rules and, subsequently, to locate equivalent
gate identities.(more...)
```

```        def generate_equivalent_ids(gate_seq, return_as_muls=False):
"""Returns a set of equivalent gate identities.

A gate identity is a quantum circuit such that the product
of the gates in the circuit is equal to a scalar value.
For example, XYZ = i, where X, Y, Z are the Pauli gates and
i is the imaginary value, is considered a gate identity.

This function uses the four operations (LL, LR, RL, RR)
to generate the gate rules and, subsequently, to locate equivalent
gate identities.

Note that all equivalent identities are reachable in n operations
from the starting gate identity, where n is the number of gates
in the sequence.

The max number of gate identities is 2n, where n is the number
of gates in the sequence (unproven).

Parameters
==========

gate_seq : Gate tuple, Mul, or Number
A variable length tuple or Mul of Gates whose product is equal to
a scalar matrix.
return_as_muls: bool
True to return as Muls; False to return as tuples

Examples
========

Find equivalent gate identities from the current circuit with tuples:

>>> from sympy.physics.quantum.identitysearch import generate_equivalent_ids
>>> from sympy.physics.quantum.gate import X, Y, Z
>>> x = X(0); y = Y(0); z = Z(0)
>>> generate_equivalent_ids((x, x))
set([(X(0), X(0))])

>>> generate_equivalent_ids((x, y, z))
set([(X(0), Y(0), Z(0)), (X(0), Z(0), Y(0)), (Y(0), X(0), Z(0)),
(Y(0), Z(0), X(0)), (Z(0), X(0), Y(0)), (Z(0), Y(0), X(0))])

Find equivalent gate identities from the current circuit with Muls:

>>> generate_equivalent_ids(x*x, return_as_muls=True)
set()

>>> generate_equivalent_ids(x*y*z, return_as_muls=True)
set([X(0)*Y(0)*Z(0), X(0)*Z(0)*Y(0), Y(0)*X(0)*Z(0),
Y(0)*Z(0)*X(0), Z(0)*X(0)*Y(0), Z(0)*Y(0)*X(0)])
"""

if isinstance(gate_seq, Number):
return set([Integer(1)])
elif isinstance(gate_seq, Mul):
gate_seq = gate_seq.args

# Filter through the gate rules and keep the rules
# with an empty tuple either on the left or right side

# A set of equivalent gate identities
eq_ids = set()

gate_rules = generate_gate_rules(gate_seq)
for rule in gate_rules:
l, r = rule
if l == ():
elif r == ():

if return_as_muls:
convert_to_mul = lambda id_seq: Mul(*id_seq)
eq_ids = set(map(convert_to_mul, eq_ids))

return eq_ids
```

```from sympy.physics.quantum.gate import (X, Y, Z, H, S, T, CNOT,
IdentityGate, CGate, PhaseGate, TGate, gate_simp)
from sympy.physics.quantum.identitysearch import (generate_gate_rules,
generate_equivalent_ids, GateIdentity, bfs_identity_search,
random_identity_search, is_scalar_sparse_matrix,
```
```def test_generate_equivalent_ids_1():
# Test with tuples
(x, y, z, h) = create_gate_sequence()

assert generate_equivalent_ids((x,)) == set([(x,)])
assert generate_equivalent_ids((x, x)) == set([(x, x)])
assert generate_equivalent_ids((x, y)) == set([(x, y), (y, x)])
```
```    gate_ids = set([(x, y, z), (y, z, x), (z, x, y), (z, y, x),
(y, x, z), (x, z, y)])
assert generate_equivalent_ids(gate_seq) == gate_ids

gate_ids = set([Mul(x, y, z), Mul(y, z, x), Mul(z, x, y),
```