PhaseEstimation package

Submodules

PhaseEstimation.annni_model module

This module implements the base functions for treating the Hamiltonian of the ANNNI Ising-model

PhaseEstimation.annni_model.build_Hs(N: int, n_hs: int, n_kappas: int, h_max: float = 2, kappa_max: float = 1, ring: bool = False) → Tuple[List[Hamiltonian], List[List[int]], List[int], List[Tuple[int, float, float]], int]

Sets up np.ndarray of pennylane Hamiltonians with different parameters total_states = n_kappas * n_hs kappa can have n_kappas values from 0 to - abs(kappa_max) (NB the sign) h can have n_hs values from 0 to h_max

Parameters:

• N (int) – Number of spins of the Ising Chain

• n_hs (int) – Number of different values of h the hamiltonian can have

• h_max (float) – Maximum value of h, the values will range from 0 to h_max

• n_kappas (int) – Number of different values of kappa the hamiltonian can have

• kappa_max (float) – Maximum value of kappa

• ring (bool) – If False, system has open-boundaries condition

Returns:

• np.array – Array of pennylane Hamiltonians

• np.array – Array of labels for analytical solutions

• np.array – Array for the recycle rule

• np.array – Array for the states parameters

PhaseEstimation.annni_model.get_H(N: int, L: float, K: float, ring: bool = False) → Hamiltonian

Set up Hamiltonian:

H = J1* (- Σsigma^i_x*sigma_x^{i+1} - (h/J1) * Σsigma^i_z - (J2/J1) * Σsigma^i_x*sigma_x^{i+2} )

[where J1 = 1, (h/J1) = Lambda(/L), (J2/J1) = K]

Parameters:

• N (int) – Number of spins of the Ising Chain

• L (float) – h/J1 parameter

• K (float) – J1/J2 parameter

• ring (bool) – If False, system has open-boundaries condition

Returns:

Hamiltonian Pennylane class for the (Transverse) Ising Chain

Return type:

pennylane.ops.qubit.hamiltonian.Hamiltonian

PhaseEstimation.circuits module

This module implements base circuit layouts for all the models used

PhaseEstimation.circuits.circuit_ID9(active_wires: List[int], params: List[Number], index: int = 0) → int

Basic block for VQE

Parameters:

• active_wires (np.ndarray) – Array of the wires to apply the rotations to

• params (list) – List of parameters of the whole circuit

• index (int) – Starting index for this block of operators

Returns:

Updated index value

Return type:

int

PhaseEstimation.circuits.convolution(active_wires: List[int], params: List[Number], index: int = 0) → int

Convolution block for the QCNN

Parameters:

• active_wires (np.ndarray) – Array of wires that are not measured during a previous pooling

• params (np.ndarray) – Array of parameters/rotation for the circuit

• index (int) – Index from where to pick the elements from the params array

Returns:

Updated starting index of params array for further rotations

Return type:

int

PhaseEstimation.circuits.encoder_block(wires: List[int], wires_trash: List[int], shift: int = 0)

Applies CX between a wire and a trash wire for each wire/trashwire

Parameters:

• wires (np.ndarray) – Array of the indexes of non-trash qubits

• wires_trash (np.ndarray) – Array of the indexes of trash qubits (np.1dsetdiff(np.arange(N),wires))

• shift (int) – Shift value for connections between wires and trash wires

PhaseEstimation.circuits.encoder_circuit(wires: List[int], wires_trash: List[int], active_wires: List[int], params: List[Number], index: int = 0) → int

Encoder circuit for encoder and autoencoder

Parameters:

• wires (np.ndarray) – Array of the indexes of non-trash qubits

• wires_trash (np.ndarray) – Array of the indexes of trash qubits (np.1dsetdiff(np.arange(N),wires))

• active_wires (np.ndarray) – wires U wires_trash

• params (np.ndarray) – Array of parameters/rotation for the circuit

• index (int) – Index from where to pick the elements from the params array

Returns:

Updated index value

Return type:

int

PhaseEstimation.circuits.pooling(active_wires: List[int], qmlrot_func: Operator, params: List[Number], index: int = 0) → Tuple[int, List[int]]

Pooling block for the QCNN

Parameters:

• active_wires (np.ndarray) – Array of wires that are not measured during a previous pooling

• qmlrot_func (function) – Pennylane Gate function to apply

• params (np.ndarray) – Array of parameters/rotation for the circuit

