Compilador Quântico Aproximado

qiskit.synthesis.unitary.aqc

Implementação do Approximate Quantum Compiler, conforme descrito no artigo [1].

Interface

A interface pública principal desse módulo é acessada passando unitary_synthesis_method='aqc' para transpile(). Isso trocará o método de síntese para usar AQCSynthesisPlugin. As classes individuais são:

Detalhes matemáticos

Estamos interessados em compilar um circuito quântico, que formalizamos como a descoberta da melhor representação do circuito em termos de uma sequência de portas ordenadas de uma matriz unitária de destino $U\in U(d)$, com algumas restrições adicionais de hardware. Em particular, analisamos as representações que podem ser restringidas em termos de conectividade de hardware, bem como a profundidade da porta, e escolhemos uma base de porta em termos de CNOT e portas de rotação. Lembramos que a combinação de CNOT e portas de rotação é universal em $SU(d)$ e, portanto, não limita a compilação.

Para definir adequadamente o que entendemos por “melhor representação do circuito”, definimos a métrica como a norma de Frobenius entre a matriz unitária do circuito compilado $V$ e a matriz unitária alvo $U$, ou seja, $\|V - U\|_{\mathrm{F}}$. Essa escolha é motivada por considerações de programação matemática e está relacionada a outras formulações que aparecem na literatura. Vamos analisar o problema com mais detalhes.

Seja $n$ o número de qubits e $d=2^n$. Dada uma estrutura CNOT $ct$ e um vetor de ângulos de rotação $\theta$, o circuito paramétrico forma uma matriz $Vct(\theta)\in SU(d)$. Se nos for dado um circuito-alvo que forma uma matriz $U\in SU(d)$, gostaríamos de calcular

em que o produto interno é o produto interno de Frobenius. Observe que $|\langle V,U\rangle|\leq d$ para todas as unidades $U$ e $V$, de modo que o objetivo tem alcance em $[0,1]$.

Nossa estratégia é maximizar

usando seu gradiente. Agora discutiremos os detalhes específicos por meio de um exemplo.

Embora o intervalo de $Vct$ seja um subconjunto de $SU(d)$ por construção, o circuito de destino pode formar uma matriz unitária geral. Entretanto, para qualquer $U\in U(d)$,

Portanto, devemos normalizar o circuito de destino por sua fase global e, em seguida, compilar aproximadamente o circuito normalizado. Podemos adicionar a fase global novamente depois.

No algoritmo, deixe $U'$ denotar a matriz de destino não normalizada e $U$ a matriz de destino normalizada. Agora que temos $U$, fornecemos a função gradiente ao otimizador do método de Nesterov e calculamos $\theta$.

Para adicionar a fase global novamente, podemos formar o circuito de controle como

Observe que, embora tenhamos otimizado usando o método de Nesterov no artigo, isso foi feito por causa de suas garantias de convergência, não por sua velocidade na prática. É muito mais rápido usar o L-BFGS, que é usado como otimizador padrão nessa implementação.

Um uso básico do algoritmo AQC deve consistir nas seguintes etapas:

# 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
)

Agora, approximate_circuit é um circuito que aproxima o unitário de destino até certo ponto e pode ser usado no lugar da matriz original.

Isso usa uma função auxiliar, make_cnot_network.

make_cnot_network

É possível tirar proveito da versão acelerada da função objetiva. Ele implementa o mesmo algoritmo matemático que o padrão DefaultCNOTUnitObjective , mas é executado várias vezes mais rápido. A instanciação da classe de função objetiva acelerada é semelhante ao caso padrão:

# Crie um objetivo que defina nosso problema de otimização approximating_objective = FastCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)

O restante do código no exemplo acima não é alterado.

Referências

[1] : Liam Madden, Andrea Simonetto, Best Approximate Quantum Compiling Problems (Problemas de compilação quântica com melhor aproximação).

arXiv:2106.05649