コード例 #1
0
ファイル: pauli.py プロジェクト: BQSKit/bqskit
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)

        H = dot_product(params, self.sigmav)
        eiH = sp.linalg.expm(H)
        return UnitaryMatrix(eiH, check_arguments=False)
コード例 #2
0
ファイル: test_minimization.py プロジェクト: BQSKit/bqskit
def test_full_pauli_gate() -> None:
    circuit = Circuit(3)
    circuit.append_gate(PauliGate(3), [0, 1, 2])
    cost = HilbertSchmidtResiduals(circuit,
                                   UnitaryMatrix(unitary_group.rvs(8)))
    circuit.minimize(cost)
    assert cost.get_cost(circuit.get_params()) < 1e-6
コード例 #3
0
 def __init__(
     self,
     utry: UnitaryLike,
     radixes: Sequence[int] = [],
 ) -> None:
     self.utry = UnitaryMatrix(utry, radixes)
     self.size = self.utry.get_size()
     self.radixes = self.utry.get_radixes()
コード例 #4
0
class YGate(ConstantGate, QubitGate):
    """The Pauli Y gate."""

    size = 1
    qasm_name = 'y'
    utry = UnitaryMatrix([
        [0, -1j],
        [1j, 0],
    ], )
コード例 #5
0
ファイル: x.py プロジェクト: BQSKit/bqskit
class XGate(ConstantGate, QubitGate):
    """The Pauli X gate."""

    size = 1
    qasm_name = 'x'
    utry = UnitaryMatrix([
        [0, 1],
        [1, 0],
    ], )
コード例 #6
0
ファイル: s.py プロジェクト: BQSKit/bqskit
class SGate(ConstantGate, QubitGate):
    """The S gate."""

    size = 1
    qasm_name = 's'
    utry = UnitaryMatrix([
        [1, 0],
        [0, 1j],
    ], )
コード例 #7
0
class ZGate(ConstantGate, QubitGate):
    """The Pauli Z gate."""

    size = 1
    qasm_name = 'z'
    utry = UnitaryMatrix([
        [1, 0],
        [0, -1],
    ], )
コード例 #8
0
ファイル: sx.py プロジェクト: BQSKit/bqskit
class SqrtXGate(ConstantGate, QubitGate):
    """The Sqrt(X) gate."""

    size = 1
    qasm_name = 'sx'
    utry = UnitaryMatrix([
        [np.sqrt(2) / 2, -1j * np.sqrt(2) / 2],
        [-1j * np.sqrt(2) / 2, np.sqrt(2) / 2],
    ], )
コード例 #9
0
class TdgGate(ConstantGate, QubitGate):
    """The T Dagger gate."""

    size = 1
    qasm_name = 'tdg'
    utry = UnitaryMatrix([
        [1, 0],
        [0, np.exp(-1j * np.pi / 4)],
    ], )
コード例 #10
0
ファイル: t.py プロジェクト: BQSKit/bqskit
class TGate(ConstantGate, QubitGate):
    """The T gate."""

    size = 1
    qasm_name = 't'
    utry = UnitaryMatrix([
        [1, 0],
        [0, np.exp(1j * np.pi / 4)],
    ], )
コード例 #11
0
ファイル: h.py プロジェクト: BQSKit/bqskit
class HGate(ConstantGate, QubitGate):
    """The Hadamard gate."""

    size = 1
    qasm_name = 'h'
    utry = UnitaryMatrix([
        [np.sqrt(2) / 2, np.sqrt(2) / 2],
        [np.sqrt(2) / 2, -np.sqrt(2) / 2],
    ], )
コード例 #12
0
ファイル: sqrtcnot.py プロジェクト: BQSKit/bqskit
class SqrtCNOTGate(ConstantGate, QubitGate):

    size = 2
    qasm_name = 'csx'
    utry = UnitaryMatrix([
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 0.5 + 0.5j, 0.5 - 0.5j],
        [0, 0, 0.5 - 0.5j, 0.5 + 0.5j],
    ], )
