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. A primeira etapa é criar uma subclasse da classe abstrata do plug-in: UnitarySynthesisPlugin. A classe de plug-in define a interface e o contrato para plug-ins de síntese unitária. O método principal é o run() que recebe um único argumento posicional, uma matriz unitária como uma matriz numpy, e espera-se que retorne um objeto DAGCircuit que representa o circuito sintetizado a partir dessa matriz unitária. Em seguida, para informar o transpilador do Qiskit sobre quais informações são necessárias para a passagem, há vários métodos de propriedade obrigatórios que precisam ser implementados, como supports_basis_gates e supports_coupling_map , dependendo do fato de o plug-in suportar e/ou exigir essa entrada para realizar a síntese. Para obter todos os detalhes, consulte a UnitarySynthesisPlugin documentação de todos os campos obrigatórios. Um exemplo de classe de plug-in seria algo parecido com:

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, as entradas disponíveis para o método run() forem insuficientes, abra um problema e poderemos discutir a expansão da interface do plug-in com novas entradas opt-in que podem ser adicionadas de maneira compatível com versões anteriores para versões futuras. Observe, porém, que essa interface de plug-in é considerada estável e garantida para não ser alterada de forma prejudicial. Se forem necessárias alterações (por exemplo, para expandir as opções de entrada opcionais disponíveis), elas serão feitas de forma a não exigir alterações nos plug-ins existentes.

A segunda etapa é expor o UnitarySynthesisPlugin como um ponto de entrada do setuptools nos metadados do pacote. Isso é feito simplesmente adicionando uma tabela entry-points em pyproject.toml para o pacote de plug-ins com os pontos de entrada necessários no namespace qiskit.unitary_synthesis . 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. A primeira etapa é criar uma subclasse da classe abstrata de plug-in: HighLevelSynthesisPluginque define a interface e o contrato para plug-ins de síntese de alto nível. O método principal é run(). O argumento posicional high_level_object especifica o "objeto de nível superior" a ser sintetizado, que é qualquer objeto do tipo Operation (incluindo, por exemplo, LinearFunction ou Clifford). O argumento de palavra-chave target especifica o backend de destino, permitindo que o plug-in acesse todas as informações específicas do destino, como o mapa de acoplamento, o conjunto de portas suportado e assim por diante. O argumento de palavra-chave coupling_map especifica apenas o mapa de acoplamento e só é usado quando target não é especificado. O argumento da palavra-chave qubits especifica a lista de qubits sobre os quais o objeto de nível superior é definido, caso a síntese seja feita no circuito físico. O valor de None indica que o layout ainda não foi escolhido e que os qubits físicos no alvo ou no mapa de acoplamento em que essa operação está operando ainda não foram determinados. Além disso, as opções e os ajustes específicos do plug-in podem ser especificados em options, que é um dicionário de configuração de forma livre. 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. O método run() deve retornar um objeto QuantumCircuit que representa o circuito sintetizado a partir desse objeto de nível superior. Também é permitido retornar None representando que o método de síntese não consegue sintetizar o objeto de nível superior fornecido. A síntese real de objetos de nível superior é realizada pelo HighLevelSynthesis passagem do transpilador. Para obter todos os detalhes, consulte a HighLevelSynthesisPlugin documentação de todos os campos obrigatórios. Um exemplo de classe de plug-in seria algo parecido com:

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 têm no máximo 3 qubits, usando o método synth_clifford_bm.

A segunda etapa é expor o HighLevelSynthesisPlugin como um ponto de entrada do setuptools nos metadados do pacote. Isso é feito adicionando uma tabela entry-points em pyproject.toml para o pacote de plug-ins com os pontos de entrada necessários no namespace qiskit.synthesis . Por exemplo:

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