• index (int) – Index from where to pick the elements from the params array

Returns:

• int – Updated starting index of params array for further rotations

• np.ndarray – Updated array of active wires (not measured)

PhaseEstimation.circuits.wall_cgate_all(active_wires: List[int], cgate: Operator, params: List[Number] = [], index: int = 0, going_down: bool = True) → int

Apply controlled rotations across all the wires (active_wires)

Parameters:

• active_wires (np.ndarray) – Array of the wires to apply the rotations to

• cgate (Pennylane gate (parametrized or not)) – Qubit controlled operator to apply

• params (list) – List of parameters of the whole circuit

• index (int) – Starting index for this block of operators

• going_down (bool) – if True -> top - down, if False -> down - top

Returns:

Updated index value

Return type:

int

PhaseEstimation.circuits.wall_cgate_nextneighbour(active_wires: List[int], cgate: Operator, params: List[Number] = [], index: int = 0, going_down: bool = True) → int

Apply drop-down controlled rotations establishing next-neighbour entanglement

Parameters:

• active_wires (np.ndarray) – Array of the wires to apply the rotations to

• cgate (Pennylane gate (parametrized or not)) – Qubit controlled operator to apply

• params (list) – List of parameters of the whole circuit

• index (int) – Starting index for this block of operators

• going_down (bool) – if True -> top - down, if False -> down - top

Returns:

Updated index value

Return type:

int

PhaseEstimation.circuits.wall_cgate_serial(active_wires: List[int], cgate: Operator, params: List[Number] = [], index: int = 0, going_down: bool = True) → int

Apply drop-down controlled rotations for all the wires (active_wires)

Parameters:

• active_wires (np.ndarray) – Array of the wires to apply the rotations to

• cgate (Pennylane gate (parametrized or not)) – Qubit controlled operator to apply

• params (list) – List of parameters of the whole circuit

• index (int) – Starting index for this block of operators

• going_down (bool) – if True -> top - down, if False -> down - top

Returns:

Updated index value

Return type:

int

PhaseEstimation.circuits.wall_gate(active_wires: List[int], gate: Operator, params: List[Number] = [], index: int = 0, samerot: bool = False) → int

Apply rotations for all the wires (active_wires)

Parameters:

• active_wires (np.ndarray) – Array of the wires to apply the rotations to

• gate (qml.ops.qubit.parametric_ops) – Qubit operator to apply

• params (list) – List of parameters of the whole circuit

• index (int) – Starting index for this block of operators

• samerot (bool) – if True -> The rotations are not independet of each other but the same

Returns:

Updated index value

Return type:

int

PhaseEstimation.encoder module

This module implements the base functions to implement an anomaly detector model

PhaseEstimation.encoder.enc_classification_ANNNI(vqeclass: vqe, lr: Number, epochs: int) → List[Number]

Train 3 encoder on the corners: > K = 0, L = 2 (Paramagnetic) > K = 0, L = 0 (Ferromagnetic) > K = -1, L = 0 (Antiphase) The other states will be classified taking the lowest error among each encoder

Parameters:

• vqeclass (class) – VQE class

• lr (float) – Learning rate for each training

• epochs (int) – Number of epochs for each training

Returns:

Array of labels

Return type:

np.ndarray

class PhaseEstimation.encoder.encoder(vqe: vqe, encoder_circuit: Callable)

Bases: object

show_compression(trainingpoint, label=False, plot3d=False)

Plots performance of the compression on the whole data for an encoder on the ANNI model

Parameters:

• trainingpoint (int) – Mark the single training point on the plot

• label (str) – Label to assign to the picture, needed for the paper

• plot3d (bool) – If True the 3D plot will be displayed aswell

train(lr: Number, n_epochs: int, train_index: List[int], circuit: bool = False)

Training function for the Anomaly Detector.

Parameters:

• lr (float) – Learning rate to be multiplied in the circuit-gradient output

• n_epochs (int) – Total number of epochs for each learning

• train_index (np.ndarray) – Index of training points

• circuit (bool) – if True -> Prints the circuit

PhaseEstimation.encoder.encoder_circuit(N: int, params: List[Number]) → int

Building function for the circuit Encoder(params)

Parameters:

• N (int) – Number of qubits

• params (np.ndarray) – Array of parameters/rotation for the circuit

Returns:

Number of parameters of the circuit

Return type:

int

PhaseEstimation.general module

Module for generic functions for other modules

