common_channels_test.py

# Copyright 2018 The Cirq Developers
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import numpy as np
import pytest

import cirq

X = np.array([[0, 1], [1, 0]])
Y = np.array( [[0, -1j], [1j, 0]])
Z = np.array( [[1, 0], [0, -1]])

round_to_6_prec = cirq.CircuitDiagramInfoArgs(known_qubits=None,
                                              known_qubit_count=None,
                                              use_unicode_characters=True,
                                              precision=6,
                                              qubit_map=None)

round_to_2_prec = cirq.CircuitDiagramInfoArgs(known_qubits=None,
                                              known_qubit_count=None,
                                              use_unicode_characters=True,
                                              precision=2,
                                              qubit_map=None)


def assert_mixtures_equal(actual, expected):
    """Assert equal for tuple of mixed scalar and array types."""
    for a, e in zip(actual, expected):
        np.testing.assert_almost_equal(a[0], e[0])
        np.testing.assert_almost_equal(a[1], e[1])


def test_asymmetric_depolarizing_channel():
    d = cirq.asymmetric_depolarize(0.1, 0.2, 0.3)
    np.testing.assert_almost_equal(cirq.channel(d),
                                   (np.sqrt(0.4) * np.eye(2),
                                    np.sqrt(0.1) * X,
                                    np.sqrt(0.2) * Y,
                                    np.sqrt(0.3) * Z))
    assert cirq.has_channel(d)


def test_asymmetric_depolarizing_mixture():
    d = cirq.asymmetric_depolarize(0.1, 0.2, 0.3)
    assert_mixtures_equal(cirq.mixture(d),
                          ((0.4, np.eye(2)),
                           (0.1, X),
                           (0.2, Y),
                           (0.3, Z)))
    assert cirq.has_mixture_channel(d)


def test_asymmetric_depolarizing_channel_repr():
    cirq.testing.assert_equivalent_repr(
        cirq.AsymmetricDepolarizingChannel(0.1, 0.2, 0.3))


def test_asymmetric_depolarizing_channel_str():
    assert (str(cirq.asymmetric_depolarize(0.1, 0.2, 0.3))
            == 'asymmetric_depolarize(p_x=0.1,p_y=0.2,p_z=0.3)')


def test_asymmetric_depolarizing_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.asymmetric_depolarize(0.0, 0.0, 0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.asymmetric_depolarize(0.0, 0.0, 0.1))
    et.add_equality_group(cirq.asymmetric_depolarize(0.0, 0.1, 0.0))
    et.add_equality_group(cirq.asymmetric_depolarize(0.1, 0.0, 0.0))
    et.add_equality_group(cirq.asymmetric_depolarize(0.1, 0.2, 0.3))
    et.add_equality_group(cirq.asymmetric_depolarize(0.3, 0.4, 0.3))
    et.add_equality_group(cirq.asymmetric_depolarize(1.0, 0.0, 0.0))
    et.add_equality_group(cirq.asymmetric_depolarize(0.0, 1.0, 0.0))
    et.add_equality_group(cirq.asymmetric_depolarize(0.0, 0.0, 1.0))


@pytest.mark.parametrize('p_x,p_y,p_z', (
    (-0.1, 0.0, 0.0),
    (0.0, -0.1, 0.0),
    (0.0, 0.0, -0.1),
    (0.1, -0.1, 0.1)))
def test_asymmetric_depolarizing_channel_negative_probability(p_x, p_y, p_z):
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.asymmetric_depolarize(p_x, p_y, p_z)


@pytest.mark.parametrize('p_x,p_y,p_z', (
    (1.1, 0.0, 0.0),
    (0.0, 1.1, 0.0),
    (0.0, 0.0, 1.1),
    (0.1, 0.9, 0.1)))
def test_asymmetric_depolarizing_channel_bigly_probability(p_x, p_y, p_z):
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.asymmetric_depolarize(p_x, p_y, p_z)


def test_asymmetric_depolarizing_channel_text_diagram():
    a = cirq.asymmetric_depolarize(1 / 9, 2 / 9, 3 / 9)
    assert (cirq.circuit_diagram_info(
        a, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('A(0.111111,0.222222,0.333333)',)))
    assert (cirq.circuit_diagram_info(
        a, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('A(0.11,0.22,0.33)',)))


