BTC_01_PL.PL¶

PL.data_loading¶

This module contains all the functions in order to load data into the quantum state. There are two implementations for the loading of a function:

one based on brute force

one based on multiplexors.

The implementation of the multiplexors is a non-recursive version of:

V.V. Shende, S.S. Bullock, and I.L. Markov. Synthesis of quantum-logic circuits. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 25(6):1000–1010, Jun 2006 arXiv:quant-ph/0406176v5

Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro

tnbs.BTC_01_PL.PL.data_loading.get_qlm_probability(data, load_method, shots, qpu)¶: executing quantum stuff

tnbs.BTC_01_PL.PL.data_loading.get_qpu(qpu=None)¶

Function for selecting solver.

Parameters

qpu (str) –

qlmass: for trying to use QLM as a Service connection to CESGA QLM
python: for using PyLinalg simulator.
c: for using CLinalg simulator

Returns

linal_qpu

Return type

solver for quantum jobs

tnbs.BTC_01_PL.PL.data_loading.get_theoric_probability(n_qbits: int) -> (numpy.ndarray, numpy.ndarray, <class 'float'>, <class 'float'>, <class 'float'>, <class 'int'>)¶: Get the discretization of the PDF for N qubits

tnbs.BTC_01_PL.PL.data_loading.load_angle(number_qubits: int, index: int, angle: float)¶

Creates an QLM Abstract Gate that apply a rotation of a given angle into a auxiliary qubit controlled by a given state of the measurement basis. Direct QLM multi controlled rotations were used for the implementation.

Notes

\[|\Psi\rangle = \sum_{j=0}^{2^n-1}\alpha_j|j\rangle\otimes|0\rangle\]

\[\mathcal{load\_angle}(\theta, |i\rangle)|\Psi\rangle \ =\sum_{j=0, j\ne i}^{2^n-1}\alpha_j|j\rangle\otimes|0\rangle+ \ \alpha_i|i\rangle\otimes\big(\cos(\theta)|0\rangle+\sin(\theta) \ |1\rangle\big)\]

Parameters

number_qubits (int) – Number of qubits for the control register. The arity of the gate is number_qubits+1.
index (int) – Index of the state that we control.
angle (float) – Angle that we load.

tnbs.BTC_01_PL.PL.data_loading.load_angles(angles: numpy.array, method: str = 'multiplexor')¶

This function serves as an interface for the two different implementations of multi controlled rotations: load_angles_brute_force and multiplexor_RY.

Notes

\[|\Psi\rangle = \sum_{j=0}^{2^n-1}\alpha_j|j\rangle\otimes|0\rangle\]

\[\mathcal{load\_angles}([\theta_j]_{j=0,1,2...2^n-1})|\Psi\rangle \ =\sum_{j=0}^{2^n-1}\alpha_j|j\rangle\otimes \ \big(\cos(\theta_j)|0\rangle+\sin(\theta_j)|1\rangle\big)\]

Parameters

angles (numpy array) – Angles to load in the circuit. The arity of the gate is: int(np.log2(len(angle)))+1.
method (string) – Method used in the loading. Default method.

tnbs.BTC_01_PL.PL.data_loading.load_angles_brute_force(angles: numpy.array)¶

Given a list of angles this function creates a QLM routine that applies rotations of each angle of the list, over an auxiliary qubit, controlled by the different states of the measurement basis. Direct QLM multi controlled rotations were used for the implementation.

Notes

\[|\Psi\rangle = \sum_{j=0}^{2^n-1}\alpha_j|j\rangle\otimes|0\rangle\]

\[\mathcal{load\_angles\_brute\_force} \ ([\theta_j]_{j=0,1,2...2^n-1}) |\Psi\rangle=\sum_{j=0}^{2^n-1} \ \alpha_j|j\rangle\otimes\big(\cos(\theta_j)|0\rangle+ \ \sin(\theta_j)|1\rangle\big)\]

Parameters: angles (numpy array) – Angles to load in the circuit. The arity of the gate is: int(np.log2(len(angle)))+1.

tnbs.BTC_01_PL.PL.data_loading.load_probability(probability_array: numpy.array, method: str = 'multiplexor', id_name: str = '1696594286916704504')¶