コード例 #13
0
ファイル: controlled.py プロジェクト: BQSKit/bqskit
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)
        if hasattr(self, 'utry'):
            return self.utry

        # TODO: Find reference
        U = self.gate.get_unitary(params)
        right = np.kron(self.OneProj, U)
        return UnitaryMatrix(self.left + right, self.get_radixes())
コード例 #14
0
ファイル: u1.py プロジェクト: BQSKit/bqskit
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)

        exp = np.exp(1j * params[0])

        return UnitaryMatrix([
            [1, 0],
            [0, exp],
        ], )
コード例 #15
0
ファイル: pauli.py プロジェクト: BQSKit/bqskit
    def get_unitary_and_grad(
        self,
        params: Sequence[float] = [],
    ) -> tuple[UnitaryMatrix, np.ndarray]:
        """Returns the unitary and gradient, see Gate for more info."""
        self.check_parameters(params)

        H = dot_product(params, self.sigmav)
        U, dU = dexpmv(H, self.sigmav)
        return UnitaryMatrix(U, check_arguments=False), dU
コード例 #16
0
class SwapGate(ConstantGate, QubitGate):
    """The swap gate."""

    size = 2
    qasm_name = 'swap'
    utry = UnitaryMatrix([
        [1, 0, 0, 0],
        [0, 0, 1, 0],
        [0, 1, 0, 0],
        [0, 0, 0, 1],
    ], )
コード例 #17
0
ファイル: sdg.py プロジェクト: BQSKit/bqskit
class SdgGate(ConstantGate, QubitGate):
    """The S Dagger gate."""

    size = 1
    qasm_name = 'sdg'
    utry = UnitaryMatrix(
        [
            [1, 0],
            [0, -1j],
        ],
    )
コード例 #18
0
class CNOTGate(ConstantGate, QubitGate):
    """The controlled-not or controlled-X gate."""

    size = 2
    qasm_name = 'cx'
    utry = UnitaryMatrix([
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 0, 1],
        [0, 0, 1, 0],
    ], )
コード例 #19
0
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)

        cos = np.cos(params[0] / 2)
        sin = -1j * np.sin(params[0] / 2)

        return UnitaryMatrix([
            [cos, sin],
            [sin, cos],
        ], )
コード例 #20
0
ファイル: test_ceres.py プロジェクト: BQSKit/bqskit
def test_minimize_ceres() -> None:
    circ = Circuit(1)
    circ.append_gate(RXGate(), location=[0], params=[0.0])
    xgate = XGate()
    xutry = xgate.get_unitary()
    cost = HilbertSchmidtResidualsGenerator().gen_cost(
        circ, UnitaryMatrix(-1j * xutry.get_numpy()),
    )
    minimizer = CeresMinimizer()
    x = minimizer.minimize(cost, np.array([np.pi / 2]))
    assert cost.get_cost(x) < 1e-6, x
コード例 #21
0
class CHGate(ConstantGate, QubitGate):
    """The controlled-H gate."""

    size = 2
    qasm_name = 'ch'
    utry = UnitaryMatrix([
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, np.sqrt(2) / 2, np.sqrt(2) / 2],
        [0, 0, np.sqrt(2) / 2, -np.sqrt(2) / 2],
    ], )
コード例 #22
0
ファイル: xx.py プロジェクト: BQSKit/bqskit
class XXGate(ConstantGate, QubitGate):
    """The Ising XX coupling gate."""

    size = 2
    qasm_name = 'rxx(pi/2)'
    utry = UnitaryMatrix([
        [np.sqrt(2) / 2, 0, 0, -1j * np.sqrt(2) / 2],
        [0, np.sqrt(2) / 2, -1j * np.sqrt(2) / 2, 0],
        [0, -1j * np.sqrt(2) / 2, np.sqrt(2) / 2, 0],
        [-1j * np.sqrt(2) / 2, 0, 0,
         np.sqrt(2) / 2],
    ], )
