renom_q.quantumcircuit

class renom_q.quantumcircuit. QuantumCircuit ( *args , set_qasm=False , set_print_matrix=False , circuit_number=0 )

Bases: object

Definite a quantum circuit.

Args:
* args (renom_q.QuantumRegister and renom_q.ClassicalRegister):
Quantum registers and classical registers that a quantum circuit consists of. In both registers, defining multiple registers is possible, but at least one register needed.
circuit_number (int):
The number used when conflating multiple quantum circuits. There is no need for the user to input.
Example 1: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
Example 2: 
>>> import renom_q
>>> qa = renom_q.QuantumRegister(1, 'qa')
>>> qb = renom_q.QuantumRegister(1, 'qb')
>>> ca = renom_q.ClassicalRegister(1, 'ca')
>>> cb = renom_q.ClassicalRegister(1, 'cb')
>>> qc = renom_q.QuantumCircuit(qa, ca, qb, cb)
Example 3: 
>>> import renom_q
>>> qa = renom_q.QuantumRegister(1, 'qa')
>>> qb = renom_q.QuantumRegister(1, 'qb')
>>> ca = renom_q.ClassicalRegister(1, 'ca')
>>> cb = renom_q.ClassicalRegister(1, 'cb')
>>> qca = renom_q.QuantumCircuit(qa, ca)
>>> qcb = renom_q.QuantumCircuit(qb, cb)
>>> qc = qca + qcb
qasm ( )

Print the qasm code of quantum circuit.

Returns:
qasm_string (str):
A string of qasm code of quantum circuit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c, set_qasm=True)
>>> qc.x(q[0])
>>> qc.measure()
>>> print(qc.qasm())
OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
creg c[1];
x q[0];
measure q[0] -> c[0];
measure_exec ( statevector )
barrier ( *args )

Add a barrier block in circuit diagram.

args:
* args (renom_q.QuantumRegister, tuple or None):
If arg type is a tuple (ex: q[0]), a quantum register No.0 is added a barrier block. If arg type is a renom_q.QuantumRegister, all quantum registers in renom_q.QuantumRegister are added a barrier block. If arg type is None, all of multiple quantum registers are added a barrier block.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.barrier()
ccx ( q_ctl1 , q_ctl2 , q_tgt )

Apply ccx gate to quantum register.