PhaseEstimation.general.b1(x)

PhaseEstimation.general.get_H_eigval_eigvec(qml_H: Hamiltonian, en_lvl: int) → Tuple[List[List[Number]], Number, List[Number]]

Function for getting the energy value and state of an Ising Hamiltonian using the jitted jnp.linalg.eigh function

Parameters:

• qml_H (pennylane.ops.qubit.hamiltonian.Hamiltonian) – Pennylane Hamiltonian of the state

• en_lvl (int) – Energy level desired

Returns:

• np.ndarray – Matricial encoding of the Hamiltonian

• float – Value of the energy level

• np.ndarray – Eigenstate of the energy level

PhaseEstimation.general.get_VQD_params(qml_H: Hamiltonian, beta: Number) → Tuple[List[List[Number]], List[List[Number]], Number]

Function for getting all the training parameter for the VQD algorithm for finding the first excited state

Parameters:

qml_H (pennylane.ops.qubit.hamiltonian.Hamiltonian) – Pennylane Hamiltonian of the Ising Model

Returns:

• np.ndarray – Matricial encoding of the Hamiltonian

• np.ndarray – Effective Hamiltonian of VQD algorithm

• float – Excited-state energy value

PhaseEstimation.general.get_VQE_params(qml_H: Hamiltonian) → Tuple[List[List[Number]], Number]

Function for getting all the training parameter for the VQE algorithm

Parameters:

qml_H (pennylane.ops.qubit.hamiltonian.Hamiltonian) – Pennylane Hamiltonian of the state

Returns:

• np.ndarray – Matricial encoding of the Hamiltonian

• float – Ground-state energy value

PhaseEstimation.general.geteigvals(qml_H: Hamiltonian, states: List[int]) → List[Number]

Function for getting the energy values of an Ising Hamiltonian using the jitted jnp.linalg.eigh function

Parameters:

• qml_H (pennylane.ops.qubit.hamiltonian.Hamiltonian) – Pennylane Hamiltonian of the state

• states (list) – List of energy levels desired

Returns:

List of energy values

Return type:

list

PhaseEstimation.general.j_linalgeigh(mat_H: List[List[Number]]) → Tuple[int, List[Number]]

Apply jax np.linalg.eigh on a matrix, to be jitted

Parameters:

mat_H (np.ndarray) – Input matrix to apply np.linalg.eigh

Returns:

• np.ndarray – Array of eigenvalues (not sorted)

• np.ndarray – Array of relative eigenvectors

PhaseEstimation.general.j_psi_outer(psi: List[Number]) → List[List[Number]]

PhaseEstimation.general.jv_psi_outer(psi: List[Number]) → List[List[Number]]

Vectorized version of psi_outer. Takes similar arguments as psi_outer but with additional array axes over which psi_outer is mapped.

PhaseEstimation.general.linalgeigh(mat_H: List[List[Number]]) → Tuple[int, List[Number]]

Apply jax np.linalg.eigh on a matrix, to be jitted

Parameters:

mat_H (np.ndarray) – Input matrix to apply np.linalg.eigh

Returns:

• np.ndarray – Array of eigenvalues (not sorted)

• np.ndarray – Array of relative eigenvectors

PhaseEstimation.general.paraanti(x)

PhaseEstimation.general.paraferro(x)

PhaseEstimation.general.peshel_emery(x)

PhaseEstimation.general.psi_outer(psi: List[Number]) → List[List[Number]]

PhaseEstimation.general.simple_to_idx(simple: int, side: int) → int | None

PhaseEstimation.hamiltonians module

This module implements the base class for spin-models Hamiltonians

PhaseEstimation.hamiltonians.get_e_psi(Hclass, en_lvl)

Return respectively the list of the true energies and true states obtained through the diagonalization of the hamiltonian matrices

Parameters:

• Hclass (hamiltonians.hamiltonians) – Custom hamiltonian class

• en_lvl (int) – Energy level to inspect

Returns:

• List[Number] – Array of the energies

• List[List[Number]] – Array of the state vectors

class PhaseEstimation.hamiltonians.hamiltonian(building_func: Callable, **kwargs)

Bases: object

J: float

N: int

add_true()

Add true ground-state energy levels and true wavefunctions by diagonalizing the Hamiltonian matrices

show_massgap(**kwargs)

Shows the mass gap which is defined as the difference between the first excited leven and the ground energy level for each point in the parameter space.

