added multi-controls multi-targets, extra gates

[JamesB-1qbit]

Added support for multiple targets and multiple controls.
A few extra gates have been added that are needed for derangement circuits, QFT and time-evolution.

[alexfleury-sb]

If I may suggest some more compact code to perform those checks and recasting to a python built-in int:

if not isinstance(target, (list, ndarray)):
    target = [target]

if all(isinstance(t, (int, integer)) and t >= 0 for t in target):
    target = [int(t) for t in target]
else:
    raise ValueError(f"Target={target[0] if len(target)==1 else target} must be a (or array-like of) positive integer(s).")

I would do the same for the control part.

[ValentinS4t1qbit]

Thank you for looking into this, this is not easy !

• Some suggestions for how to handle extra controls and targets in the code, and to make your code more concise and improve readability / avoid many multi-indendation and branches.

• I don't have the impression that any of the new gates you've supported have been tested in the translation module.

• We should maybe think about how to document what we support and dont support for our different backends if relevant to users. There are differences in conventions, gates supported, multi-controls... Some of that is handled in variables, some in errors... do we need more in our docs?

[ValentinS4t1qbit]

I'm not sure why we'd want to support strings as input. Is there a reason for users to use strings for target / control qubits, or for us to encourage them to do so?

[ValentinS4t1qbit]

I think this blob of code may be simplified. What do you think about the following suggestions?
Are there cases we expect users may fall into that are not covered well by this ?

# 1. Turn whatever you have as a list
# A list would remain a list, and won't become a list of list. A single element would become a list of 1 element.
# numpy integers are turned into python integers in the process (https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tolist.html)
indices = target.tolist() if isinstance(target, np.ndarray) else list(target)

# 2.a We want to check that these are all integers, and non-negative
# The following solution seems succint, but we lose information about what index was problematic. 
# We however really don't expect many control or target qubits as input to a gate (idk, 2-3 of them at most?)
# so it's probably enough tbh
if any((ind < 0 or not type(ind) != int) for ind in indices):
   raise ValueError(f"All target qubit indices must be non-negative integers.")

# 2.b Keep the loop, report all "infractions", only raise error once we're done.
# No try and except needed, unless you think instructions may unexpectedly fail out of nowhere
errmsg =""
for ind in target:
   if (ind < 0) or (type(ind) != int):
          errmsg += f"\n Target qubit index {ind} is not a non-negative integer"

if errmsg:
   raise ValueError(f"Error: type or value of qubit index not as expected. See details below:")

[ValentinS4t1qbit]

Good work, quite a few changes in there. This module is starting to get messy, I wonder if there's some python features or design here that could help us.

I think we should look how pytket handles things, because if what they do is open-source, then we could get really reliable stuff and considerably reduce codebase.