Python gates.RX属性代码示例

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def get_rotation_program(pauli_term: PauliTerm) -> Program:
    """
    Generate a rotation program so that the pauli term is diagonal.

    :param pauli_term: The Pauli term used to generate diagonalizing one-qubit rotations.
    :return: The rotation program.
    """
    meas_basis_change = Program()
    for index, gate in pauli_term:
        if gate == 'X':
            meas_basis_change.inst(RY(-np.pi / 2, index))
        elif gate == 'Y':
            meas_basis_change.inst(RX(np.pi / 2, index))
        elif gate == 'Z':
            pass
        else:
            raise ValueError()

    return meas_basis_change 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_PrepareAndMeasureOnWFSim():
    p = Program()
    params = p.declare("params", memory_type="REAL", memory_size=2)
    p.inst(RX(params[0], 0))
    p.inst(RX(params[1], 1))

    def make_memory_map(params):
        return {"params": params}

#    ham = PauliSum.from_compact_str("1.0*Z0 + 1.0*Z1")
    term1 = PauliTerm("Z", 0)
    term2 = PauliTerm("Z", 1)
    ham = PauliSum([term1, term2])
    sim = WavefunctionSimulator()
    cost_fn = PrepareAndMeasureOnWFSim(p,
                                       make_memory_map,
                                       ham,
                                       sim,
                                       scalar_cost_function=False,
                                       enable_logging=True)
    out = cost_fn([np.pi, np.pi / 2])
    print(cost_fn.log[0].fun)
    assert np.allclose(cost_fn.log[0].fun, (-1.0, 0.0))
    assert np.allclose(out, (-1, 0.0)) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_PrepareAndMeasureOnWFSim_QubitPlaceholders():
    q1, q2 = QubitPlaceholder(), QubitPlaceholder()
    p = Program()
    params = p.declare("params", memory_type="REAL", memory_size=2)
    p.inst(RX(params[0], q1))
    p.inst(RX(params[1], q2))

    def make_memory_map(params):
        return {"params": params}

    ham = PauliSum([PauliTerm("Z", q1), PauliTerm("Z", q2)])
    qubit_mapping = get_default_qubit_mapping(p)
    sim = WavefunctionSimulator()
    cost_fn = PrepareAndMeasureOnWFSim(p, make_memory_map, ham, sim,
                                       enable_logging=True,
                                       qubit_mapping=qubit_mapping,
                                       scalar_cost_function=False,
                                       )
    out = cost_fn([np.pi, np.pi / 2])
    assert np.allclose(cost_fn.log[0].fun, (-1.0, 0.0))
    assert np.allclose(out, (-1, 0.0)) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_PrepareAndMeasureOnQVM():
    prepare_ansatz = Program()
    param_register = prepare_ansatz.declare(
        "params", memory_type="REAL", memory_size=2)
    prepare_ansatz.inst(RX(param_register[0], 0))
    prepare_ansatz.inst(RX(param_register[1], 1))

    def make_memory_map(params):
        return {"params": params}