Args:
q_ctl1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s one of the control qubit.
q_ctl2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s one of the control qubit.
q_tgt (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(3)
>>> c = renom_q.ClassicalRegister(3)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.ccx(q[0], q[1], q[2])
ch ( q_num1 , q_num2 )

Apply ch gate to quantum register.

Args:
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.ch(q[0], q[1])
convert_q_number ( q_num )
crz ( lam , q_num1 , q_num2 )

Apply crz gate to quantum register.

Args:
lam (float):
Rotation angle of quantum statevector.
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.crz(math.pi, q[0], q[1])
cs ( q_num1 , q_num2 )

Apply cs gate to quantum register.

Args:
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cs(q[0], q[1])
cswap ( q_ctl , q_num1 , q_num2 )

Apply cswap gate to quantum register.

Args:
q_ctl (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the exchanging qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the exchanging qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(3)
>>> c = renom_q.ClassicalRegister(3)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cswap(q[0], q[1], q[2])
cu1 ( lam , q_num1 , q_num2 )

Apply cu1 gate to quantum register.

Args:
lam (float):
The paramater of unitary gate cU1.
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cu1(math.pi, q[0], q[1])
cu3 ( theta , phi , lam , q_num1 , q_num2 )

Apply cu3 gate to quantum register.

Args:
theta (float):
The paramater of unitary gate cU3.
phi (float):
The paramater of unitary gate cU3.
lam (float):
The paramater of unitary gate cU3.
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cu3(math.pi, 0, math.pi, q[0], q[1])
cx ( q_num1 , q_num2 )

Apply cx gate to quantum register.

Args:
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cx(q[0], q[1])
cy ( q_num1 , q_num2 )

Apply cy gate to quantum register.

Args:
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cy(q[0], q[1])
cz ( q_num1 , q_num2 )

Apply cz gate to quantum register.

Args:
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the control qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the target qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.cz(q[0], q[1])
gate_base1 ( gate_matrix , num , gatemark )
gate_base2 ( gate_matrix , ctl , tgt , gatemark )
h ( q_num )

Apply h gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.h(q[0])
id ( q_num )

Apply id gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.id(q[0])
measure ( *args )

Measure the quantum state of the qubits.

args:
* args (renom_q.QuantumRegister and renom_q.ClassicalRegister, tuple and tuple or None):
If arg type is tuple and tuple (ex: q[0], c[0]), measured a quantum register No.0 into a classical register No.0. If arg type is a renom_q.QuantumRegister and a renom_q.ClassicalRegister, measured all quantum registers in renom_q.QuantumRegister into all classical registers in renom_q.ClassicalRegister. If arg is None, measured all of multiple quantum registers into all classical registers in renom_q.ClassicalRegister. Only when definited single classical register, coding like example1 is possible.
Example 1: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.h(q[0])
>>> qc.measure()
Example 2: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.h(q[0])
>>> qc.measure(q, c)
Example 3: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.h(q[0])
>>> for i in range(2):
...     qc.measure(q[i], c[i])
reset ( )

Apply reset gate to quantum register.

Thie gate is available only when resetting all quantum register.

Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.reset()
rx ( theta , q_num )

Apply rx gate to quantum register.

Args:
theta (float):
Rotation angle of quantum statevector.
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.rx(math.pi, q[0])
ry ( theta , q_num )

Apply ry gate to quantum register.

Args:
theta (float):
Rotation angle of quantum statevector.
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.ry(math.pi, q[0])
rz ( theta , q_num )

Apply rz gate to quantum register.

Args:
theta (float):
Rotation angle of quantum statevector.
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.rz(math.pi, q[0])
s ( q_num )

Apply s gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.s(q[0])
sdg ( q_num )

Apply sdg gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.sdg(q[0])
swap ( q_num1 , q_num2 )

Apply swap gate to quantum register.

Args:
q_num1 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the exchanging qubit.
q_num2 (tuple):
A tuple of a quantum register and its index (ex:q[0]). It’s the exchanging qubit.
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(2)
>>> c = renom_q.ClassicalRegister(2)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.swap(q[0], q[1])
t ( q_num )

Apply t gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.t(q[0])
tdg ( q_num )

Apply tdg gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.tsg(q[0])
u1 ( lam , q_num )

Apply u1 gate to quantum register.

Args:
lam (float):
The paramater of unitary gate U1.
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.u1(math.pi, q[0])
u2 ( phi , lam , q_num )

Apply u2 gate to quantum register.

Args:
phi (float):
The paramater of unitary gate U2.
lam (float):
The paramater of unitary gate U2.
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.u2(0, math.pi, q[0])
u3 ( theta , phi , lam , q_num )

Apply u3 gate to quantum register.

Args:
theta (float):
The paramater of unitary gate U3.
phi (float):
The paramater of unitary gate U3.
lam (float):
The paramater of unitary gate U3.
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.u3(math.pi, 0, math.pi, q[0])
x ( q_num )

Apply x gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.x(q[0])
y ( q_num )

Apply y gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.y(q[0])
z ( q_num )

Apply z gate to quantum register.

Args:
q_num (tuple):
A tuple of a quantum register and its index (ex:q[0]).
Example: 
>>> import renom_q
>>> q = renom_q.QuantumRegister(1)
>>> c = renom_q.ClassicalRegister(1)
>>> qc = renom_q.QuantumCircuit(q, c)
>>> qc.z(q[0])
convert_c_number ( c_num )