Remove qargs/cargs/circuit from instructions, in favor of circuit keeping context

[ajavadia]

Summary

Currently each instruction knows about the qubits and cbits that it is attached to. There are two problems with this:
1- It is redundant, as when building a DAG, there are edges corresponding to the qubits and cbits incoming to an instruction. So it adds the burden that these two sources of information must always be synced.
2- It prevents the instruction from being anonymous and thus reused and attached elsewhere.

Additionally, each instruction has a pointer to the circuit that contains it. This is also redundant, cyclic information, and causes many headaches (for example copying instructions amounts to a massively expensive operation). As a result there has been extensive efforts to avoid copying instructions (#1431, #1530), which made the code more verbose and hacky.

In this PR, I remove qargs and cargs from instructions, and give the responsibility of keeping context for each instruction to the circuit. Additionally I remove the circuit pointer, making the instructions very light-weight.

Examples:

So now you can create circuits like this (these can be e.g. opaque gates):

from qiskit import QuantumRegister
from qiskit import QuantumCircuit
from qiskit.circuit import Gate

q = QuantumRegister(3)
circ = QuantumCircuit(q)
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
circ.append(my_gate, [q[0], q[1]])
circ.append(my_gate, [q[1], q[2]])
circ.draw()

         ┌─────────┐           
q1_0: |0>┤         ├───────────
         │ My_gate │┌─────────┐
q1_1: |0>┤         ├┤         ├
         └─────────┘│ My_gate │
q1_2: |0>───────────┤         ├
                    └─────────┘

Or custom composite gate:

# build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name='sub_circ')
sub_circ.h(sub_q[0])
sub_circ.crz(0.1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.iden(sub_q[1])
sub_circ.u3(0.1, 0.2, -0.2, sub_q[0])

# convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()
circ.append(sub_inst, [q[1], q[2]])
circ.draw()

q3_0: |0>────────────
         ┌──────────┐
q3_1: |0>┤          ├
         │ Sub_circ │
q3_2: |0>┤          ├
         └──────────┘

This will decompose to the sub gates when it goes through a Decompose or Unroller pass.

from qiskit import BasicAer
from qiskit.transpiler.passes import Decompose
from qiskit.transpiler import PassManager, transpile

sim = BasicAer.get_backend('qasm_simulator')

passes = [
    Decompose()
]
pm = PassManager(passes)
new_circ = transpile(circ, sim, pass_manager=pm)
new_circ.draw()

                                                
q3_0: |0>───────────────────────────────────────
         ┌───┐            ░ ┌──────────────────┐
q3_1: |0>┤ H ├─────■──────░─┤ U3(0.1,0.2,-0.2) ├
         └───┘┌────┴────┐ ░ ├──────────────────┤
q3_2: |0>─────┤ Rz(0.1) ├─░─┤        Id        ├
              └─────────┘ ░ └──────────────────┘

Details and comments

1- Adds a public circuit.append() method that allows any operation to be added to the circuit on any wires (as long as the shapes match).

2- Adds a circuit.to_instruction() method to convert a constructed circuit to a Gate, which can then be added into another circuit. A gate is anonymous and not attached to any registers, so it's more flexible.

3- Adds a circuit.decompose() method that decomposes each composite instruction in the circuit by one level. Recursively calling this fuction will decompose the circuit entirely to a U and CX basis.

4- CompositeGate is no longer used. Instead, any Gate can be composite or not (for example, ZGate is a composite that is made up of U1Gate). If you build a gate from a circuit, then that circuit is your decomposition rule.

5- An instruction is uniquely identified by the following:
its type, name, num_qubits/num_clbits (i.e. its shape), and params.

6- Removed the reapply() method of instructions as it is no longer needed (it was used to attach a gate to the same qubits it was defined on).

7- The logic of how to print QASM is now in the circuit, because the instructions are significantly simplified.

Breaking Changes

Everything should work in a backwards compatible way except the following syntax for inverting gates:

circuit.s(qr).inverse()

This is not possible to keep with the current method because it requires an instruction to know about the circuit it is attached to. I think this is a weird syntax to begin with, and it should eventually have been removed. This basically says attach a gate, then modify it in place. Instead, we should attach modified versions of the instructions in the first place. For example:

circuit.append(SGate().inverse(), qr)
circuit.append(SGate().control(), qr)
circuit.append(SGate().power(), qr)
etc.