Parameters:

• Hs (hamiltonians.hamiltonian) – Custom hamiltonian class, it is needed to call plot_layout

• phase_lines (bool) – if True plots the phase transition lines

• pe_line (bool) – if True plots Peshel Emery line

show_phasesplot()

Shows the division of phases of the parameter space according to the state-of-the-art lines

PhaseEstimation.ising_chain module

This module implements the base function for treating Ising Chain with Transverse Field.

PhaseEstimation.ising_chain.build_Hs(N: int, J: float, n_states: int, ring: bool = False) → Tuple[List[Hamiltonian], List[int], List[int], List[Tuple[int, Number, Number]], int]

Sets up np.ndarray of pennylane Hamiltonians with different instensity of magnetic field mu in np.linspace(0, 2*J, n_states)

Parameters:

• N (int) – Number of spins of the Ising Chain

• J (float) – Interaction strenght between spins

• n_states (int) – Number of Hamiltonians to generate

• ring (bool) – If False, system has open-boundaries condition

Returns:

• np.array – Array of pennylane Hamiltonians

• np.array – Array of labels for analytical solutions

• np.array – Array for the recycle rule

• np.array – Array for the states parameters

• int – Number of states

PhaseEstimation.ising_chain.get_H(N: int, lam: float, J: float, ring: bool = False) → Hamiltonian

Set up Hamiltonian:

H = -lam*Σsigma^i_z - J*Σsigma^i_x*sigma_x^{i+1}

Parameters:

• N (int) – Number of spins of the Ising Chain

• lam (float) – Strenght of (transverse) magnetic field

• J (float) – Interaction strenght between spins

• ring (bool) – If False, system has open-boundaries condition

Returns:

Hamiltonian Pennylane class for the (Transverse) Ising Chain

Return type:

pennylane.ops.qubit.hamiltonian.Hamiltonian

PhaseEstimation.losses module

This module implements loss functions and regularizers for VQE, QCNN and Encoder

PhaseEstimation.losses.cross_entropy(X, Y, params, q_circuit)

LOSS: Compute Cross Entropy for a binary classification task

Parameters:

• X (np.ndarray) – Array of VQE parameters (input of VQE)

• Y (np.ndarray) – Array of labels

• params (np.ndarray) – Array of parameters of the QCNN circuit

• q_circuit (function) – Quantum function of the VQE circuit

Returns:

Cross entropy <Circuit(X)|Y>

Return type:

float

PhaseEstimation.losses.cross_entropy1D(X, Y, params, q_circuit)

LOSS: Compute Cross Entropy for a binary classification task

Parameters:

• X (np.ndarray) – Array of VQE parameters (input of VQE)

• Y (np.ndarray) – Array of labels

• params (np.ndarray) – Array of parameters of the QCNN circuit

• q_circuit (fun) – Quantum function of the VQE circuit

Returns:

Cross entropy <Circuit(X)|Y>

Return type:

float

PhaseEstimation.losses.cross_entropy_power4(X, Y, params, q_circuit)

LOSS: Compute Cross Entropy for a binary classification task Apply ^4 to punish the model on uncertain classifications

Parameters:

• X (np.ndarray) – Array of VQE parameters (input of VQE)

• Y (np.ndarray) – Array of labels

• params (np.ndarray) – Array of parameters of the QCNN circuit

• q_circuit (function) – Quantum function of the VQE circuit

Returns:

Cross entropy <Circuit(X)|Y>

Return type:

float

PhaseEstimation.losses.hinge(X, Y, params, q_circuit)

LOSS: (Experimental) Compute Hinge loss for a binary classification task N.B: MAX is not applied because output is a probability [0,1] that will be mapped to [-1,1], hence the 1 - Prediction(X)*Y can be at minimum 0

Parameters:

• X (np.ndarray) – Array of VQE parameters (input of VQE)

• Y (np.ndarray) – Array of labels

• params (np.ndarray) – Array of parameters of the QCNN circuit

• q_circuit (fun) – Quantum function of the VQE circuit

Returns:

Mean Hinge Loss <Circuit(X)|Y>

Return type:

float

PhaseEstimation.losses.vqe_fidelities(Y: List[Number], params: List[Number], q_circuit: Callable) → float

LOSS: Compute Fidelity between VQE PSI (output of q_circuit(params)) and TRUE PSI computed by diagonalizing the Hamiltonian

Parameters:

