Plug-ins de síntese

qiskit.transpiler.passes.synthesis.plugin

Esse módulo define as interfaces de plug-in para as passagens do transpilador de síntese no Qiskit. Eles fornecem um ponto de conexão para que os pacotes python externos implementem suas próprias técnicas de síntese e as exponham perfeitamente como opções opcionais aos usuários quando eles executam o transpile().

As interfaces de plug-in são criadas usando pontos de entrada de setuptools que permitem que pacotes externos ao qiskit anunciem que incluem um plug-in de síntese.

Consulte qiskit.transpiler.preset_passmanagers.plugin para obter detalhes sobre como escrever plug-ins para estágios do transpilador.

API do plug-in Synthesis

API do plug-in de síntese unitária

API do plug-in de síntese de alto nível

Escrevendo Plugins

Plug-ins de síntese unitária

Para escrever um plug-in de síntese unitária, há duas etapas principais. O primeiro passo é criar uma subclasse da classe abstrata do plugin: UnitarySynthesisPlugin. A classe do plug-in define a interface e o contrato para plug-ins de síntese unitária. O método principal é run() aquele que recebe um único argumento posicional — uma matriz unitária na forma de um array numpy — e deve retornar um DAGCircuit objeto que represente o circuito sintetizado a partir dessa matriz unitária. Em seguida, para informar ao transpiler do Qiskit quais informações são necessárias para essa etapa, há vários métodos de propriedade obrigatórios que precisam ser implementados, tais como supports_basis_gates e supports_coupling_map , dependendo se o plug-in suporta e/ou requer essa entrada para realizar a síntese. Para obter todos os detalhes, consulte a UnitarySynthesisPlugin documentação sobre todos os campos obrigatórios. Uma classe de plugin de exemplo seria algo como:

from qiskit.transpiler.passes.synthesis import plugin
from qiskit_plugin_pkg.synthesis import generate_dag_circuit_from_matrix


class SpecialUnitarySynthesis(plugin.UnitarySynthesisPlugin):
    @property
    def supports_basis_gates(self):
        return True

    @property
    def supports_coupling_map(self):
        return False

    @property
    def supports_natural_direction(self):
        return False

    @property
    def supports_pulse_optimize(self):
        return False

    @property
    def supports_gate_lengths(self):
        return False

    @property
    def supports_gate_errors(self):
        return False

    @property
    def supports_gate_lengths_by_qubit(self):
        return False

    @property
    def supports_gate_errors_by_qubit(self):
        return False

    @property
    def min_qubits(self):
        return None

    @property
    def max_qubits(self):
        return None

    @property
    def supported_bases(self):
        return None

    def run(self, unitary, **options):
        basis_gates = options['basis_gates']
        dag_circuit = generate_dag_circuit_from_matrix(unitary, basis_gates)
        return dag_circuit

Se, por algum motivo, os parâmetros disponíveis para o run() método forem insuficientes, por favor, abra uma solicitação para que possamos discutir a ampliação da interface do plug-in com novos parâmetros opcionais que possam ser adicionados de forma compatível com versões anteriores em lançamentos futuros. No entanto, é importante observar que a interface deste plug-in é considerada estável e há garantia de que não sofrerá alterações que causem incompatibilidade. Caso sejam necessárias alterações (por exemplo, para ampliar as opções de entrada disponíveis), elas serão feitas de forma a não exigir alterações nos plug-ins existentes.

O segundo passo é definir o UnitarySynthesisPlugin como ponto de entrada do setuptools nos metadados do pacote. Para isso, basta adicionar uma entry-points tabela no pyproject.toml pacote do plug-in com os pontos de entrada necessários no qiskit.unitary_synthesis namespace. Por exemplo:

[project.entry-points."qiskit.unitary_synthesis"]
"special" = "qiskit_plugin_pkg.module.plugin:SpecialUnitarySynthesis"

Não há um limite para o número de plug-ins que um único pacote pode incluir, desde que cada plug-in tenha um nome exclusivo. Portanto, um único pacote pode expor vários plug-ins, se necessário. O nome default é usado pelo próprio Qiskit e não pode ser usado em um plug-in.