O site name consiste em duas partes separadas por um ponto ".": o nome do tipo de Operation ao qual o plug-in de síntese se aplica (clifford) e o nome do plug-in (special). 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.

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 instalada de plug-ins de síntese unitária instalados, você pode usar a função 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 instancie um HLSConfig para armazenar os nomes dos plug-ins a serem usados para vários 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 usa o plug-in acg para sintetizar PermutationGate o plug-in layers para sintetizar objetos Clifford e o plug-in pmh para sintetizar LinearFunction objetos. Os argumentos da palavra-chave são os Operation.name campos dos objetos relevantes. Por exemplo, todas as Clifford operações têm o name clifford portanto, ele é usado como argumento da palavra-chave. Você pode especificar aqui qualquer argumento de palavra-chave que tenha instalado plug-ins para tratar, inclusive objetos de usuário personalizados, se tiver plug-ins instalados para eles. Consulte HLSConfig para obter mais detalhes sobre formatos alternativos para configurar os plug-ins em 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 objeto HLSConfig no argumento hls_config para o transpile() ou generate_preset_pass_manager() que usará os plug-ins especificados como parte do fluxo de trabalho de compilação maior.

Para obter uma lista dos plug-ins de síntese de alto nível instalados para qualquer Operation.namevocê pode usar a função high_level_synthesis_plugin_names() passando o endereço name desejado 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 de síntese unitária padrão define o algoritmo padrão usado pela passagem UnitarySynthesis do transpiler para sintetizar portas unitárias no circuito. Seu comportamento depende do número de qubits na unidade alvo e na 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 do ângulo de Euler (ver OneQubitEulerDecomposer).
• Portas de 2 qubits: decomposições 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 usa o algoritmo Solovay-Kitaev (ver SolovayKitaevDecomposition) para aproximar unitários de 1 qubit. As configurações utilizadas para criar aproximações básicas são basis_gates=["h", "t", "tdg"], depth=12 e recursion_degree=5, e foram escolhidas empiricamente para equilibrar a qualidade da aproximação com o custo computacional. Para usar o Solovay-Kitaev com parâmetros personalizados ou para evitar o recálculo de aproximações para vários circuitos, você pode invocar o plugin de SolovayKitaevSynthesis síntese unitária em vez deste plugin 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 que estão diretamente disponíveis no Qiskit incluem plug-ins para sintetizar Clifford objetos, LinearFunction objetos e PermutationGate objetos. Alguns desses plug-ins visam implicitamente a conectividade de todos para todos. Essa não é uma limitação prática, pois o HighLevelSynthesis normalmente é executado antes do layout e do roteamento, o que garantirá que o circuito final seja compatível com a conectividade do dispositivo, inserindo portas SWAP adicionais. Um bom exemplo é o plug-in de síntese de permutação ACGSynthesisPermutation , que pode sintetizar qualquer permutação com no máximo 2 camadas de portas SWAP. Por outro lado, alguns plug-ins visam implicitamente a conectividade linear. Normalmente, os circuitos de síntese têm maior profundidade e número de portas, mas nenhuma porta SWAP adicional seria inserida se a passagem de layout a seguir escolhesse uma linha consecutiva de qubits dentro da topologia do dispositivo. Um bom exemplo disso é o plug-in de síntese de permutação KMSSynthesisPermutation , que pode sintetizar qualquer permutação de n qubits em profundidade n. Normalmente, é difícil saber de antemão qual das duas abordagens: sintetizar circuitos para conectividade total e inserir portas SWAP versus sintetizar circuitos para conectividade linear e inserir menos ou nenhuma porta SWAP resultará em um circuito final melhor, portanto, provavelmente faz sentido tentar as duas abordagens e ver qual delas oferece melhores resultados. Por fim, alguns plug-ins podem ter como alvo uma determinada conectividade e, portanto, devem ser executados depois que o layout for definido. Nesse caso, o circuito sintetizado adere automaticamente à topologia do dispositivo. Um bom exemplo disso é o plug-in de síntese de permutação TokenSwapperSynthesisPermutation , que é capaz de sintetizar permutações arbitrárias com relação a mapas de acoplamento arbitrários. Para obter mais detalhes, consulte a descrição de cada plug-in individual.

Para cada objeto de alto nível, fornecemos 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 direcionado e, opcionalmente, informações adicionais. Lembre-se de que os plug-ins devem ser usados por meio do procedimento descrito anteriormente HLSConfigdescrito anteriormente, por exemplo:

HLSConfig(permutation=["kms"])

cria uma configuração de síntese de alto nível que usa o plug-in kms para sintetizar PermutationGate 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 adere à 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 porta 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