def test_WGate():
nqubits = 2
basis_states = superposition_basis(nqubits)
assert qapply(WGate(nqubits)*basis_states) == basis_states
expected = ((2/sqrt(pow(2, nqubits)))*basis_states) - IntQubit(1, nqubits=nqubits)
assert qapply(WGate(nqubits)*IntQubit(1, nqubits=nqubits)) == expected
def test_grover():
nqubits = 2
assert apply_grover(return_one_on_one, nqubits) == IntQubit(1, nqubits=nqubits)
nqubits = 4
basis_states = superposition_basis(nqubits)
expected = (-13*basis_states)/64 + 264*IntQubit(2, nqubits)/256
assert apply_grover(return_one_on_two, 4) == qapply(expected)
def random_oracle(nqubits, min_img=1, max_img=1, q_type='bin'):
"""Create a random OracleGate under the given parameter
Parameters
==========
nqubits : int
The number of qubits for OracleGate
min_pic : int
Minimum number of inverse images that are mapped to 1
max_pic : int
Maximum number of inverse images that are mapped to 1
q_type : OracleGate
Type of the Qubits that the oracle should be applied on.
Can be 'bin' for binary (Qubit()) or 'int' for integer (IntQubit()).
Returns
=======
OracleGate : random OracleGate under the given parameter
Examples
========
Generate random OracleGate that outputs 1 for 2-4 inputs::
>>> from sympy.physics.quantum.grover import random_oracle
>>> oracle = random_oracle(4, min_img=2, max_img=4, q_type="bin")
"""
if q_type != 'bin' and q_type != 'int':
raise QuantumError("q_type must be 'int' or 'bin'")
if min_img < 1 or max_img < 1:
raise QuantumError("min_pic, max_pic must be > 0")
if min_img > max_img:
raise QuantumError("max_pic must be >= min_pic")
if min_img >= 2 ** nqubits or max_img > 2 ** nqubits:
raise QuantumError("min_pic must be < 2**nqubits and max_pic must be <= 2**nqubits")
import random
pics = random.randint(min_img, max_img)
integers = random.sample(range(2 ** nqubits), pics)
if q_type == "int":
items = [IntQubit(i) for i in integers]
else:
items = [Qubit(IntQubit(i)) for i in integers]
return OracleGate(nqubits, lambda qubits: qubits in items)
def _apply_operator_Qubit(self, qubits, **options):
"""
Calcula Vx da segunda metade do registrador e armazena na
primeira metade
"""
a = 1
j = 0
# Determina o valor de j no segundo registrador.
for i in range(self.t):
j = j + a * qubits[self.n + i]
a = a * 2
# Calcula o valor que será armazenado no primeiro registrador.
value = int(self.x**j % self.N)
primeiro = Qubit(IntQubit(value, self.n))
array = list(qubits[k]
for k in reversed(range(self.n, self.n + self.t)))
for i in reversed(range(self.n)):
array.append(primeiro[i])
#print Qubit(*array), self.x, j, value
return Qubit(*array)
def test_UGate():
a, b, c, d = symbols('a,b,c,d')
uMat = Matrix([[a, b], [c, d]])
# Test basic case where gate exists in 1-qubit space
u1 = UGate((0, ), uMat)
assert represent(u1, nqubits=1) == uMat
assert qapply(u1 * Qubit('0')) == a * Qubit('0') + c * Qubit('1')
assert qapply(u1 * Qubit('1')) == b * Qubit('0') + d * Qubit('1')
# Test case where gate exists in a larger space
u2 = UGate((1, ), uMat)
u2Rep = represent(u2, nqubits=2)
for i in range(4):
assert u2Rep*qubit_to_matrix(IntQubit(i, 2)) == \
qubit_to_matrix(qapply(u2*IntQubit(i, 2)))
def superposition_basis(nqubits):
"""Creates an equal superposition of the computational basis.
Parameters
==========
nqubits : int
The number of qubits.
Returns
=======
state : Qubit
An equal superposition of the computational basis with nqubits.
Examples
========
Create an equal superposition of 2 qubits::
>>> from sympy.physics.quantum.grover import superposition_basis
>>> superposition_basis(2)
|0>/2 + |1>/2 + |2>/2 + |3>/2
"""
amp = 1/sqrt(2**nqubits)
return sum([amp*IntQubit(n, nqubits=nqubits) for n in range(2**nqubits)])
def test_IntQubit():
assert IntQubit(8).as_int() == 8
assert IntQubit(8).qubit_values == (1, 0, 0, 0)
assert IntQubit(7, 4).qubit_values == (0, 1, 1, 1)
assert IntQubit(3) == IntQubit(3, 2)
#test Dual Classes
assert IntQubit(3).dual_class() == IntQubitBra
assert IntQubitBra(3).dual_class() == IntQubit
assert IntQubit(5)._eval_innerproduct_IntQubitBra(
IntQubitBra(5)) == Integer(1)
assert IntQubit(4)._eval_innerproduct_IntQubitBra(
IntQubitBra(5)) == Integer(0)
raises(ValueError, lambda: IntQubit(4, 1))
def test_UGate_CGate_combo():
a, b, c, d = symbols('a,b,c,d')
uMat = Matrix([[a, b], [c, d]])
cMat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, a, b], [0, 0, c, d]])
# Test basic case where gate exists in 1-qubit space.
u1 = UGate((0, ), uMat)
cu1 = CGate(1, u1)
assert represent(cu1, nqubits=2) == cMat
assert qapply(cu1 * Qubit('10')) == a * Qubit('10') + c * Qubit('11')
assert qapply(cu1 * Qubit('11')) == b * Qubit('10') + d * Qubit('11')
assert qapply(cu1 * Qubit('01')) == Qubit('01')
assert qapply(cu1 * Qubit('00')) == Qubit('00')
# Test case where gate exists in a larger space.
u2 = UGate((1, ), uMat)
u2Rep = represent(u2, nqubits=2)
for i in range(4):
assert u2Rep*qubit_to_matrix(IntQubit(i, 2)) == \
qubit_to_matrix(qapply(u2*IntQubit(i, 2)))
def _represent_ZGate(self, basis, **options):
"""
Represent the OracleGate in the computational basis.
"""
nbasis = 2**self.nqubits # compute it only once
matrixOracle = eye(nbasis)
# Flip the sign given the output of the oracle function
for i in range(nbasis):
if self.search_function(IntQubit(i, nqubits=self.nqubits)):
matrixOracle[i, i] = NegativeOne()
return matrixOracle
def test_qubit():
q1 = Qubit("0101")
q2 = IntQubit(8)
assert str(q1) == "|0101>"
assert pretty(q1) == "|0101>"
assert upretty(q1) == u"❘0101⟩"
assert latex(q1) == r"{\left|0101\right\rangle }"
sT(q1, "Qubit(Integer(0),Integer(1),Integer(0),Integer(1))")
assert str(q2) == "|8>"
assert pretty(q2) == "|8>"
assert upretty(q2) == u"❘8⟩"
assert latex(q2) == r"{\left|8\right\rangle }"
sT(q2, "IntQubit(8)")
def test_IntQubit():
assert IntQubit(8).as_int() == 8
assert IntQubit(8).qubit_values == (1, 0, 0, 0)
assert IntQubit(7, 4).qubit_values == (0, 1, 1, 1)
assert IntQubit(3) == IntQubit(3, 2)
#test Dual Classes
assert IntQubit(3).dual_class() == IntQubitBra
assert IntQubitBra(3).dual_class() == IntQubit
raises(ValueError, lambda: IntQubit(4, 1))
def test_qubit():
q1 = Qubit('0101')
q2 = IntQubit(8)
assert str(q1) == '|0101>'
assert pretty(q1) == '|0101>'
assert upretty(q1) == u'❘0101⟩'
assert latex(q1) == r'{\left|0101\right\rangle }'
sT(q1, "Qubit(Integer(0),Integer(1),Integer(0),Integer(1))")
assert str(q2) == '|8>'
assert pretty(q2) == '|8>'
assert upretty(q2) == u'❘8⟩'
assert latex(q2) == r'{\left|8\right\rangle }'
sT(q2, "IntQubit(8)")
def test_IntQubit():
assert IntQubit(8).as_int() == 8
assert IntQubit(8).qubit_values == (1,0,0,0)
assert IntQubit(7, 4).qubit_values == (0,1,1,1)
assert IntQubit(3) == IntQubit(3,2)
#test Dual Classes
assert IntQubit(3).dual_class == IntQubitBra
assert IntQubitBra(3).dual_class == IntQubit
def test_grover_iteration_2():
numqubits = 4
basis_states = superposition_basis(numqubits)
v = OracleGate(numqubits, return_one_on_two)
# After (pi/4)sqrt(pow(2, n)), IntQubit(2) should have highest prob
# In this case, after around pi times (3 or 4)
iterated = grover_iteration(basis_states, v)
iterated = qapply(iterated)
iterated = grover_iteration(iterated, v)
iterated = qapply(iterated)
iterated = grover_iteration(iterated, v)
iterated = qapply(iterated)
# In this case, probability was highest after 3 iterations
# Probability of Qubit('0010') was 251/256 (3) vs 781/1024 (4)
# Ask about measurement
expected = (-13*basis_states)/64 + 264*IntQubit(2, numqubits)/256
assert qapply(expected) == iterated
def test_IntQubit():
iqb = IntQubit(8)
assert iqb.as_int() == 8
assert iqb.qubit_values == (1, 0, 0, 0)
iqb = IntQubit(7, 4)
assert iqb.qubit_values == (0, 1, 1, 1)
assert IntQubit(3) == IntQubit(3, 2)
#test Dual Classes
iqb = IntQubit(3)
iqb_bra = IntQubitBra(3)
assert iqb.dual_class() == IntQubitBra
assert iqb_bra.dual_class() == IntQubit
iqb = IntQubit(5)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(1)
iqb = IntQubit(4)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(0)
raises(ValueError, lambda: IntQubit(4, 1))
def n_kron(*args):
result = np.array([[1. + 0.j]])
for op in args:
result = np.kron(result, op)
return result
zero = np.array([[1. + 0.j], [0. + 0.j]])
one = np.array([[0. + 0.j], [1. + 0.j]])
print("> Sympy хэрэглэн qubit дүрслэх туршилтууд :\n")
print("qubit |5> буюу integer дүрслэл ")
q0 = IntQubit(5)
print("qubit int :", q0)
print("qubit nqubits :", q0.nqubits)
print("qubit values :", q0.qubit_values)
q1 = Qubit(q0)
print("sympy qubit дүрслэл :", q1, "\n")
print("IntQubit(1, 1)")
q2 = IntQubit(1, 1)
print(q2, Qubit(q2))
print("IntQubit(1,0,1,0,1)")
q3 = IntQubit(1, 0, 1, 0, 1)
print(q3, Qubit(q3))
print(q3.qubit_values)
print(Qubit(q3).qubit_values)
def test_OracleGate():
v = OracleGate(1, lambda qubits: qubits == IntQubit(0))
assert qapply(v*IntQubit(0)) == -IntQubit(0)
assert qapply(v*IntQubit(1)) == IntQubit(1)
nbits = 2
v = OracleGate(2, return_one_on_two)
assert qapply(v*IntQubit(0, nbits)) == IntQubit(0, nqubits=nbits)
assert qapply(v*IntQubit(1, nbits)) == IntQubit(1, nqubits=nbits)
assert qapply(v*IntQubit(2, nbits)) == -IntQubit(2, nbits)
assert qapply(v*IntQubit(3, nbits)) == IntQubit(3, nbits)
assert represent(OracleGate(1, lambda qubits: qubits == IntQubit(0)), nqubits=1) == \
Matrix([[-1, 0], [0, 1]])
assert represent(v, nqubits=2) == Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])
def test_superposition_basis():
nbits = 2
first_half_state = IntQubit(0, nqubits=nbits)/2 + IntQubit(1, nqubits=nbits)/2
second_half_state = IntQubit(2, nbits)/2 + IntQubit(3, nbits)/2
assert first_half_state + second_half_state == superposition_basis(nbits)
nbits = 3
firstq = (1/sqrt(8))*IntQubit(0, nqubits=nbits) + (1/sqrt(8))*IntQubit(1, nqubits=nbits)
secondq = (1/sqrt(8))*IntQubit(2, nbits) + (1/sqrt(8))*IntQubit(3, nbits)
thirdq = (1/sqrt(8))*IntQubit(4, nbits) + (1/sqrt(8))*IntQubit(5, nbits)
fourthq = (1/sqrt(8))*IntQubit(6, nbits) + (1/sqrt(8))*IntQubit(7, nbits)
assert firstq + secondq + thirdq + fourthq == superposition_basis(nbits)
def return_one_on_one(qubits):
return qubits == IntQubit(1, nqubits=qubits.nqubits)
q5 = QubitString(Qubit(1, 0, 1, 0, 0), "five") q6 = QubitString(Qubit(0, 1, 0, 1, 1, 0), "six") q7 = QubitString(Qubit(0, 0, 1, 1, 1, 0, 0), "seven") q8 = QubitString(Qubit(0, 0, 1, 0, 1, 0, 1, 0), "eight") qcol = QubitCollection() qcol.add(q1.qutuple) qcol.add(q2.qutuple) qcol.add(q3.qutuple) qcol.add(q4.qutuple) qcol.add(q5.qutuple) qcol.add(q6.qutuple) qcol.add(q7.qutuple) qcol.add(q8.qutuple) f1 = lambda qubits: qubits == IntQubit(1) f2 = lambda qubits: qubits == IntQubit(2) f3 = lambda qubits: qubits == IntQubit(3) f4 = lambda qubits: qubits == IntQubit(4) f5 = lambda qubits: qubits == IntQubit(5) f6 = lambda qubits: qubits == IntQubit(6) f7 = lambda qubits: qubits == IntQubit(7) f8 = lambda qubits: qubits == IntQubit(8) v1 = OracleGate(q1.nQubits(), f1) v2 = OracleGate(q2.nQubits(), f2) v3 = OracleGate(q3.nQubits(), f3) v4 = OracleGate(q4.nQubits(), f4) v5 = OracleGate(q5.nQubits(), f5) v6 = OracleGate(q6.nQubits(), f6) v7 = OracleGate(q7.nQubits(), f7)
def test_OracleGate():
v = OracleGate(1, lambda qubits: qubits == IntQubit(0))
assert qapply(v*IntQubit(0)) == -IntQubit(0)
assert qapply(v*IntQubit(1)) == IntQubit(1)
nbits = 2
v = OracleGate(2, return_one_on_two)
assert qapply(v*IntQubit(0, nbits)) == IntQubit(0, nbits)
assert qapply(v*IntQubit(1, nbits)) == IntQubit(1, nbits)
assert qapply(v*IntQubit(2, nbits)) == -IntQubit(2, nbits)
assert qapply(v*IntQubit(3, nbits)) == IntQubit(3, nbits)
# Due to a bug of IntQubit, this first assertion is buggy
# assert represent(OracleGate(1, lambda qubits: qubits == IntQubit(0)), nqubits=1) == \
# Matrix([[-1/sqrt(2), 0], [0, 1/sqrt(2)]])
assert represent(v, nqubits=2) == Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])
def return_one_on_two(qubits):
return qubits == IntQubit(2, qubits.nqubits)
def test_IntQubit():
# issue 9136
iqb = IntQubit(0, nqubits=1)
assert qubit_to_matrix(Qubit('0')) == qubit_to_matrix(iqb)
qb = Qubit('1010')
assert qubit_to_matrix(IntQubit(qb)) == qubit_to_matrix(qb)
iqb = IntQubit(1, nqubits=1)
assert qubit_to_matrix(Qubit('1')) == qubit_to_matrix(iqb)
assert qubit_to_matrix(IntQubit(1)) == qubit_to_matrix(iqb)
iqb = IntQubit(7, nqubits=4)
assert qubit_to_matrix(Qubit('0111')) == qubit_to_matrix(iqb)
assert qubit_to_matrix(IntQubit(7, 4)) == qubit_to_matrix(iqb)
iqb = IntQubit(8)
assert iqb.as_int() == 8
assert iqb.qubit_values == (1, 0, 0, 0)
iqb = IntQubit(7, 4)
assert iqb.qubit_values == (0, 1, 1, 1)
assert IntQubit(3) == IntQubit(3, 2)
#test Dual Classes
iqb = IntQubit(3)
iqb_bra = IntQubitBra(3)
assert iqb.dual_class() == IntQubitBra
assert iqb_bra.dual_class() == IntQubit
iqb = IntQubit(5)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(1)
iqb = IntQubit(4)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(0)
raises(ValueError, lambda: IntQubit(4, 1))
raises(ValueError, lambda: IntQubit('5'))
raises(ValueError, lambda: IntQubit(5, '5'))
raises(ValueError, lambda: IntQubit(5, nqubits='5'))
raises(TypeError, lambda: IntQubit(5, bad_arg=True))
def find_r(x, N):
"""
Encontra o período de x em aritimética módulo N.
Essa é a parte realmente quântica da solução.
Põe a primeira parte do registrador em um estado de superposição |j> |0>,
com j = 0 to 2 ** n - 1, usando a porta Hadamard.
Depois aplica a porta Vx e IQFT para determinar a ordem de x.
"""
# Calcula o número de qubits necessários
n = int(math.ceil(log(N, 2)))
t = int(math.ceil(2 * log(N, 2)))
print("n: ", n)
print("t: ", t)
# Cria o registrador
register = Qubit(IntQubit(0, t + n))
print("register: ", register)
# Põe a segunda metade do registrado em superposição |1>|0> + |2>|0> + ... |j>|0> + ... + |2 ** n - 1>|0>
print("Aplicando Hadamard...")
circuit = 1
for i in reversed(list(range(n, n + t))):
circuit = HadamardGate(i) * circuit
circuit = qapply(circuit * register)
print("Circuit Hadamard:\n", circuit.simplify())
# Calcula os valores para a primeira metade do registrador |1>|x ** 1 % N> + |2>|x ** 2 % N> + ... + |k>|x ** k % N >+ ... + |2 ** n - 1 = j>|x ** j % N>
print("Aplicando Vx...")
circuit = qapply(Vx(n, t, x, N) * circuit)
print("Circuit Vx:\n", circuit.simplify())
# Faz a medição da primeira metade do registrador obtendo um dos [x ** j % N's]
print("Medindo 0->n ...")
circuit = measure_partial_oneshot(circuit, range(n))
print("Circuit 0->n:\n", circuit.simplify())
# Aplica a Transformada de Fourier Quântica Inversa na segunda metade do registrador
print("Aplicando a transformada inversa...")
circuit = qapply(IQFT(n, n + t).decompose() * circuit)
print("Circuit IQFT:\n", circuit.simplify())
# Faz a medição da segunda metade do registrador um dos valores da transformada
while (
True
): # O correto seria repetir a rotina inteira, mas é suficiente repetir a medição.
# Num computador quântico real o estado colapsaria e não seria possível medi-lo novamente.
print("Medindo n->n+t ...")
#measurement = measure_partial_oneshot(circuit, range(n, n + t))
measurement = measure_all_oneshot(circuit)
print(measurement.simplify())
if isinstance(measurement, Qubit):
register = measurement
elif isinstance(measurement, Mul):
register = measurement.args[-1]
else:
register = measurement.args[-1].args[-1]
print("Medicao: ", register)
# Converte o qubit de binário para decimal
k = 1
answer = 0
for i in range(t):
answer += k * register[n + i]
k = k << 1
print("Medicao: ", answer)
if answer != 0:
break
print("2^t: ", 2**t)
# Lista os termos da fração continuada
fraction = continued_fraction(answer, 2**t)
# A soma dos termos da fração continuada é a razão entre dois
# números primos entre si (p e q onde MDC(p, q) == 1) que
# multiplicados resultam N (somar apenas os termos menores ou iguais a N)
r = 0
for x in fraction:
if (x > N):
break
else:
print("fraction: ", x)
r = r + x
return r
def test_sympy__physics__quantum__qubit__IntQubit():
from sympy.physics.quantum.qubit import IntQubit
assert _test_args(IntQubit(0))
def demo_vgate_app(v):
for i in range(2**v.nqubits):
print('qapply(v*IntQubit(%i, %r))' % (i, v.nqubits))
pprint(qapply(v * IntQubit(i, nqubits=v.nqubits)))
qapply(v * IntQubit(i, nqubits=v.nqubits))
def test_IntQubit():
iqb = IntQubit(8)
assert iqb.as_int() == 8
assert iqb.qubit_values == (1, 0, 0, 0)
iqb = IntQubit(7, 4)
assert iqb.qubit_values == (0, 1, 1, 1)
assert IntQubit(3) == IntQubit(3, 2)
#test Dual Classes
iqb = IntQubit(3)
iqb_bra = IntQubitBra(3)
assert iqb.dual_class() == IntQubitBra
assert iqb_bra.dual_class() == IntQubit
iqb = IntQubit(5)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(1)
iqb = IntQubit(4)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(0)
raises(ValueError, lambda: IntQubit(4, 1))
def test_grover_iteration_1():
numqubits = 2
basis_states = superposition_basis(numqubits)
v = OracleGate(numqubits, return_one_on_one)
expected = IntQubit(1, nqubits=numqubits)
assert qapply(grover_iteration(basis_states, v)) == expected
def demo_vgate_app(v):
for i in range(2**v.nqubits):
print 'qapply(v*IntQubit({0}, {1}))'.format(i, v.nqubits)
pprint(qapply(v * IntQubit(i, v.nqubits)))
qapply(v * IntQubit(i, v.nqubits))
def test_OracleGate():
v = OracleGate(1, lambda qubits: qubits == IntQubit(0))
assert qapply(v*IntQubit(0)) == -IntQubit(0)
assert qapply(v*IntQubit(1)) == IntQubit(1)
nbits = 2
v = OracleGate(2, return_one_on_two)
assert qapply(v*IntQubit(0, nbits)) == IntQubit(0, nbits)
assert qapply(v*IntQubit(1, nbits)) == IntQubit(1, nbits)
assert qapply(v*IntQubit(2, nbits)) == -IntQubit(2, nbits)
assert qapply(v*IntQubit(3, nbits)) == IntQubit(3, nbits)
def test_IntQubit():
# issue 9136
iqb = IntQubit(0, nqubits=1)
assert qubit_to_matrix(Qubit('0')) == qubit_to_matrix(iqb)
qb = Qubit('1010')
assert qubit_to_matrix(IntQubit(qb)) == qubit_to_matrix(qb)
iqb = IntQubit(1, nqubits=1)
assert qubit_to_matrix(Qubit('1')) == qubit_to_matrix(iqb)
assert qubit_to_matrix(IntQubit(1)) == qubit_to_matrix(iqb)
iqb = IntQubit(7, nqubits=4)
assert qubit_to_matrix(Qubit('0111')) == qubit_to_matrix(iqb)
assert qubit_to_matrix(IntQubit(7, 4)) == qubit_to_matrix(iqb)
iqb = IntQubit(8)
assert iqb.as_int() == 8
assert iqb.qubit_values == (1, 0, 0, 0)
iqb = IntQubit(7, 4)
assert iqb.qubit_values == (0, 1, 1, 1)
assert IntQubit(3) == IntQubit(3, 2)
#test Dual Classes
iqb = IntQubit(3)
iqb_bra = IntQubitBra(3)
assert iqb.dual_class() == IntQubitBra
assert iqb_bra.dual_class() == IntQubit
iqb = IntQubit(5)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(1)
iqb = IntQubit(4)
iqb_bra = IntQubitBra(5)
assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(0)
raises(ValueError, lambda: IntQubit(4, 1))
raises(ValueError, lambda: IntQubit('5'))
raises(ValueError, lambda: IntQubit(5, '5'))
raises(ValueError, lambda: IntQubit(5, nqubits='5'))
raises(TypeError, lambda: IntQubit(5, bad_arg=True))
def black_box(qubits):
return True if qubits == IntQubit(1, nqubits=qubits.nqubits) else False