Configuração do plugin de síntese unitária

Para alguns plug-ins de síntese unitária que expõem várias opções e ajustes, a interface do plug-in tem uma opção para que os usuários forneçam um dicionário de configuração de forma livre. Isso será passado para o método run() como o kwarg options . Se o seu plug-in tiver essas opções de configuração, você deverá documentar claramente como um usuário deve especificar essas opções de configuração e como elas são usadas, já que se trata de um campo de formulário livre.

Plug-ins de síntese de alto nível

Escrever um plug-in de síntese de alto nível é, conceitualmente, semelhante a escrever um plug-in de síntese unitária. O primeiro passo é criar uma subclasse da classe abstrata de plug-in: HighLevelSynthesisPlugin, que define a interface e o contrato para plug-ins de síntese de alto nível. O método principal é run(). O argumento high_level_object posicional especifica o “objeto de nível superior” a ser sintetizado, que é qualquer objeto do tipo Operation (incluindo, por exemplo, LinearFunction ou Clifford). O argumento target de palavra-chave especifica o backend de destino, permitindo que o plug-in acesse todas as informações específicas desse destino, como o mapa de acoplamento, o conjunto de portas suportadas e assim por diante. O argumento coupling_map de palavra-chave especifica apenas o mapa de acoplamento e só é usado quando target não for especificado. O argumento qubits de palavra-chave especifica a lista de qubits sobre os quais o objeto de nível superior é definido, caso a síntese seja realizada no circuito físico. O valor de None indica que o layout ainda não foi escolhido e que os qubits físicos no mapa-alvo ou no mapa de acoplamento sobre o qual esta operação está sendo realizada ainda não foram determinados. Além disso, opções e parâmetros de ajuste específicos do plug-in podem ser definidos por meio de options, que é um dicionário de configuração de formato livre. Se o seu plugin tiver essas opções de configuração, você deve documentar claramente como o usuário deve especificá-las e como elas são utilizadas, já que se trata de um campo de preenchimento livre. Espera-se que o método run() retorne um QuantumCircuit objeto que represente o circuito sintetizado a partir desse objeto de nível superior. Também é permitido retornar None indicando que o método de síntese não é capaz de sintetizar o objeto de nível superior especificado. A síntese propriamente dita dos objetos de nível superior é realizada pela HighLevelSynthesis etapa do transpiler. Para obter todos os detalhes, consulte a HighLevelSynthesisPlugin documentação sobre todos os campos obrigatórios. Uma classe de plugin de exemplo seria algo como:

from qiskit.transpiler.passes.synthesis.plugin import HighLevelSynthesisPlugin
from qiskit.synthesis.clifford import synth_clifford_bm


class SpecialSynthesisClifford(HighLevelSynthesisPlugin):

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
    if higher_level_object.num_qubits <= 3:
        return synth_clifford_bm(high_level_object)
    else:
        return None

O exemplo acima cria um plug-in para sintetizar objetos do tipo Clifford que tenham no máximo 3 qubits, utilizando o método synth_clifford_bm.

O segundo passo é definir o HighLevelSynthesisPlugin como ponto de entrada do setuptools nos metadados do pacote. Isso é feito adicionando uma entry-points tabela no pyproject.toml pacote do plug-in com os pontos de entrada necessários no qiskit.synthesis namespace. Por exemplo:

[project.entry-points."qiskit.synthesis"]
"clifford.special" = "qiskit_plugin_pkg.module.plugin:SpecialSynthesisClifford"

O name é composto por duas partes separadas por um ponto “.”: o nome do tipo ao Operation qual o plug-in de síntese se aplica (clifford), e o nome do plug-in (special). Não há limite para o número de plug-ins que um único pacote pode incluir, desde que cada plug-in tenha um nome exclusivo.

Usando plugins

Plug-ins de síntese unitária

Para usar um plug-in, tudo o que você precisa fazer é instalar o pacote que inclui um plug-in de síntese. Em seguida, o Qiskit descobrirá automaticamente os plug-ins instalados e os exporá como opções válidas para os transpile() kwargs e construtores de passagem apropriados. Se houver algum plug-in instalado que não possa ser carregado/importado, isso será registrado em Python logging.