def test_depolarizing_channel():
    d = cirq.depolarize(0.3)
    np.testing.assert_almost_equal(cirq.channel(d),
                                   (np.sqrt(0.7) * np.eye(2),
                                    np.sqrt(0.1) * X,
                                    np.sqrt(0.1) * Y,
                                    np.sqrt(0.1) * Z))
    assert cirq.has_channel(d)

def test_depolarizing_mixture():
    d = cirq.depolarize(0.3)
    assert_mixtures_equal(cirq.mixture(d),
                          ((0.7, np.eye(2)),
                           (0.1, X),
                           (0.1, Y),
                           (0.1, Z)))
    assert cirq.has_mixture_channel(d)


def test_depolarizing_channel_repr():
    cirq.testing.assert_equivalent_repr(cirq.DepolarizingChannel(0.3))


def test_depolarizing_channel_str():
    assert str(cirq.depolarize(0.3)) == 'depolarize(p=0.3)'


def test_depolarizing_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.depolarize(0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.depolarize(0.1))
    et.add_equality_group(cirq.depolarize(0.9))
    et.add_equality_group(cirq.depolarize(1.0))


def test_depolarizing_channel_invalid_probability():
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.depolarize(-0.1)
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.depolarize(1.1)


def test_depolarizing_channel_text_diagram():
    d = cirq.depolarize(0.1234567)
    assert (cirq.circuit_diagram_info(
        d, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('D(0.123457)',)))
    assert (cirq.circuit_diagram_info(
        d, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('D(0.12)',)))


def test_generalized_amplitude_damping_channel():
    d = cirq.generalized_amplitude_damp(0.1, 0.3)
    np.testing.assert_almost_equal(cirq.channel(d),
              (np.sqrt(0.1) * np.array([[1., 0.], [0., np.sqrt(1.-0.3)]]),
               np.sqrt(0.1) * np.array([[0., np.sqrt(0.3)], [0., 0.]]),
               np.sqrt(0.9) * np.array([[np.sqrt(1. - 0.3), 0.], [0., 1.]]),
               np.sqrt(0.9) * np.array([[0., 0.], [np.sqrt(0.3), 0.]])))
    assert cirq.has_channel(d)
    assert not cirq.has_mixture_channel(d)

def test_generalized_amplitude_damping_repr():
    cirq.testing.assert_equivalent_repr(
        cirq.GeneralizedAmplitudeDampingChannel(0.1, 0.3))

def test_generalized_amplitude_damping_str():
    assert (str(cirq.generalized_amplitude_damp(0.1, 0.3))
            == 'generalized_amplitude_damp(p=0.1,gamma=0.3)')


def test_generalized_amplitude_damping_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.generalized_amplitude_damp(0.0, 0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.generalized_amplitude_damp(0.1, 0.0))
    et.add_equality_group(cirq.generalized_amplitude_damp(0.0, 0.1))
    et.add_equality_group(cirq.generalized_amplitude_damp(0.6, 0.4))
    et.add_equality_group(cirq.generalized_amplitude_damp(0.8, 0.2))


@pytest.mark.parametrize('p, gamma', (
    (-0.1, 0.0),
    (0.0, -0.1),
    (0.1, -0.1),
    (-0.1, 0.1)))
def test_generalized_amplitude_damping_channel_negative_probability(p, gamma):
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.generalized_amplitude_damp(p, gamma)


@pytest.mark.parametrize('p,gamma', (
    (1.1, 0.0),
    (0.0, 1.1),
    (1.1, 1.1)))
def test_generalized_amplitude_damping_channel_bigly_probability(p, gamma):
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.generalized_amplitude_damp(p, gamma)



def test_generalized_amplitude_damping_channel_text_diagram():
    a = cirq.generalized_amplitude_damp(0.1, 0.39558391)
    assert (cirq.circuit_diagram_info(
        a, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('GAD(0.1,0.395584)',)))
    assert (cirq.circuit_diagram_info(
        a, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('GAD(0.1,0.4)',)))


def test_amplitude_damping_channel():
    d = cirq.amplitude_damp(0.3)
    np.testing.assert_almost_equal(cirq.channel(d),
                              (np.array([[1., 0.], [0., np.sqrt(1. - 0.3)]]),
                               np.array([[0., np.sqrt(0.3)], [0., 0.]])))
    assert cirq.has_channel(d)
    assert not cirq.has_mixture_channel(d)


def test_amplitude_damping_channel_repr():
    cirq.testing.assert_equivalent_repr(
        cirq.AmplitudeDampingChannel(0.3))


def test_amplitude_damping_channel_str():
    assert (str(cirq.amplitude_damp(0.3))
            == 'amplitude_damp(gamma=0.3)')


