Compilateur quantique approximatif

qiskit.synthesis.unitary.aqc

Implémentation d'un compilateur quantique approximatif tel que décrit dans l'article [1.]

Interface

L'interface publique principale de ce module est accessible en passant unitary_synthesis_method='aqc' à transpile(). La méthode de synthèse sera alors modifiée pour utiliser AQCSynthesisPlugin. Les classes individuelles sont les suivantes

Détails mathématiques

Nous nous intéressons à la compilation d'un circuit quantique, que nous formalisons comme la recherche de la meilleure représentation du circuit en termes de séquence de portes ordonnée d'une matrice unitaire cible $U\in U(d)$, avec quelques contraintes matérielles supplémentaires. En particulier, nous recherchons des représentations qui pourraient être limitées en termes de connectivité matérielle et de profondeur de porte, et nous choisissons une base de porte en termes de CNOT et de portes de rotation. Nous rappelons que la combinaison des portes CNOT et de rotation est universelle sur le site $SU(d)$ et qu'elle ne limite donc pas la compilation.

Pour définir clairement ce que nous entendons par « meilleure représentation du circuit », nous définissons cette mesure comme la norme de Frobenius entre la matrice unitaire du circuit compilé $V$ et la matrice unitaire cible $U$, c'est-à-dire $\|V - U\|_{\mathrm{F}}$. Ce choix s'appuie sur des considérations de programmation mathématique et s'inscrit dans le prolongement d'autres formulations présentes dans la littérature. Examinons ce problème plus en détail.

Soit $n$ le nombre de qubits et $d=2^n$. Étant donné une structure CNOT $ct$ et un vecteur d'angles de rotation $\theta$, le circuit paramétrique forme une matrice $Vct(\theta)\in SU(d)$. Si l'on nous donne un circuit cible formant une matrice $U\in SU(d)$, nous aimerions calculer

où le produit intérieur est le produit intérieur de Frobenius. Notez que $|\langle V,U\rangle|\leq d$ pour tous les unitaires $U$ et $V$, de sorte que l'objectif a une portée dans $[0,1]$.

Notre stratégie consiste à maximiser

à l'aide de son gradient. Nous allons maintenant en aborder les spécificités à l'aide d'un exemple.

Bien que la plage de $Vct$ soit un sous-ensemble de $SU(d)$ par construction, le circuit cible peut former une matrice unitaire générale. Cependant, pour tout $U\in U(d)$,

Il convient donc de normaliser le circuit cible en fonction de sa phase globale, puis de compiler approximativement le circuit normalisé. Nous pourrons ajouter la phase globale par la suite.

Dans l'algorithme, $U'$ désigne la matrice cible non normalisée et $U$ la matrice cible normalisée. Maintenant que nous avons $U$, nous donnons la fonction de gradient à l'optimiseur de la méthode de Nesterov et calculons $\theta$.

Pour ajouter la phase globale, nous pouvons former le circuit de commande comme suit

Notez que si nous avons optimisé en utilisant la méthode de Nesterov dans le document, c'était pour ses garanties de convergence, et non pour sa rapidité en pratique. Il est beaucoup plus rapide d'utiliser L-BFGS qui est utilisé comme optimiseur par défaut dans cette implémentation.

Une utilisation de base de l'algorithme AQC devrait comprendre les étapes suivantes :

# Define a target circuit as a unitary matrix
unitary = ...

# Define a number of qubits for the algorithm, at least 3 qubits
num_qubits = round(math.log2(unitary.shape[0]))

# Choose a layout of the CNOT structure for the approximate circuit, e.g. ``spin`` for
# a linear layout.
layout = options.get("layout") or "spin"

# Choose a connectivity type, e.g. ``full`` for full connectivity between qubits.
connectivity = options.get("connectivity") or "full"

# Define a targeted depth of the approximate circuit in the number of CNOT units.
depth = int(options.get("depth") or 0)

# Generate a network made of CNOT units
cnots = make_cnot_network(
    num_qubits=num_qubits,
    network_layout=layout,
    connectivity_type=connectivity,
    depth=depth
)

# Create an optimizer to be used by AQC
optimizer = partial(scipy.optimize.minimize, method="L-BFGS-B")

# Create an instance
aqc = AQC(optimizer)

# Create a template circuit that will approximate our target circuit
approximate_circuit = CNOTUnitCircuit(num_qubits=num_qubits, cnots=cnots)

# Create an objective that defines our optimization problem
approximating_objective = DefaultCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)

# Run optimization process to compile the unitary
aqc.compile_unitary(
    target_matrix=unitary,
    approximate_circuit=approximate_circuit,
    approximating_objective=approximating_objective
)

Maintenant, approximate_circuit est un circuit qui approxime l'unité cible à un certain degré et peut être utilisé à la place de la matrice originale.

Cette fonction utilise une fonction d'aide, make_cnot_network.

make_cnot_network

On peut tirer parti de la version accélérée de la fonction objective. Il met en œuvre le même algorithme mathématique que l'algorithme par défaut DefaultCNOTUnitObjective mais s'exécute plusieurs fois plus rapidement. L'instanciation de la classe de fonction objective accélérée est similaire au cas par défaut :

# Créer un objectif qui définit notre problème d'optimisation approximativement_objectif = FastCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)

Le reste du code de l'exemple ci-dessus ne change pas.

Références

[1] : Liam Madden, Andrea Simonetto, Best Approximate Quantum Compiling Problems.

arXiv:2106.05649