blind_transpiler.essentials package

The essentials package defines the core intermediate abstractions used throughout BlindTranspiler.

These abstractions provide a protocol-independent representation of blind delegated quantum computation and act as the interface between the controller and translator layers.

Overview

BlindTranspiler performs blind transpilation by taking a Qiskit quantum circuit as input and generating an object of the BQCInstruction class as output.

The BQCInstruction object internally stores a list of modified gate objects called Blind Operations (BOP).

Each BOP object contains:

  • delegated gate definition

  • classical control information

  • communication dependencies

  • delegation metadata

  • client/server execution information

These abstractions allow the library to:

  • estimate communication rounds

  • analyze delegation overhead

  • estimate client/server resource requirements

  • simulate delegated execution

  • convert blind instructions back into executable circuits

The BQCInstruction object can also be converted into a Qiskit-compatible circuit representation using the to_circuit() method.

Blindness Models Implemented

The library currently supports multiple approaches for blind quantum computation.

Quantum Homomorphic Encryption

The library implements blind transpilation based on Quantum Homomorphic Encryption (QHE) approaches.

Translation rules are implemented for the following gates:

  • H

  • S

  • S†

  • T

  • T†

  • CX

  • CZ

  • CCX

The implementation follows approaches described in:

  • Childs (2005)

  • Broadbent and Jeffery (2015)

  • Fisher et al. (2014)

  • Tan et al. (2017)

Additionally, the library supports delegation of arbitrary Rz rotations using recursive decryption techniques.

This enables efficient handling of:

  • parametric quantum circuits

  • variational quantum algorithms

  • low-depth delegated computations

Universal Blind Quantum Computation

The library also implements Universal Blind Quantum Computation (UBQC) style approaches.

These approaches operate using universal delegated resource sets.

Implemented universal approaches include:

  • recursive parametric gate delegation

  • ordered universal gate sets

  • fixed π/4 rotation universal sets

The recursive parametric implementation is especially efficient for circuits containing arbitrary rotation gates.

Implemented models include:

  • recursive decryption delegation

  • ordered universal gate delegation

  • fixed-angle universal gate delegation

Client Assumptions

All current implementations assume that the client can directly perform gates from the set:

\[\{X, Z, Swap, Measure\}\]

All other gates are delegated to the remote server.

Core Abstractions

BQCInstruction

The BQCInstruction class represents the complete blind delegated computation.

Responsibilities include:

  • storing blind operations

  • tracking delegation dependencies

  • communication scheduling

  • conversion to executable circuits

  • protocol resource estimation

blind_transpiler.essentials.bqc_instruction

class blind_transpiler.essentials.bqc_instruction.BQCInstruction[source]

Bases: object

add_elements(elem)[source]

It is used to add new BOP element to the variable instruction_list. This fuction can handle elem as object BOP or the list of BOP class.

Parameters:

elem (BOP/ List[BOP]) – elem to be added to list, can be object of class BOP or list of object of class BOP.

get_meta_data()[source]
print_meta_data()[source]
to_circuit(const_type='complete', show_barrier=False)[source]

Create the quantum circuit using list of BOP class objects based on the conditional provided to them.

Parameters:

  • bqc_instruction (list[BOP]) – the list of BOP object that contain the gate object needed to be applied at each step to form the bqc circuit with given key, based on conditional value.

  • const_type (str) –

    circuit can be constructed of four different types:

    ’complete’: all the client and server gates are present, circuit is complete functional blind circuit. ‘client_only’: contains only gates corresponding to the client. It is not functional blind circuit, and should only be used for resource estimation of client side and other similar tasks. ‘server_only’: contains only gates corresponding to the server. It is not functional blind circuit, and should only be used for resource estimation of server side and other similar tasks. ‘encrypt_only’: contain no decryption gate for the operations performed. Not a functional blind circuit, can be used to verify the blindness of data at server end. At the end of presentation.

  • show_barrier (boolean) – flag that controlls if the circuit will contain barrier or not.

Returns:

qc (QuantumCircuit)

a quantum circuit that performs same operation as original circuit, with exception of global phase shift, but is completly blind.

Raises:

ValueError(f'const_type {const_type} not available. Kindly choose from "complete", "client_only", "server_only", "encrypt_only".') –

Library Dependency:
qiskit:

QuantumCircuit

BOP

The BOP (Blind Operation) class represents an individual delegated quantum operation.

Each operation contains:

  • delegated gate definition

  • classical dependency information

  • encryption metadata

  • delegation semantics

blind_transpiler.essentials.bop

class blind_transpiler.essentials.bop.BOP(op_type: str, qargs: Tuple, cargs: Tuple, gate: Instruction, conditional: Literal[0, 1] = 1, gate_seq: int = None)[source]

Bases: object

conditional_and(x)[source]

Modifies the conditional of the self class object with Binary ANDing it with incoming x.

Parameters:

x ({0,1}) – binary conditional, can be 0 or 1.

Returns:

BOP

x & conditional of the current object of class, use to apply gate like condtional cx,cz gate in ccx decryption and other similar situations.

Raises:

None –

Library Dependency:

None

Package Contents