Para obter a lista dos plug-ins de síntese unitária instalados, você pode usar a qiskit.transpiler.passes.synthesis.plugin.unitary_synthesis_plugin_names() função.

Plug-ins de síntese de alto nível

Para usar um plug-in de síntese de alto nível, primeiro é preciso instanciar um HLSConfig para armazenar os nomes dos plug-ins a serem usados para diversos objetos de alto nível. Por exemplo:

HLSConfig(permutation=["acg"], clifford=["layers"], linear_function=["pmh"])

cria uma configuração de síntese de alto nível que utiliza o acg plug-in para sintetizar PermutationGate objetos, o layers plug-in para sintetizar Clifford objetos e o pmh plug-in para sintetizar LinearFunction objetos. Os argumentos de palavra-chave são os Operation.name campos dos objetos em questão. Por exemplo, todas Clifford as operações têm o nameclifford , portanto, isso é usado como argumento-chave. Aqui você pode especificar qualquer argumento-chave que os plug-ins instalados sejam capazes de processar, incluindo objetos de usuário personalizados, caso tenha plug-ins instalados para eles. Consulte HLSConfig para obter mais detalhes sobre os formatos alternativos para configurar os plug-ins dentro de cada argumento.

Para cada objeto de alto nível, a lista de plug-ins fornecidos é tentada em sequência até que um deles seja bem-sucedido (no exemplo acima, cada lista contém apenas um único plug-in). Além de especificar um plug-in por seu nome, você pode passar uma tupla (name, options) , em que o segundo elemento da tupla é um dicionário que contém opções para o plug-in.

Depois de criado, você passa esse HLSConfig objeto como argumento hls_config para transpile() ou generate_preset_pass_manager() , que utilizará os plug-ins especificados como parte do fluxo de trabalho de compilação mais amplo.

Para obter uma lista dos plug-ins de síntese de alto nível instalados para qualquer Operation.name, você pode usar a high_level_synthesis_plugin_names() função, passando o desejado name como argumento:

high_level_synthesis_plugin_names("clifford")

retornará uma lista de todos os plug-ins de síntese Clifford instalados.

Plug-ins disponíveis

Abaixo estão as classes de plug-in de síntese disponíveis no Qiskit. Essas classes não devem ser usadas diretamente, mas, em vez disso, devem ser usadas por meio da interface de plug-in documentada acima. As classes estão listadas aqui para facilitar a localização da documentação de cada um dos plug-ins incluídos e para facilitar a comparação entre diferentes métodos de síntese de um determinado objeto.

Plug-ins de síntese unitária

Plugin de síntese AQC

Plugin de síntese Solovay-Kitaev

Plugin de síntese Ross-Selinger

Plugin Clifford Unitary Synthesis

Plugin de síntese unitária padrão

O plug-in padrão de síntese unitária define o algoritmo padrão utilizado pela UnitarySynthesis etapa do transpiler para sintetizar portas unitárias no circuito. Seu comportamento depende do número de qubits na operação unitária alvo e da base alvo.

Conjuntos de bases contínuas

Quando a base alvo é contínua (ou seja, não é Clifford+T), o plug-in usa as seguintes decomposições:

• Portas de 1 qubit: decomposições em ângulos de Euler (ver OneQubitEulerDecomposer).
• Portas de 2 qubits: decomposições de KAK/Cartan (ver TwoQubitBasisDecomposer, TwoQubitControlledUDecomposer, XXDecomposer).
• Portas de 3+ qubits: Decomposição Quântica de Shannon, consulte qs_decomposition().

Para portas de 1 e 2 qubits, o plug-in usa as informações de erro básico do alvo para selecionar a decomposição que maximiza a fidelidade esperada.

Conjuntos de bases Clifford+T

Quando a base-alvo é Clifford+T, o plug-in utiliza o algoritmo de Solovay-Kitaev (ver SolovayKitaevDecomposition) para aproximar operadores unitários de 1 qubit. Os parâmetros utilizados para criar aproximações básicas são basis_gates=["h", "t", "tdg"], depth=12 e recursion_degree=5, e foram escolhidos empiricamente para equilibrar a qualidade da aproximação com o custo computacional. Para usar o Solovay-Kitaev com parâmetros personalizados ou para evitar recalcular aproximações para vários circuitos, você pode utilizar SolovayKitaevSynthesis o plug-in de síntese unitária em vez deste plug-in padrão.

