量子线性系统算法及实践——以Cirq为例

class HamiltonianSimulation(cirq.EigenGate):

    def __init__(self, A, t, exponent=1.0):
        cirq.EigenGate.__init__(self, exponent=exponent)
        self.A = A
        self.t = t
        ws, vs = np.linalg.eigh(A)
        self.eigen_components = []
        for w, v in zip(ws, vs.T):
            theta = w * t / math.pi
            P = np.outer(v, np.conj(v))
            self.eigen_components.append((theta, P))

    def _num_qubits_(self) -> int:
        return 1

    def _with_exponent(self, exponent):
        return HamiltonianSimulation(self.A, self.t, exponent)

    def _eigen_components(self):
        return self.eigen_components

class PhaseEstimation(cirq.Gate):
    """
        num_qubits: The number of qubits of the unitary.
        unitary: The unitary gate whose phases will be estimated.
    """
    def __init__(self, num_qubits, unitary):
        self._num_qubits = num_qubits
        self.U = unitary

    def num_qubits(self):
        return self._num_qubits

    def _decompose_(self, qubits):
        qubits = list(qubits)
        yield cirq.H.on_each(*qubits[:-1])
        yield PhaseKickback(self.num_qubits(), self.U)(*qubits)
        yield cirq.qft(*qubits[:-1], without_reverse=True) ** -1

import numpy as np

from qutrunk.circuit import QCircuit
from qutrunk.circuit.gates import H, All, P


def run_QFT():
    circuit = QCircuit()
    qureg = circuit.allocate(3)

    All(H) * qureg
    circuit.qft([q.index for q in qureg])
    print(circuit.get_all_state())

    circuit.run()


def run_Full_QFT():
    circuit = QCircuit()
    qureg = circuit.allocate(3)

    All(H) * qureg
    circuit.qft()
    print(circuit.get_all_state())

    circuit.run()


def qft_single_wave():
    num_qubits = 4
    circuit = QCircuit()
    qreg = circuit.allocate(num_qubits)
    All(H) * qreg
    P(np.pi / 4) * qreg[0]
    P(np.pi / 2) * qreg[1]
    P(np.pi) | qreg[2]
    circuit.qft()
    print(circuit.get_all_state())
    circuit.run()

    return circuit


if __name__ == "__main__":
    run_QFT()
    run_Full_QFT()
    circuit = qft_single_wave()
    print(circuit.draw())

def hhl_circuit(A, C, t, register_size, *input_prep_gates):

    ancilla = cirq.LineQubit(0)
    # to store eigenvalues of the matrix
    register = [cirq.LineQubit(i + 1) for i in range(register_size)]
    # to store input and output vectors
    memory = cirq.LineQubit(register_size + 1)

    c = cirq.Circuit()
    hs = HamiltonianSimulation(A, t)
    pe = PhaseEstimation(register_size + 1, hs)
    c.append([gate(memory) for gate in input_prep_gates])
    c.append(
        [
            pe(*(register + [memory])),
            EigenRotation(register_size + 1, C, t)(*(register + [ancilla])),
            pe(*(register + [memory])) ** -1,
            cirq.measure(ancilla, key='a'),
        ]
    )

    c.append(
        [
            cirq.PhasedXPowGate(
                exponent=sympy.Symbol('exponent'), phase_exponent=sympy.Symbol('phase_exponent')
            )(memory),
            cirq.measure(memory, key='m'),
        ]
    )

    return c