def test_amplitude_damping_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.amplitude_damp(0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.amplitude_damp(0.1))
    et.add_equality_group(cirq.amplitude_damp(0.4))
    et.add_equality_group(cirq.amplitude_damp(0.6))
    et.add_equality_group(cirq.amplitude_damp(0.8))

def test_amplitude_damping_channel_invalid_probability():
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.amplitude_damp(-0.1)
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.amplitude_damp(1.1)


def test_amplitude_damping_channel_text_diagram():
    ad = cirq.amplitude_damp(0.38059322)
    assert (cirq.circuit_diagram_info(
        ad, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('AD(0.380593)',)))
    assert (cirq.circuit_diagram_info(
        ad, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('AD(0.38)',)))


def test_reset_channel():
    r = cirq.reset(cirq.LineQubit(0))
    np.testing.assert_almost_equal(
        cirq.channel(r),
        (np.array([[1., 0.], [0., 0]]), np.array([[0., 1.], [0., 0.]])))
    assert cirq.has_channel(r)
    assert not cirq.has_mixture_channel(r)
    assert cirq.qid_shape(r) == (2,)

    r = cirq.reset(cirq.LineQid(0, dimension=3))
    np.testing.assert_almost_equal(
        cirq.channel(r),
        (np.array([[1, 0, 0], [0, 0, 0], [0, 0, 0]]),
         np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]]),
         np.array([[0, 0, 1], [0, 0, 0], [0, 0, 0]])))  # yapf: disable
    assert cirq.has_channel(r)
    assert not cirq.has_mixture_channel(r)
    assert cirq.qid_shape(r) == (3,)


def test_reset_channel_equality():
    assert cirq.reset(cirq.LineQubit(0)).gate == cirq.ResetChannel()
    assert cirq.reset(cirq.LineQid(0, 3)).gate == cirq.ResetChannel(3)


def test_reset_channel_repr():
    cirq.testing.assert_equivalent_repr(cirq.ResetChannel())
    cirq.testing.assert_equivalent_repr(cirq.ResetChannel(3))


def test_reset_channel_str():
    assert str(cirq.ResetChannel()) == 'reset'
    assert str(cirq.ResetChannel(3)) == 'reset'


def test_reset_channel_text_diagram():
    assert (cirq.circuit_diagram_info(
        cirq.ResetChannel()) == cirq.CircuitDiagramInfo(wire_symbols=('R',)))
    assert (cirq.circuit_diagram_info(
        cirq.ResetChannel(3)) == cirq.CircuitDiagramInfo(wire_symbols=('R',)))


def test_reset_act_on():
    with pytest.raises(TypeError, match="Failed to act"):
        cirq.act_on(cirq.ResetChannel(), object())

    args = cirq.ActOnStateVectorArgs(
        target_tensor=cirq.one_hot(index=(1, 1, 1, 1, 1),
                                   shape=(2, 2, 2, 2, 2),
                                   dtype=np.complex64),
        available_buffer=np.empty(shape=(2, 2, 2, 2, 2)),
        axes=[1],
        prng=np.random.RandomState(),
        log_of_measurement_results={},
    )

    cirq.act_on(cirq.ResetChannel(), args)
    assert args.log_of_measurement_results == {}
    np.testing.assert_allclose(
        args.target_tensor,
        cirq.one_hot(index=(1, 0, 1, 1, 1),
                     shape=(2, 2, 2, 2, 2),
                     dtype=np.complex64))

    cirq.act_on(cirq.ResetChannel(), args)
    assert args.log_of_measurement_results == {}
    np.testing.assert_allclose(
        args.target_tensor,
        cirq.one_hot(index=(1, 0, 1, 1, 1),
                     shape=(2, 2, 2, 2, 2),
                     dtype=np.complex64))


def test_phase_damping_channel():
    d = cirq.phase_damp(0.3)
    np.testing.assert_almost_equal(cirq.channel(d),
                              (np.array([[1.0, 0.], [0., np.sqrt(1 - 0.3)]]),
                               np.array([[0., 0.], [0., np.sqrt(0.3)]])))
    assert cirq.has_channel(d)
    assert not cirq.has_mixture_channel(d)


def test_phase_damping_channel_repr():
    cirq.testing.assert_equivalent_repr(
        cirq.PhaseDampingChannel(0.3))


def test_phase_damping_channel_str():
    assert (str(cirq.phase_damp(0.3))
            == 'phase_damp(gamma=0.3)')