Creates a QLM Abstract gate for loading a given discretized probability distribution using Quantum Multiplexors.

Parameters

probability_array (numpy array) – Numpy array with the discretized probability to load. The arity of of the gate is int(np.log2(len(probability_array))).
method (str) –

type of loading method used:
multiplexor : with quantum Multiplexors brute_force : using multicontrolled rotations by state
id_name (str) – name for the Abstract Gate

Returns

P_Gate – Customized Abstract Gate for Loading Probability array using Quantum Multiplexors

Return type

AbstractGate

tnbs.BTC_01_PL.PL.data_loading.mask(number_qubits, index)¶

Transforms the state \(|index\rangle\) into the state \(|11...1\rangle\) of size number qubits.

Parameters

number_qubits (int) –
index (int) –

Returns

mask – the gate that we have to apply in order to transform state \(|index\rangle\). Note that it affects all states.

Return type

Qlm abstract gate

tnbs.BTC_01_PL.PL.data_loading.multiplexor_ry(angles: numpy.array, ordering: str = 'sequency')¶

Given a list of angles this functions creates a QLM routine that applies rotations of each angle of the list, over an auxiliary qubit, controlled by the different states of the measurement basis. The multi-controlled rotations were implemented using Quantum Multiplexors.

Notes

\[|\Psi\rangle = \sum_{j=0}^{2^n-1}\alpha_j|j\rangle\otimes|0\rangle\]

\[\mathcal{multiplexor\_RY} \ ([\theta_j]_{j=0,1,2...2^n-1})|\Psi\rangle = \sum_{j=0}^{2^n-1} \ \alpha_j|j\rangle\otimes\big(\cos(\theta_j)|0\rangle+\sin(\theta_j)|1\rangle\big)\]

Parameters

angles (numpy array) –

Angles to load in the circuit. The arity of the gate is:: int(np.log2(len(angle)))+1.

PL.load_probabilities¶

Mandatory code for softaware implemetation of the Benchmark Test Case of PL kernel

class tnbs.BTC_01_PL.PL.load_probabilities.LoadProbabilityDensity(**kwargs)¶

Bases: object

Probability Loading

exe()¶: Execution of workflow

get_metrics()¶: Computing Metrics

get_quantum_pdf()¶: Computing quantum probability density function

get_theoric_pdf()¶: Computing theoretical probability densitiy function

summary()¶: Pandas summary

PL.data_extracting¶

This module contains auxiliary functions for executing QLM programs based on QLM Routines or QLM gates and for post processing results from QLM qpu executions

Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro Costas

tnbs.BTC_01_PL.PL.data_extracting.check_list_type(x_input, tipo)¶

Check if a list x_input is of type tipo :param x_input: :type x_input: list :param tipo: it has to be understandable by numpy :type tipo: data type

Returns: y_output – numpy array of type tipo.
Return type: np.array

tnbs.BTC_01_PL.PL.data_extracting.create_qcircuit(prog_q)¶

Given a QLM program creates a QLM circuit

Parameters: prog_q (QLM QProgram) –
Returns: circuit
Return type: QLM circuit

tnbs.BTC_01_PL.PL.data_extracting.create_qjob(circuit, shots=0, qubits=None)¶

Given a QLM circuit creates a QLM job

Parameters

circuit (QLM circuit) –
shots (int) – number of measurmentes
qubits (list) – with the qubits to be measured

Returns

job – job for submit to QLM QPU

Return type

QLM job

tnbs.BTC_01_PL.PL.data_extracting.create_qprogram(quantum_gate)¶

Creates a Quantum Program from an input qlm gate or routine

Parameters: quantum_gate (QLM gate or QLM routine) –
Returns: q_prog – Quantum Program from input QLM gate or routine
Return type: QLM Program.

tnbs.BTC_01_PL.PL.data_extracting.get_results(quantum_object, linalg_qpu, shots: int = 0, qubits: list = None, complete: bool = False)¶

Function for testing an input gate. This function creates the quantum program for an input gate, the correspondent circuit and job. Execute the job and gets the results

Parameters