コード例 #23
0
ファイル: u2.py プロジェクト: BQSKit/bqskit
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)

        sq2 = np.sqrt(2) / 2
        eip = np.exp(1j * params[0])
        eil = np.exp(1j * params[1])

        return UnitaryMatrix([
            [sq2, -eil * sq2],
            [eip * sq2, eip * eil * sq2],
        ], )
コード例 #24
0
class CZGate(ConstantGate, QubitGate):
    """The controlled-Z gate."""

    size = 2
    qasm_name = 'cz'
    utry = UnitaryMatrix(
        [
            [1, 0, 0, 0],
            [0, 1, 0, 0],
            [0, 0, 1, 0],
            [0, 0, 0, -1],
        ],
    )
コード例 #25
0
ファイル: rzz.py プロジェクト: BQSKit/bqskit
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)

        pos = np.exp(1j * params[0] / 2)
        neg = np.exp(-1j * params[0] / 2)

        return UnitaryMatrix([
            [neg, 0, 0, 0],
            [0, pos, 0, 0],
            [0, 0, pos, 0],
            [0, 0, 0, neg],
        ], )
コード例 #26
0
ファイル: cy.py プロジェクト: BQSKit/bqskit
class CYGate(ConstantGate, QubitGate):
    """The controlled-Y gate."""

    size = 2
    qasm_name = 'cy'
    utry = UnitaryMatrix(
        [
            [1, 0, 0, 0],
            [0, 1, 0, 0],
            [0, 0, 0, -1j],
            [0, 0, 1j, 0],
        ],
    )
コード例 #27
0
ファイル: cpi.py プロジェクト: BQSKit/bqskit
class CPIGate(ConstantGate, QutritGate):
    """The CPI gate."""

    size = 2
    utry = UnitaryMatrix([
        [1, 0, 0, 0, 0, 0, 0, 0, 0],
        [0, 1, 0, 0, 0, 0, 0, 0, 0],
        [0, 0, 1, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 1, 0, 0, 0, 0],
        [0, 0, 0, 1, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 0, 1, 0, 0, 0],
        [0, 0, 0, 0, 0, 0, 1, 0, 0],
        [0, 0, 0, 0, 0, 0, 0, 1, 0],
        [0, 0, 0, 0, 0, 0, 0, 0, 1],
    ], )
コード例 #28
0
ファイル: csum.py プロジェクト: BQSKit/bqskit
class CSUMGate(ConstantGate, QutritGate):
    """The Conditional-SUM gate."""

    size = 2
    utry = UnitaryMatrix(
        [
            [1, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 1, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 1, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 1, 0, 0, 0],
            [0, 0, 0, 1, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 1, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 1, 0],
            [0, 0, 0, 0, 0, 0, 1, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 1],
        ],
    )
コード例 #29
0
ファイル: u3.py プロジェクト: BQSKit/bqskit
    def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:
        """Returns the unitary for this gate, see Unitary for more info."""
        self.check_parameters(params)

        ct = np.cos(params[0] / 2)
        st = np.sin(params[0] / 2)
        cp = np.cos(params[1])
        sp = np.sin(params[1])
        cl = np.cos(params[2])
        sl = np.sin(params[2])
        el = cl + 1j * sl
        ep = cp + 1j * sp

        return UnitaryMatrix([
            [ct, -el * st],
            [ep * st, ep * el * ct],
        ], )
コード例 #30
0
ファイル: instantiater.py プロジェクト: BQSKit/bqskit
    def check_target(
        self,
        target: UnitaryLike | StateLike,
    ) -> UnitaryMatrix | StateVector:
        """Check `target` to be valid and return it casted."""
        try:
            typed_target = StateVector(target)  # type: ignore
        except (ValueError, TypeError):
            try:
                typed_target = UnitaryMatrix(target)  # type: ignore
            except (ValueError, TypeError) as ex:
                raise TypeError(
                    'Expected either StateVector, UnitaryMatrix, or'
                    ' CostFunction for target, got %s.' % type(target),
                ) from ex

        return typed_target