import qcircuits as qc
import numpy as np
# Deutsch's Algorithhm:
# We use interference to determine if f(0) = f(1) using a single function evaluation.
# Construct a Boolean function that is constant or balanced
def construct_problem():
    answers = np.random.randint(0, 2, size=2)
    def f(bit):
        return answers[bit]
    return f
def deutsch_algorithm(f):
    U_f = qc.U_f(f, d=2)
    H = qc.Hadamard()
    phi = H(qc.zeros()) * H(qc.ones())
    phi = U_f(phi)
    phi = H(phi, qubit_indices=[0])
    measurement = phi.measure(qubit_indices=0)
    return measurement
if __name__ == '__main__':
    f = construct_problem()
    parity = f(0) == f(1)
    measurement = deutsch_algorithm(f)
    print('f(0): {}, f(1): {}'.format(f(0), f(1)))
    print('f(0) == f(1): {}'.format(parity))
    print('Measurement: {}'.format(measurement))

import qcircuits as qc
import numpy as np
import random
# Deutsch-Jozsa Algorithhm:
# We are presented with a Boolean function that is either constant or
# balanced (i.e., 0 for half of inputs, 1 for the other half).
# We make use of interference to determine whether the function is constant
# or balanced in a single function evaluation.
# Construct a Boolean function that is constant or balanced
def construct_problem(d=1, problem_type='constant'):
    num_inputs = 2**d
    answers = np.zeros(num_inputs, dtype=np.int32)
    if problem_type == 'constant':
        answers[:] = int(np.random.random() < 0.5)
    else: # function is balanced
        indices = np.random.choice(num_inputs, size=num_inputs//2, replace=False)
        answers[indices] = 1
    def f(*bits):
        index = sum(v * 2**i for i, v in enumerate(bits))
        return answers[index]
    return f
def deutsch_jozsa_algorithm(d, f):
    # The operators we will need
    U_f = qc.U_f(f, d=d+1)
    H_d = qc.Hadamard(d)
    H = qc.Hadamard()
    state = qc.zeros(d) * qc.ones(1)
    state = (H_d * H)(state)
    state = U_f(state)
    state = H_d(state, qubit_indices=range(d))
    measurements = state.measure(qubit_indices=range(d))
    return measurements
if __name__ == '__main__':
    d = 10
    problem_type = random.choice(['constant', 'balanced'])
    f = construct_problem(d, problem_type)
    measurements = deutsch_jozsa_algorithm(d, f)
    print('Problem type: {}'.format(problem_type))
    print('Measurement: {}'.format(measurements))
    print('Observed all zeros: {}'.format(not any(measurements)))

import qcircuits as qc
import numpy as np
import random
# Grover's algorithm (search)
# Given a boolean function f, Grover's algorithm finds an x such that
# f(x) = 1.
# If there are N values of x, and M possible solutions, it requires
# O(sqrt(N/M)) time.
# Here, we construct a search problem with 1 solution amongst 1024
# possible answers, and find the solution with 25 applications of
# the Grover iteration operator.
# Construct a Boolean function that is 1 in exactly one place
def construct_problem(d=10):
    num_inputs = 2**d
    answers = np.zeros(num_inputs, dtype=np.int32)
    answers[np.random.randint(0, num_inputs)] = 1
    def f(*bits):
        index = sum(v * 2**i for i, v in enumerate(bits))
        return answers[index]
    return f
def grover_algorithm(d, f):
    # The operators we will need
    Oracle = qc.U_f(f, d=d+1)
    H_d = qc.Hadamard(d)
    H = qc.Hadamard()
    N = 2**d
    zero_projector = np.zeros((N, N))
    zero_projector[0, 0] = 1
    Inversion = H_d((2 * qc.Operator.from_matrix(zero_projector) - qc.Identity(d))(H_d))
    Grover = Inversion(Oracle, qubit_indices=range(d))
    # Initial state
    state = qc.zeros(d) * qc.ones(1)
    state = (H_d * H)(state)
    # Number of Grover iterations
    angle_to_rotate = np.arccos(np.sqrt(1 / N))
    rotation_angle = 2 * np.arcsin(np.sqrt(1 / N))
    iterations = int(round(angle_to_rotate / rotation_angle))
    for i in range(iterations):
        state = Grover(state)
    measurements = state.measure(qubit_indices=range(d))