Atualmente, o Qiskit não inclui algoritmos para aproximar unidades de 2+ qubits diretamente no conjunto de bases Clifford+T. Portanto, o gerenciador de passagem predefinido primeiro decompõe esses portões em ["cx", "u"] base e, em seguida, aplica Solovay-Kitaev aos portões unitários de 1 qubit resultantes.

Síntese de alto nível

Os plug-ins de síntese de alto nível disponíveis diretamente no Qiskit incluem plug-ins para sintetizar Clifford objetos, LinearFunction objetos e PermutationGate objetos. Alguns desses plug-ins visam implicitamente a conectividade “todos com todos”. Essa não é uma limitação prática, já que HighLevelSynthesis normalmente é executada antes do layout e do roteamento, o que garantirá que o circuito final esteja em conformidade com a conectividade do dispositivo por meio da inserção de portas SWAP adicionais. Um bom exemplo é o plug-in ACGSynthesisPermutation de síntese por permutação, que pode sintetizar qualquer permutação com, no máximo, duas camadas de portas SWAP. Por outro lado, alguns plug-ins têm como objetivo implícito a conectividade linear. Normalmente, os circuitos de síntese apresentam maior profundidade e maior número de portas; no entanto, nenhuma porta SWAP adicional seria inserida se a etapa de layout seguinte escolhesse uma linha consecutiva de qubits dentro da topologia do dispositivo. nUm bom exemplo disso é o plug-in KMSSynthesisPermutation de síntese por permutação, que é capaz de sintetizar qualquer permutação de n qubits em profundidade. Normalmente, é difícil saber com antecedência qual das duas abordagens — sintetizar circuitos para conectividade “todos com todos” e inserir portas SWAP, ou sintetizar circuitos para conectividade linear e inserir menos ou nenhuma porta SWAP — resulta em um circuito final melhor; portanto, provavelmente faz sentido testar ambas e verificar qual delas oferece melhores resultados. Por fim, alguns plug-ins podem ser direcionados a um tipo específico de conectividade e, portanto, devem ser executados após a definição do layout. Nesse caso, o circuito sintetizado se adapta automaticamente à topologia do dispositivo. Um bom exemplo disso é o plug-in TokenSwapperSynthesisPermutation de síntese por permutação, que é capaz de sintetizar permutações arbitrárias em relação a mapas de acoplamento arbitrários. Para mais detalhes, consulte a descrição de cada plugin individualmente.

Para cada objeto de alto nível, apresentamos uma tabela que lista todos os seus plug-ins disponíveis diretamente no Qiskit. Incluímos o nome do plug-in, a classe do plug-in, o mapa de conectividade de destino e, opcionalmente, informações adicionais. HLSConfigLembre-se de que os plug-ins devem ser utilizados por meio do método descrito anteriormente, por exemplo:

HLSConfig(permutation=["kms"])

cria uma configuração de síntese de alto nível que utiliza o kms plugin para sintetizar PermutationGate objetos – ou seja, aqueles com name = "permutation". Nesse caso, o nome do plug-in é “kms”, e a classe do plug-in é KMSSynthesisPermutation. Esse algoritmo de síntese específico criou um circuito que segue a conectividade linear do vizinho mais próximo.

Plug-ins de síntese de alto nível

Síntese de Clifford

Síntese de Função Linear

Síntese de Permutações

Síntese QFT

Síntese MCX

A tabela a seguir lista os plug-ins de síntese disponíveis para um MCXGate portão com k qubits de controle. Se o número disponível de qubits auxiliares limpos/sujos não for suficiente, o método de síntese correspondente retornará None.

Síntese MCMT

Comparadores de inteiros

Somas

Síntese da evolução de Pauli

Síntese modular de somadores

Síntese do somador parcial

Síntese do somador completo

Síntese multiplicadora