• Y (np.ndarray) – Array of true wavefunction obtained by diagonalizing the Hamiltonians

• params (np.ndarray) – Array of parameters of the VQE circuits

• q_circuit (fun) – Quantum function of the VQE circuit

Returns:

Mean fidelities between VQE PSI and TRUE PSI

Return type:

float

PhaseEstimation.qcnn module

This module implements the base functions to implement a Quantum Convolutional Neural Network (QCNN) for the (ANNNI) Ising Model.

PhaseEstimation.qcnn.ANNNI_accuracy(qcnnclass: qcnn, plot: bool = False) → float

Compute accuracy of the QCNN of the whole ANNNI state space

Parameters:

• qcnnclass (qcnn) – QCNN class

• plot (bool) –

  if True -> displays the plot of the accuracy:

  if green: sample correctly classified if red : sample wrongly classified

Returns:

Accuracy : (# samples correctly classified)/(# samples) (0,1)

Return type:

float

PhaseEstimation.qcnn.get_trainset_gaussian(vqeclass: vqe, nS: int, sigma: float = 1) → List[int]

Draw randomly samples from the training for each axis according to the gaussian distribution centered around the phase transition on the axis and std sigma

Parameters:

• vqeclass (vqe.vqe) – VQE class to get the side size of the system

• nS (int) – Number of samples to draw in total

• sigma (float) – Standard deviation of the two distributions

Returns:

List of the indexes of the subset of the training set

Return type:

np.ndarray

PhaseEstimation.qcnn.load(filename_vqe: str, filename_qcnn: str) → qcnn

Load QCNN from VQE file and QCNN file

Parameters:

• filename_vqe (str) – Name of the file from where to load the VQE class

• filename_qcnn (str) – Name of the file from where to load the main parameters of the QCNN class

Returns:

QCNN class

Return type:

class

class PhaseEstimation.qcnn.qcnn(vqe: vqe, qcnn_circuit: Callable, n_outputs: int = 1)

Bases: object

predict()

Get the phases probabilities for each VQE state

Returns:

List of probabilities

Return type:

List[List[Number]]

predict_lines(predictions=[])

Get the prdicted phase-transition line

Parameters:

predictions (List[List[Number]]) – This is the output of self.predict(), if it is not passed, the predictions will be computed asnew

Returns:

y-coordinate of the transition point for each kappa value

Return type:

List[Number]

save(filename: str)

Saves QCNN parameters to file

Parameters:

filename (str) – File where to save the parameters

show(train_index=[], marginal=False, **kwargs)

train(lr: float, n_epochs: int, train_index: List[Number], loss_fn: Callable, circuit: bool = False, plot: bool = False)

Training function for the QCNN.

Parameters:

• lr (float) – Learning rate for the ADAM optimizer

• n_epochs (int) – Total number of epochs for each learning

• train_index (np.ndarray) – Index of training points

• loss_fn (function) – Loss function

• circuit (bool) – if True -> Prints the circuit

• plot (bool) – if True -> It displays loss curve

PhaseEstimation.qcnn.qcnn_circuit(params: List[Number], N: int, n_outputs: int) → Tuple[int, List[int]]

Building function for the QCNN circuit:

Parameters:

• params (np.ndarray) – Array of QCNN parameters

• N (int) – Number of qubits

• n_outputs (int) – Output vector dimension

Returns:

• int – Total number of parameters needed to build this circuit

• np.ndarray – Array of indexes of not-measured wires (due to pooling)

PhaseEstimation.visualization module

Plotting functions for the classes hamiltonians, vqe, qcnn, encoder. This functions are not meant to be used directly, but are called within their respective classes

PhaseEstimation.visualization.ENC_show_compression_ANNNI(encclass, trainingpoint=False, label=False, plot3d=False)

Plots performance of the compression on the whole data for an encoder on the ANNI model

Parameters:

• encoder (encoder.encoder) – Custom encoder class after being trained

• trainingpoint (int) – Mark the single training point on the plot

• label (str) – Label to assign to the picture, needed for the paper

• plot3d (bool) – If True the 3D plot will be displayed aswell

PhaseEstimation.visualization.HAM_mass_gap(Hs, phase_lines=False, pe_line=False)

Shows the mass gap which is defined as the difference between the first excited leven and the ground energy level for each point in the parameter space.

Parameters:

• Hs (hamiltonians.hamiltonian) – Custom hamiltonian class, it is needed to call plot_layout

• phase_lines (bool) – if True plots the phase transition lines

• pe_line (bool) – if True plots Peshel Emery line

PhaseEstimation.visualization.HAM_phases_plot(Hs)

Shows the division of phases of the parameter space according to the state-of-the-art lines

Parameters:

Hs (hamiltonians.hamiltonian) – Custom hamiltonian class, it is needed to call plot_layout

PhaseEstimation.visualization.QCNN_classification_ANNNI(qcnnclass, hard_thr=True, predicted_line=False, label=False, info=False)

Plots performance of the classifier on the whole data for a QCNN of a ANNI model

Parameters:

• qcnnclass (qcnn.qcnn) – Custom QCNN class after being trained

• hard_thr (bool) – if True the prediction will be displayed through an argmax instead of using color channels to entail the 3 (4 considering the trash case) probabilities

• predicted_line (bool) – if True it displays the predicted transition line

• label (str) – Label to assign to the picture, needed for the paper

• info (bool) – if True more infos will be displayed such as the names of the phases

PhaseEstimation.visualization.QCNN_classification_ANNNI_marginal(qcnnclass)

Displays the probabilities of the states on the two axes. It is used more as a debug function to test if the classes are being trained correctly.

Parameters:

qcnnclass (qcnn.qcnn) – Custom QCNN class after being trained

PhaseEstimation.visualization.QCNN_classification_ising(qcnnclass, train_index)

Plots performance of the classifier on the whole data for a QCNN of a Nearest Neighbour Interaction Hamiltonian

Parameters:

• qcnnclass (qcnn.qcnn) – Custom QCNN class after being trained

• train_index (List[Number]) – List of the indexes of the training set. On displaying they will be marked with a different colour

PhaseEstimation.visualization.VQE_fidelity_slice(vqeclass, slice_value, axis=0, truestates=False)

Shows confusion matrix of fidelities of only a ‘slice’ of states in the parameter space. In other words, it will be computed the fidelity of each state among every other that share the same h or kappa.

Parameters:

• vqeclass (vqe.vqe) – Custom VQE class after being trained

• slice_value (float) – if axis = 0, then we will pick only the states having h = slice_value and kappa whatever if axis = 1, then we will pick only the states having kappa = slice_value and h whatever

• axis (int) – Direction of where to slide, 0 is horizontal (fixed h), 1 is vertical (fixed kappa)

• truestates (bool) – if True the true states will be employed if False the VQE states will be employed

PhaseEstimation.visualization.VQE_psi_truepsi_fidelity(vqeclass, phase_lines=False, pe_line=False)

For each VQE resulting state, show its fidelity compared to its true state obtained through diagonalization of the Hamiltonian:

Parameters:

• vqeclass (vqe.vqe) – Custom VQE class after being trained

• phase_lines (bool) – if True plots the phase transition lines

• pe_line (bool) – if True plots Peshel Emery line

PhaseEstimation.visualization.VQE_show_annni(vqeclass, log_heatmap=False, plot3d=True, phase_lines=False, pe_line=False)

Shows results of a trained VQE (ANNNI) run:

Parameters:

• vqeclass (vqe.vqe) – Custom VQE class after being trained

• log_heatmap (bool) – if True, the accuracy is displayed in logscale

• plot3d (bool) – if True the predicted energies and true energies will be displayed in a 3D plot

• phase_lines (bool) – if True plots the phase transition lines

• pe_line (bool) – if True plots Peshel Emery line

PhaseEstimation.visualization.VQE_show_isingchain(vqeclass)

Shows results of a trained VQE (Nearest Neighbour Ising Model) run

Parameters:

vqeclass (vqe.vqe) – Custom VQE class after being trained

PhaseEstimation.visualization.getlines_from_Hs(Hs, func: Callable, xrange: List[float], res: int = 100, **kwargs)

Plot function func from xrange[0] to xrange[1] This function uses the Hamiltonians class to plot the function according to the ranges of its parameters

Parameters:

• Hs (hamiltonians.hamiltonian) – Custom Hamiltonian class

• func (function) – Function to plot, usually: > general.paraanti : Transition line between paramagnetic phase and antiphase; > general.paraferro : Transition line between paramagnetic phase and ferromagnetic phase; > general.b1 : Pseudo-transition line inside the antiphase subspace; > general.peshel_emery :Peshel Emery Line.

PhaseEstimation.visualization.plot_layout(Hs, pe_line, phase_lines, title, figure_already_defined=False)

Many plotting functions here have the same layout, this function will be called inside the others to have a standard layout

Parameters:

• Hs (hamiltonians.hamiltonian) – Custom hamiltonian class, it is needed to set xlim and ylim and ticks

• pe_line (bool) – if True plots Peshel Emery line

• phase_lines (bool) – if True plots the phase transition lines

• title (str) – Title of the legent of the plot

• figure_already_defined (bool) – if False it calls the plt.figure function

PhaseEstimation.vqe module

This module implements the base function to implement a VQE.

PhaseEstimation.vqe.circuit_ising(N: int, params: List[Number]) → int

Full VQE circuit Number of parameters (gates): 7*N

Parameters:

• N (int) – Number of qubits

• params (np.ndarray) – Array of parameters/rotation for the circuit

Returns:

Total number of parameters needed to build this circuit

Return type:

int

PhaseEstimation.vqe.circuit_ising2(N: int, params: List[Number]) → int

Full VQE circuit, enhanced version of circuit_ising, higher number of parameters Number of parameters (gates): 11*N

Parameters:

• N (int) – Number of qubits

• params (np.ndarray) – Array of parameters/rotation for the circuit

Returns:

Total number of parameters needed to build this circuit

Return type:

int

PhaseEstimation.vqe.circuit_ising3(N: int, params: List[Number]) → int

Shorter and more real circuit

Parameters:

• N (int) – Number of qubits

• params (np.ndarray) – Array of parameters/rotation for the circuit

Returns:

Total number of parameters needed to build this circuit

Return type:

int

PhaseEstimation.vqe.load_vqe(filename: str) → vqe

Load main parameters of a VQE class saved to a local file using vqe.save(filename)

Parameters:

filename (str) – Local file from where to load the parameters

Returns:

VQE class with main parameters

Return type:

class

class PhaseEstimation.vqe.vqe(Hs: hamiltonian, circuit: Callable)

Bases: object

save(filename: str)

Save main parameters of the VQE class to a local file. Parameters saved: > Hs class, vqe parameters, circuit function

Parameters:

filename (str) – Local file to save the parameters

show(**kwargs)

Shows results of a trained VQE (ANNNI) run:

Parameters:

• log_heatmap (bool) – (IF ANNNI) if True, the accuracy is displayed in logscale

• plot3d (bool) – (IF ANNNI) if True the predicted energies and true energies will be displayed in a 3D plot

• phase_lines (bool) – (IF ANNNI) if True plots the phase transition lines

• pe_line (bool) – (IF ANNNI) if True plots Peshel Emery line

show_fidelity(**kwargs)

For each VQE resulting state, show its fidelity compared to its true state obtained through diagonalization of the Hamiltonian:

Parameters:

• phase_lines (bool) – if True plots the phase transition lines

• pe_line (bool) – if True plots Peshel Emery line

show_fidelity_slice(slice_value, axis=0, truestates=False)

Shows confusion matrix of fidelities of only a ‘slice’ of states in the parameter space. In other words, it will be computed the fidelity of each state among every other that share the same h or kappa.

Parameters:

• slice_value (float) – if axis = 0, then we will pick only the states having h = slice_value and kappa whatever if axis = 1, then we will pick only the states having kappa = slice_value and h whatever

• axis (int) – Direction of where to slide, 0 is horizontal (fixed h), 1 is vertical (fixed kappa)

• truestates (bool) – if True the true states will be employed if False the VQE states will be employed

train(lr: Number, n_epochs: int, circuit: bool = False)

Training function for the VQE.

Parameters:

• lr (float) – Learning rate to be multiplied in the circuit-gradient output

• n_epochs (int) – Total number of epochs for each learning

• circuit (bool) – if True -> Prints the circuit

train_refine(lr: Number, n_epochs: int, acc_thr: Number, assist: bool = False)

Training only the sites that have an accuracy score worse (higher) than acc_thr

Parameters:

• lr (float) – Learning rate to be multiplied in the circuit-gradient output

• n_epochs (int) – Total number of epochs for each learning

• acc_thr (float) – Accuracy threshold for which selecting the sites to train

• assist (bool) – if True -> Each site that will be trained will start from the neighbouring site that has the better accuracy

train_site(lr: Number, n_epochs: int, site: int)

Minimize <psi|H|psi> for a single site

Module contents