quantum_object (QLM Gate, Routine or Program) –
linalg_qpu (QLM solver) –
shots (int) – number of shots for the generated job. if 0 True probabilities will be computed
qubits (list) – list with the qubits for doing the measurement when simulating if None measurement over all allocated qubits will be provided
complete (bool) – for return the complete basis state. Useful when shots is not 0 and all the posible basis states are necessary.

Returns

pdf (pandas DataFrame) – DataFrame with the results of the simulation
circuit (QLM circuit)
q_prog (QLM Program.)
job (QLM job)

tnbs.BTC_01_PL.PL.data_extracting.proccess_qresults(result, qubits, complete=False)¶

Post Process a QLM results for creating a pandas DataFrame

Parameters

result (QLM results from a QLM qpu.) – returned object from a qpu submit
qubits (int) – number of qubits
complete (bool) – for return the complete basis state.

PL.utils¶

This module contains several auxiliary functions needed by other scripts of the library

Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro Costas

Fast Walsh-Hadamard Transform is based on mex function written by Chengbo Li@Rice Uni for his TVAL3 algorithm:

https://github.com/dingluo/fwht/blob/master/FWHT.py

tnbs.BTC_01_PL.PL.utils.bitfield(n_int: int, size: int)¶

Transforms an int n_int to the corresponding bitfield of size size

Parameters

n_int (int) – integer from which we want to obtain the bitfield
size (int) – size of the bitfield

Returns

full – bitfield representation of n_int with size size

Return type

list of ints

tnbs.BTC_01_PL.PL.utils.expmod(n_input: int, base: int)¶

For a pair of integer numbers, performs the decomposition:

\[n_input = base^power+remainder\]

Parameters

n_input (int) – number to decompose
base (int) – basis

Returns

power (int) – power
remainder (int) – remainder

tnbs.BTC_01_PL.PL.utils.fwht(x_input: numpy.array, ordering: str = 'sequency')¶

Fast Walsh Hadamard transform of array x_input Works as a wrapper for the different orderings of the Walsh-Hadamard transforms.

Parameters

x_input (numpy array) –
ordering (string) – desired ordering of the transform

Returns

y_output – Fast Walsh Hadamard transform of array x_input in the corresponding ordering

Return type

numpy array

tnbs.BTC_01_PL.PL.utils.fwht_dyadic(x_input: numpy.array)¶

Fast Walsh-Hadamard Transform of array x_input in dyadic ordering The result is not normalised Based on mex function written by Chengbo Li@Rice Uni for his TVAL3 algorithm. His code is according to the K.G. Beauchamp’s book – Applications of Walsh and Related Functions. :param array: :type array: numpy array

Returns: x_output – Fast Walsh Hadamard transform of array x_input.
Return type: numpy array

tnbs.BTC_01_PL.PL.utils.fwht_natural(array: numpy.array)¶

Fast Walsh-Hadamard Transform of array x in natural ordering The result is not normalised :param array: :type array: numpy array

Returns: fast_wh_transform – Fast Walsh Hadamard transform of array x.
Return type: numpy array

tnbs.BTC_01_PL.PL.utils.fwht_sequency(x_input: numpy.array)¶

Fast Walsh-Hadamard Transform of array x_input in sequence ordering The result is not normalised Based on mex function written by Chengbo Li@Rice Uni for his TVAL3 algorithm. His code is according to the K.G. Beauchamp’s book – Applications of Walsh and Related Functions. :param x_input: :type x_input: numpy array

Returns: x_output – Fast Walsh Hadamard transform of array x_input.
Return type: numpy array

tnbs.BTC_01_PL.PL.utils.left_conditional_probability(initial_bins, probability)¶

This function calculate f(i) according to the Lov Grover and Terry Rudolph 2008 papper: ‘Creating superposition that correspond to efficiently integrable probability distributions’ http://arXiv.org/abs/quant-ph/0208112v1

Given a discretized probability and an initial number of bins the function splits each initial region in 2 equally regions and calculates the conditional probabilities for x is located in the left part of the new regions when x is located in the region that contains the corresponding left region

Parameters

initial_bins (int) – Number of initial bins for splitting the input probabilities
probability (np.darray.) – Numpy array with the probabilities to be load. initial_bins <= len(Probability)

Returns

left_cond_prob – conditional probabilities of the new initial_bins+1 splits

Return type

np.darray