small unit tests

Author: mpharrigan

qualtran/bloqs/arithmetic/addition_test.py

@@ -449,3 +449,8 @@ def test_controlled_add_from_add():
     assert ctrl == 0
     assert a == 5
     assert b == 15
+
+
+def test_add_k_str():
+    add_k = AddK(QUInt(5), k=3)
+    assert str(add_k) == "AddK(k=3)"

qualtran/bloqs/arithmetic/bitwise_test.py

@@ -184,3 +184,8 @@ def test_bitwisenot_classical_action(dtype, bitsize):
     else:
         valid_range = range(2**bitsize)
     qlt_testing.assert_consistent_classical_action(b, x=valid_range)
+
+
+def test_bitwise_not_str():
+    bloq = BitwiseNot(QUInt(5))
+    assert str(bloq) == "BitwiseNot(5)"

qualtran/bloqs/basic_gates/global_phase_test.py

@@ -77,3 +77,8 @@ def test_t_complexity():
 
 def test_global_phase(bloq_autotester):
     bloq_autotester(_global_phase)
+
+
+def test_global_phase_str():
+    bloq = GlobalPhase(exponent=0.5)
+    assert str(bloq) == "GPhase(0.5)"

qualtran/bloqs/basic_gates/on_each_test.py

@@ -59,3 +59,8 @@ def test_call_graph():
     c1 = x_on_each.bloq_counts(generalizer=ignore_split_join)
     c2 = x_on_each.decompose_bloq().bloq_counts(generalizer=ignore_split_join)
     assert c1 == c2
+
+
+def test_on_each_str():
+    on_each = OnEach(10, XGate())
+    assert str(on_each) == "X(oneach=10)"

qualtran/bloqs/basic_gates/power_test.py

@@ -90,3 +90,42 @@ def to_cirq_circuit(bloq: GateWithRegisters) -> cirq.Circuit:
 @pytest.mark.slow
 def test_no_circular_import():
     subprocess.check_call(['python', '-c', 'from qualtran.bloqs.basic_gates import power'])
+
+
+def test_power_wire_symbol():
+    from qualtran import Signature
+    from qualtran.drawing import LarrowTextBox, RarrowTextBox, Text, TextBox
+
+    class MockBloq(GateWithRegisters):
+        @property
+        def signature(self):
+            return Signature([])
+
+        def wire_symbol(self, reg, idx=tuple()):
+            if reg is None:
+                return Text("Mock")
+            if reg.name == 'a':
+                return Text("A")
+            if reg.name == 'b':
+                return TextBox("B")
+            if reg.name == 'c':
+                return LarrowTextBox("C")
+            if reg.name == 'd':
+                return RarrowTextBox("D")
+
+    bloq = MockBloq()
+    power_bloq = Power(bloq, 3)
+
+    assert power_bloq.wire_symbol(None) == Text("Mock**3")
+
+    from qualtran import QUInt, Register
+
+    reg_a = Register('a', QUInt(1))
+    reg_b = Register('b', QUInt(1))
+    reg_c = Register('c', QUInt(1))
+    reg_d = Register('d', QUInt(1))
+
+    assert power_bloq.wire_symbol(reg_a) == Text("A**3")
+    assert power_bloq.wire_symbol(reg_b) == TextBox("B**3")
+    assert power_bloq.wire_symbol(reg_c) == LarrowTextBox("C**3")
+    assert power_bloq.wire_symbol(reg_d) == RarrowTextBox("D**3")

qualtran/bloqs/basic_gates/rotation_test.py

@@ -33,7 +33,7 @@
     ZGate,
     ZPowGate,
 )
-from qualtran.bloqs.basic_gates.rotation import _crz, _cz_pow, _rx, _ry, _rz, _z_pow, CRz
+from qualtran.bloqs.basic_gates.rotation import _crz, _cz_pow, _rx, _ry, _rz, _z_pow, CRy, CRz
 from qualtran.resource_counting import GateCounts, get_cost_value, QECGatesCost
 from qualtran.resource_counting.classify_bloqs import bloq_is_rotation, bloq_is_t_like
 
@@ -156,6 +156,7 @@ def test_t_like_rotation_gates():
     assert not bloq_is_rotation(Rx(angle))
     assert not bloq_is_rotation(Ry(angle))
     assert not bloq_is_rotation(Rz(angle))
+    assert not bloq_is_rotation(CRy(angle))
     assert bloq_is_t_like(Rx(angle))
     assert bloq_is_t_like(Ry(angle))
     assert bloq_is_t_like(Rz(angle))
@@ -267,6 +268,8 @@ def test_str():
     assert str(CZPowGate(1.0)) == 'CZ(pow=1.0)'
     assert str(CZPowGate(0.9)) == 'CZ(pow=0.9)'
 
+    assert str(CRz(1.0)) == 'CRz(1.0)'
+
 
 def test_rx(bloq_autotester):
     bloq_autotester(_rx)
@@ -278,3 +281,27 @@ def test_ry(bloq_autotester):
 
 def test_rz(bloq_autotester):
     bloq_autotester(_rz)
+
+
+def test_cry():
+    from qualtran.bloqs.basic_gates.rotation import CRy
+
+    rs = np.random.RandomState(52)
+    angle = rs.uniform(0, 2 * np.pi)
+
+    u1 = CRy(angle=angle).tensor_contract()
+    u2 = cirq.unitary(cirq.Ry(rads=angle).controlled())
+    u3 = Controlled(Ry(angle=angle), CtrlSpec()).tensor_contract()
+    np.testing.assert_allclose(u1, u2, atol=1e-8)
+    np.testing.assert_allclose(u1, u3, atol=1e-8)
+
+    ry = Ry(angle=angle)
+    assert ry.controlled() == CRy(angle=angle)
+
+    ctrl_bloq = Controlled(ry.as_composite_bloq(), CtrlSpec()).decompose_bloq()
+    (cry_inst,) = list(ctrl_bloq.bloq_instances)
+    assert cry_inst.bloq == CRy(angle=angle)
+
+    # testing the specialized ctrl
+    ctrl, bloq_with_ctrl = ry.get_ctrl_system(CtrlSpec())
+    assert ctrl == CRy(angle=angle)

qualtran/bloqs/mcmt/multi_control_pauli_test.py

@@ -114,3 +114,13 @@ def test_classical_multi_control_x(cvs, x, ctrls, result):
 @pytest.mark.notebook
 def test_notebook():
     qlt_testing.execute_notebook('multi_control_multi_target_pauli')
+
+
+def test_multi_control_pauli_str():
+    from qualtran.bloqs.mcmt.multi_control_pauli import MultiControlX, MultiControlZ
+
+    mcx = MultiControlX(cvs=(1, 0, 1))
+    assert str(mcx) == "MultiControlX(3)"
+
+    mcz = MultiControlZ(cvs=(1, 1))
+    assert str(mcz) == "MultiControlZ(2)"