qibo

import numpy as np
from scipy.optimize import minimize
from qibo import Circuit, gates
def ansatz(p=0):
    """Ansatz for driving a random state into its up-tp-phases canonical form.
    Args:
      p (float): probability of occuring a single-qubit depolarizing error
    Returns:
      Qibo circuit implementing the variational ansatz.
    """
    circuit = Circuit(3, density_matrix=p > 0)
    for qubit in range(3):
        circuit.add(gates.RZ(qubit, theta=0))
        circuit.add(gates.RY(qubit, theta=0))
        circuit.add(gates.RZ(qubit, theta=0))
        if p > 0:
            circuit.add(
                gates.PauliNoiseChannel(
                    qubit, [("X", p / 3), ("Y", p / 3), ("Z", p / 3)]
                )
            )
    for qubit in range(3):
        if p > 0:
            circuit.add(gates.PauliNoiseChannel(qubit, [("X", 10 * p)]))
        circuit.add(gates.M(qubit))
    return circuit
def cost_function(theta, state, circuit, shots: int = 1000):
    """Cost function encoding the difference between a state and its up-to-phases canonical form.
    Args:
        theta (ndarray): parameters of the unitary rotations.
        state (ndarray): three-qubit random state.
        circuit (:class:`qibo.models.Circuit`): variational circuit.
        shots (int, optional): shots used for measuring every circuit. Defaults to :math:`1000`.
    Returns:
        float: Cost function
    """
    circuit.set_parameters(theta)
    measurements = circuit(state, nshots=shots).frequencies(binary=False)
    return (measurements[1] + measurements[2] + measurements[3]) / shots
def canonize(state, circuit, shots: int = 1000):

import argparse
import matplotlib.pyplot as plt
import numpy as np
from canonizator import *
parser = argparse.ArgumentParser()
parser.add_argument("--N", default=100, help="Number of random states.", type=int)
parser.add_argument(
    "--p", default=0.001, help="Probability of occurring an error.", type=float
)
parser.add_argument(
    "--shots", default=1000, help="Shots used for measuring every circuit.", type=float
)
parser.add_argument(
    "--post_selection", default=True, help="Post selection technique", type=bool
)
parser.add_argument("--no_plot", action="store_true", help="Avoid plots")
def main(N, p, shots, post_selection, no_plot):
    # Initialize exact and measured tangles
    tangles = np.empty(N)
    opt_tangles = np.empty(N)
    circuit = ansatz(p)
    for qubit in range(N):
        """
        For every seed from 0 to N, the steps to follow are
        1) A random state with three qubits is created from the seed
        2) The tangle of the recently created random state is computed exactly
        3) Transformation to the up-to-phases canonical form is performed by applying local operations
                that drive some coefficients to zero
        4) The tangle of the up-to-phases canonical form of the created state is measured from the outcomes of the state.
                Post-selection can be applied at this stage
        Results are stored into variables to paint the results
        """
        if qubit % 10 == 0:
            print("Initialized state with seed %s" % qubit + "/ %s" % N)
        state = create_random_state(qubit, p > 0)
        tangles[qubit] = compute_random_tangle(qubit)
        _, params = canonize(state, circuit, shots=np.int32(shots))
        opt_tangles[qubit] = canonical_tangle(
            state, params, circuit, post_selection=post_selection
        )

#!/usr/bin/env python
import argparse
import numpy as np
from qibo import Circuit, gates
from qibo.hamiltonians import XXZ, X
from qibo.models.variational import AAVQE
def main(nqubits, layers, maxsteps, T_max):
    circuit = Circuit(nqubits)
    for l in range(layers):
        circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
        circuit.add(gates.CZ(q, q + 1) for q in range(0, nqubits - 1, 2))
        circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
        circuit.add(gates.CZ(q, q + 1) for q in range(1, nqubits - 2, 2))
        circuit.add(gates.CZ(0, nqubits - 1))
    circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
    problem_hamiltonian = XXZ(nqubits)
    easy_hamiltonian = X(nqubits)
    s = lambda t: t
    aavqe = AAVQE(
        circuit, easy_hamiltonian, problem_hamiltonian, s, nsteps=maxsteps, t_max=T_max
    )
    initial_parameters = np.random.uniform(
        0, 2 * np.pi * 0.1, 2 * nqubits * layers + nqubits
    )
    best, params = aavqe.minimize(initial_parameters)
    print("Final parameters: ", params)
    print("Final energy: ", best)
    # We compute the difference from the exact value to check performance
    eigenvalue = problem_hamiltonian.eigenvalues()
    print(eigenvalue)
    print("Difference from exact value: ", best - np.real(eigenvalue[0]))
    print("Log difference: ", -np.log10(best - np.real(eigenvalue[0])))
if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--nqubits", default=6, type=int)
    parser.add_argument("--layers", default=5, type=int)
    parser.add_argument("--maxsteps", default=10, type=int)
    parser.add_argument("--T_max", default=5, type=int)
    args = parser.parse_args()
    main(**vars(args))