def test_phase_damping_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.phase_damp(0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.phase_damp(0.1))
    et.add_equality_group(cirq.phase_damp(0.4))
    et.add_equality_group(cirq.phase_damp(0.6))
    et.add_equality_group(cirq.phase_damp(0.8))


def test_phase_damping_channel_invalid_probability():
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.phase_damp(-0.1)
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.phase_damp(1.1)


def test_phase_damping_channel_text_diagram():
    pd = cirq.phase_damp(0.1000009)
    assert (cirq.circuit_diagram_info(
        pd, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('PD(0.100001)',)))
    assert (cirq.circuit_diagram_info(
        pd, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('PD(0.1)',)))


def test_phase_flip_channel():
    d = cirq.phase_flip(0.3)
    np.testing.assert_almost_equal(
        cirq.channel(d), (np.sqrt(1. - 0.3) * np.eye(2), np.sqrt(0.3) * Z))
    assert cirq.has_channel(d)


def test_phase_flip_mixture():
    d = cirq.phase_flip(0.3)
    assert_mixtures_equal(cirq.mixture(d), ((0.7, np.eye(2)), (0.3, Z)))
    assert cirq.has_mixture_channel(d)


def test_phase_flip_overload():
    d = cirq.phase_flip()
    d2 = cirq.phase_flip(0.3)
    assert str(d) == 'Z'
    assert str(d2) == 'phase_flip(p=0.3)'

def test_phase_flip_channel_repr():
    cirq.testing.assert_equivalent_repr(
        cirq.PhaseFlipChannel(0.3))


def test_phase_flip_channel_str():
    assert (str(cirq.phase_flip(0.3))
            == 'phase_flip(p=0.3)')


def test_phase_flip_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.phase_flip(0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.phase_flip(0.1))
    et.add_equality_group(cirq.phase_flip(0.4))
    et.add_equality_group(cirq.phase_flip(0.6))
    et.add_equality_group(cirq.phase_flip(0.8))



def test_phase_flip_channel_invalid_probability():
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.phase_flip(-0.1)
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.phase_flip(1.1)


def test_phase_flip_channel_text_diagram():
    pf = cirq.phase_flip(0.987654)
    assert (cirq.circuit_diagram_info(
        pf, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('PF(0.987654)',)))
    assert (cirq.circuit_diagram_info(
        pf, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('PF(0.99)',)))


def test_bit_flip_channel():
    d = cirq.bit_flip(0.3)
    np.testing.assert_almost_equal(
        cirq.channel(d), (np.sqrt(1.0 - 0.3) * np.eye(2), np.sqrt(.3) * X))
    assert cirq.has_channel(d)


def test_bit_flip_mixture():
    d = cirq.bit_flip(0.3)
    assert_mixtures_equal(cirq.mixture(d), ((0.7, np.eye(2)), (0.3, X)))
    assert cirq.has_mixture_channel(d)


def test_bit_flip_overload():
    d = cirq.bit_flip()
    d2 = cirq.bit_flip(0.3)
    assert str(d) == 'X'
    assert str(d2) == 'bit_flip(p=0.3)'


def test_bit_flip_channel_repr():
    cirq.testing.assert_equivalent_repr(
        cirq.BitFlipChannel(0.3))


def test_bit_flip_channel_str():
    assert (str(cirq.bit_flip(0.3))
            == 'bit_flip(p=0.3)')


def test_bit_flip_channel_eq():
    et = cirq.testing.EqualsTester()
    c = cirq.bit_flip(0.0)
    et.make_equality_group(lambda: c)
    et.add_equality_group(cirq.bit_flip(0.1))
    et.add_equality_group(cirq.bit_flip(0.4))
    et.add_equality_group(cirq.bit_flip(0.6))
    et.add_equality_group(cirq.bit_flip(0.8))

def test_bit_flip_channel_invalid_probability():
    with pytest.raises(ValueError, match='was less than 0'):
        cirq.bit_flip(-0.1)
    with pytest.raises(ValueError, match='was greater than 1'):
        cirq.bit_flip(1.1)



def test_bit_flip_channel_text_diagram():
    bf = cirq.bit_flip(0.1234567)
    assert (cirq.circuit_diagram_info(
        bf, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('BF(0.123457)',)))
    assert (cirq.circuit_diagram_info(
        bf, args=round_to_2_prec) == cirq.CircuitDiagramInfo(
            wire_symbols=('BF(0.12)',)))