#    ham = PauliSum.from_compact_str("1.0*Z0 + 1.0*Z1")
    term1 = PauliTerm("Z", 0)
    term2 = PauliTerm("Z", 1)
    ham = PauliSum([term1, term2])
    qvm = get_qc("2q-qvm")
    cost_fn = PrepareAndMeasureOnQVM(prepare_ansatz, make_memory_map, qvm=qvm,
                                     hamiltonian=ham, enable_logging=True,
                                     scalar_cost_function=True,
                                     base_numshots=10,
                                     nshots=10)
    out = cost_fn([np.pi, np.pi / 2])
    assert np.allclose(cost_fn.log[0].fun, (-1.0, 0.1), rtol=1.1)
    assert np.allclose(out, -1, rtol=1.1) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_PrepareAndMeasureOnQVM_QubitPlaceholders():
    q1, q2 = QubitPlaceholder(), QubitPlaceholder()
    prepare_ansatz = Program()
    param_register = prepare_ansatz.declare(
        "params", memory_type="REAL", memory_size=2)
    prepare_ansatz.inst(RX(param_register[0], q1))
    prepare_ansatz.inst(RX(param_register[1], q2))

    def make_memory_map(params):
        return {"params": params}

    ham = PauliSum([PauliTerm("Z", q1), PauliTerm("Z",q2)])
    qubit_mapping = get_default_qubit_mapping(prepare_ansatz)
    qvm = get_qc("2q-qvm")
    cost_fn = PrepareAndMeasureOnQVM(prepare_ansatz, make_memory_map,
                                     qvm=qvm,
                                     hamiltonian=ham, enable_logging=True,
                                     scalar_cost_function=False,
                                     base_numshots=10,
                                     qubit_mapping=qubit_mapping)
    out = cost_fn([np.pi, np.pi / 2], nshots=10)
    assert np.allclose(cost_fn.log[0].fun, (-1.0, 0.1), rtol=1.1)
    assert np.allclose(out, (-1, 0.1), rtol=1.1) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def _qaoa_mixing_ham_rotation(x_rotation_angles_reg: MemoryReference,
                              reg: Iterable) -> Program:
    """Produce parametric Quil-Code for the mixing hamiltonian rotation.

    Parameters
    ----------
    x_rotation_angles_reg:
        Classic register to read the x_rotation_angles from.
    reg:
        The register to apply the X-rotations on.

    Returns
    -------
    Program
        Parametric Quil Program containing the X-Rotations.

    """
    if len(reg) != x_rotation_angles_reg.declared_size:
        raise ValueError("x_rotation_angles must have the same length as reg")

    p = Program()
    for x_angle, qubit in zip(x_rotation_angles_reg, reg):
        p.inst(RX(-2 * x_angle, qubit))
    return p 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def get_compiled_prog(theta):
    return Program([
        RZgate(-pi/2, 0),
        RXgate(-pi/2, 0),
        RZgate(-pi/2, 1),
        RXgate( pi/2, 1),
        CZgate(1, 0),
        RZgate(-pi/2, 1),
        RXgate(-pi/2, 1),
        RZgate(theta, 1),
        RXgate( pi/2, 1),
        CZgate(1, 0),
        RXgate( pi/2, 0),
        RZgate( pi/2, 0),
        RZgate(-pi/2, 1),
        RXgate( pi/2, 1),
        RZgate(-pi/2, 1),
    ]) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_tensor_gates_single_qubit():
    prog = Program().inst([Hgate(0)])
    test_unitary = tensor_gates(gate_matrix, {}, prog.instructions[0], 1).toarray()
    true_unitary = gate_matrix['H']
    assert np.allclose(test_unitary, true_unitary)

    prog = Program().inst([Hgate(0)])
    test_unitary = tensor_gates(gate_matrix, {}, prog.instructions[0], 5).toarray()
    true_unitary = np.kron(np.eye(2**4), gate_matrix['H'])
    assert np.allclose(test_unitary, true_unitary)

    prog = Program().inst([RXgate(0.2, 3)])
    test_unitary = tensor_gates(gate_matrix, {}, prog.instructions[0], 5).toarray()
    true_unitary = np.kron(np.eye(2**1), np.kron(gate_matrix['RX'](0.2),  np.eye(2**3)))
    assert np.allclose(test_unitary, true_unitary)

    prog = Program().inst([RXgate(0.5, 4)])
    test_unitary = tensor_gates(gate_matrix, {}, prog.instructions[0], 5).toarray()
    true_unitary = np.kron(np.eye(2**0), np.kron(gate_matrix['RX'](0.5),  np.eye(2**4)))
    assert np.allclose(test_unitary, true_unitary) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_parameter_not_given_error(self):
        """Test that the correct error is raised if a parameter is not given."""
        program = pyquil.Program()

        alpha = program.declare("alpha", "REAL")
        beta = program.declare("beta", "REAL")

        program += g.H(0)
        program += g.CNOT(0, 1)
        program += g.RX(alpha, 1)
        program += g.RZ(beta, 1)

        a = 0.1

        parameter_map = {"alpha": a}

        with pytest.raises(
            qml.DeviceError,
            match="The PyQuil program defines a variable .* that is not present in the given variable map",
        ):
            load_program(program)(wires=range(2), parameter_map=parameter_map) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_lifted_gate_single_qubit():
    test_unitary = lifted_gate(H(0), 1)
    true_unitary = mat.H
    assert np.allclose(test_unitary, true_unitary)

    test_unitary = lifted_gate(H(0), 5)
    true_unitary = np.kron(np.eye(2 ** 4), mat.H)
    assert np.allclose(test_unitary, true_unitary)

    test_unitary = lifted_gate(RX(0.2, 3), 5)
    true_unitary = np.kron(np.eye(2 ** 1), np.kron(mat.RX(0.2), np.eye(2 ** 3)))
    assert np.allclose(test_unitary, true_unitary)

    test_unitary = lifted_gate(RX(0.5, 4), 5)
    true_unitary = np.kron(np.eye(2 ** 0), np.kron(mat.RX(0.5), np.eye(2 ** 4)))
    assert np.allclose(test_unitary, true_unitary) 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_gates_in_isa(isa_dict):
    isa = ISA.from_dict(isa_dict)
    gates = gates_in_isa(isa)
    for q in [0, 1, 2]:
        for g in [
            I(q),
            RX(np.pi / 2, q),
            RX(-np.pi / 2, q),
            RX(np.pi, q),
            RX(-np.pi, q),
            RZ(THETA, q),
        ]:
            assert g in gates

    assert CZ(0, 1) in gates
    assert CZ(1, 0) in gates
    assert ISWAP(1, 2) in gates
    assert ISWAP(2, 1) in gates
    assert CPHASE(THETA, 2, 0) in gates
    assert CPHASE(THETA, 0, 2) in gates 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def _flip_array_to_prog(flip_array: Tuple[bool], qubits: List[int]) -> Program:
    """
    Generate a pre-measurement program that flips the qubit state according to the flip_array of
    bools.

    This is used, for example, in symmetrization to produce programs which flip a select subset
    of qubits immediately before measurement.

    :param flip_array: tuple of booleans specifying whether the qubit in the corresponding index
        should be flipped or not.
    :param qubits: list specifying the qubits in order corresponding to the flip_array
    :return: Program which flips each qubit (i.e. instructs RX(pi, q)) according to the flip_array.
    """
    assert len(flip_array) == len(qubits), "Mismatch of qubits and operations"
    prog = Program()
    for qubit, flip_output in zip(qubits, flip_array):
        if flip_output == 0:
            continue
        elif flip_output == 1:
            prog += Program(RX(pi, qubit))
        else:
            raise ValueError("flip_bools should only consist of 0s and/or 1s")
    return prog 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def _one_q_sic_prep(index: int, qubit: QubitDesignator) -> Program:
    """Prepare the index-th SIC basis state."""
    if index == 0:
        return Program()

    theta = 2 * np.arccos(1 / np.sqrt(3))
    zx_plane_rotation = Program([RX(-pi / 2, qubit), RZ(theta - pi, qubit), RX(-pi / 2, qubit)])

    if index == 1:
        return zx_plane_rotation

    elif index == 2:
        return zx_plane_rotation + RZ(-2 * pi / 3, qubit)

    elif index == 3:
        return zx_plane_rotation + RZ(2 * pi / 3, qubit)

    raise ValueError(f"Bad SIC index: {index}") 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def _one_q_pauli_prep(label: str, index: int, qubit: QubitDesignator) -> Program:
    """Prepare the index-th eigenstate of the pauli operator given by label."""
    if index not in [0, 1]:
        raise ValueError(f"Bad Pauli index: {index}")

    if label == "X":
        if index == 0:
            return Program(RY(pi / 2, qubit))
        else:
            return Program(RY(-pi / 2, qubit))

    elif label == "Y":
        if index == 0:
            return Program(RX(-pi / 2, qubit))
        else:
            return Program(RX(pi / 2, qubit))

    elif label == "Z":
        if index == 0:
            return Program()
        else:
            return Program(RX(pi, qubit))

    raise ValueError(f"Bad Pauli label: {label}") 

# 需要导入模块: from pyquil import gates [as 别名]
# 或者: from pyquil.gates import RX [as 别名]
def test_to_latex():
    """A test to give full coverage of latex_generation."""
    p = Program()
    p.inst(
        X(0),
        RX(1.0, 5),
        Y(0),
        CZ(0, 2),
        SWAP(0, 1),
        MEASURE(0, None),
        CNOT(2, 0),
        X(0).controlled(1),
        Y(0).dagger(),
    )
    _ = to_latex(p)

    # Modify settings to access non-standard control paths.
    settings = DiagramSettings(impute_missing_qubits=True)
    _ = to_latex(p, settings)

    settings = DiagramSettings(abbreviate_controlled_rotations=True)
    _ = to_latex(p, settings)

    settings = DiagramSettings(label_qubit_lines=False)
    _ = to_latex(p, settings)