increase test cov

Author: refraction-ray

tests/test_circuit.py

@@ -1189,6 +1189,8 @@ def test_qiskit2tc():
     qisc_from_tc = c.to_qiskit(enable_instruction=True)
     qis_unitary2 = qi.Operator(qisc_from_tc)
     qis_unitary2 = np.reshape(qis_unitary2, [2**n, 2**n])
+    # Note: the following assertion may fail intermittently due to non-deterministic behavior
+    # in Qiskit's UnitaryGate.control() method as of Qiskit 0.46.3
     np.testing.assert_allclose(qis_unitary2, qis_unitary, atol=1e-5)
 
 
@@ -1812,3 +1814,25 @@ def test_cirq_gates_translation(backend):
     u_cirq4 = cirq.unitary(c4)
     u_tc4 = c4_tc.matrix()
     assert_allclose_up_to_global_phase(u_cirq4, tc.backend.numpy(u_tc4), atol=1e-5)
+
+
+@pytest.mark.parametrize("backend", [lf("jaxb"), lf("tfb")])
+def test_circuit_extra_coverage(backend):
+    c = tc.Circuit(2)
+    c.h(0)
+    c.cx(0, 1)
+
+    # inverse
+    c1 = c.inverse()
+    assert len(c1.to_qir()) == 2
+
+    # replace_mps_inputs
+    c2 = tc.Circuit(2)
+    c2.replace_mps_inputs(c.quvector())
+
+    # depolarizing2
+    c.depolarizing2(0, px=0.1, py=0.1, pz=0.1)
+
+    # unitary_kraus2
+    kraus = [tc.gates.x(), tc.gates.y()]
+    c.unitary_kraus2(kraus, 0, prob=[0.5, 0.5])

tests/test_miscs.py

@@ -302,3 +302,162 @@ def exp(theta):
         return c.expectation_ps(z=[-3], reuse=False)
 
     assert len(exp(0.3)) == 9
+
+
+@pytest.mark.parametrize("backend", [lf("jaxb"), lf("tfb")])
+def test_parameter_shift_grad(backend):
+    def f(params):
+        c = tc.Circuit(2)
+        c.rx(0, theta=params[0])
+        c.ry(1, theta=params[1])
+        c.cnot(0, 1)
+        return tc.backend.real(c.expectation_ps(z=[0, 1]))
+
+    params = tc.array_to_tensor(np.array([0.1, 0.2]))
+
+    # Standard AD gradient
+    g_ad = tc.backend.grad(f)(params)
+
+    # Parameter shift gradient
+    g_ps = experimental.parameter_shift_grad(f)(params)
+
+    np.testing.assert_allclose(g_ad, g_ps, atol=1e-5)
+
+
+@pytest.mark.parametrize("backend", [lf("jaxb")])
+def test_parameter_shift_grad_v2(backend):
+    # v2 is mainly for jax and supports randomness
+    def f(params):
+        c = tc.Circuit(2)
+        c.rx(0, theta=params[0])
+        c.ry(1, theta=params[1])
+        return tc.backend.real(c.expectation_ps(z=[0]))
+
+    params = tc.array_to_tensor(np.array([0.5, 0.5]))
+    g_ps = experimental.parameter_shift_grad_v2(f)(params)
+    g_ad = tc.backend.grad(f)(params)
+    np.testing.assert_allclose(g_ps, g_ad, atol=1e-5)
+
+
+def test_broadcast_py_object_single_process(jaxb):
+    # In a single process environment, broadcast should just return the object
+    # though it uses jax.experimental.multihost_utils.broadcast_one_to_all
+    obj = {"a": 1, "b": [1, 2, 3]}
+    res = experimental.broadcast_py_object(obj)
+    assert res == obj
+
+
+@pytest.mark.parametrize("backend", [lf("jaxb")])
+def test_jax_jitted_function_save_load_v2(backend, tmp_path):
+    K = tc.backend
+
+    @K.jit
+    def f(x):
+        return x**2 + 1.0
+
+    x = K.ones([2])
+    path = os.path.join(tmp_path, "f.bin")
+    experimental.jax_jitted_function_save(path, f, x)
+
+    f_load = experimental.jax_jitted_function_load(path)
+    np.testing.assert_allclose(f_load(x), f(x), atol=1e-5)
+
+
+@pytest.mark.parametrize("backend", [lf("jaxb"), lf("tfb")])
+def test_qng_options(backend):
+    def f(params):
+        c = tc.Circuit(1)
+        c.rx(0, theta=params[0])
+        return c.state()
+
+    params = tc.backend.ones([1])
+    # test different options in qng to hit more lines
+    qng_fn = experimental.qng(f, mode="fwd")
+    qng_fn(params)
+
+    qng_fn2 = experimental.qng(f, mode="rev")
+    qng_fn2(params)
+
+    qng_fn3 = experimental.qng(f, kernel="dynamics", postprocess=None)
+    qng_fn3(params)
+
+
+@pytest.mark.parametrize("backend", [lf("jaxb"), lf("tfb")])
+def test_qng2_options(backend):
+    def f(params):
+        c = tc.Circuit(1)
+        c.rx(0, theta=params[0])
+        return c.state()
+
+    params = tc.backend.ones([1])
+    qng_fn = experimental.qng2(f, mode="fwd")
+    qng_fn(params)
+
+    qng_fn2 = experimental.qng2(f, mode="rev")
+    qng_fn2(params)
+
+    qng_fn3 = experimental.qng2(f, kernel="dynamics", postprocess=None)
+    qng_fn3(params)
+
+
+def test_vis_extra():
+    c = tc.Circuit(2)
+    c.h(0)
+    c.cx(0, 1)
+    tex = tc.vis.qir2tex(c.to_qir(), 2)
+    assert "\\qw" in tex
+
+    assert tc.vis.gate_name_trans("ccnot") == (2, "not")
+    assert tc.vis.gate_name_trans("h") == (0, "h")
+
+
+def test_cons_extra(jaxb):
+    # set_function_backend
+    @tc.cons.set_function_backend("jax")
+    def f():
+        return tc.backend.name
+
+    # set_function_dtype
+    @tc.cons.set_function_dtype("complex128")
+    def g():
+        return tc.dtypestr
+
+
+def test_ascii_art():
+    # hit some lines in asciiart.py
+
+    try:
+        tc.set_ascii("wrong")
+    except AttributeError:
+        pass
+
+    # lucky() is only available after set_ascii
+    assert not hasattr(tc, "lucky")
+
+
+def test_utils_extra():
+    from tensorcircuit import utils
+
+    # return_partial
+    f = lambda x: [x, x**2, x**3]
+    f1 = utils.return_partial(f, return_argnums=1)
+    assert f1(2) == 4
+    f2 = utils.return_partial(f, return_argnums=[0, 2])
+    assert f2(2) == (2, 8)
+
+    # append
+    f3 = utils.append(lambda x: x**2, lambda x: x + 1)
+    assert f3(2) == 5
+
+    # is_m1mac
+    utils.is_m1mac()
+
+    # is_sequence, is_number
+    assert utils.is_sequence([1])
+    assert utils.is_number(1.0)
+
+    # benchmark
+    def h(x):
+        return x + 1
+
+    utils.benchmark(h, 1.0, tries=2)

tests/test_mpscircuit.py

@@ -372,3 +372,30 @@ def expec(params):
         tc.backend.numpy(exp_grad_dir_jit),
         atol=1e-6,
     )
+
+
+def test_mps_base_extra(jaxb):
+    from tensorcircuit.mps_base import FiniteMPS
+
+    # create a simple MPS
+    n = 4
+    nodes = [
+        tc.backend.ones([1, 2, 2]),
+        tc.backend.ones([2, 2, 2]),
+        tc.backend.ones([2, 2, 2]),
+        tc.backend.ones([2, 2, 1]),
+    ]
+    mps = FiniteMPS(nodes, center_position=0)
+    mps1 = mps.copy()
+    mps2 = mps.conj()
+
+    # measure_local_operator
+    ops = [tc.backend.ones([2, 2])]
+    mps.measure_local_operator(ops, [1])
+
+    # measure_two_body_correlator
+    mps.measure_two_body_correlator(ops[0], ops[0], 0, [1, 2])
+
+    # apply_two_site_gate
+    gate = tc.backend.ones([2, 2, 2, 2])
+    mps.apply_two_site_gate(gate, 1, 2)

tests/test_shadows.py

@@ -158,3 +158,21 @@ def test_ent(backend):
 #
 #     assert np.isclose(expc, pl_expc)
 #     assert np.isclose(ent, pl_ent)
+
+
+def test_shadow_extra(jaxb):
+
+    ps = [1, 2, 3]  # X, Y, Z
+    N, k = shadow_bound(ps, 0.1)
+    assert N > 0
+    assert k > 0
+
+    # test shadow_snapshots with measurement_only and sub
+    c = tc.Circuit(3)
+    c.h(range(3))
+    psi = c.state()
+    ns = 2
+    pauli_strings = tc.backend.convert_to_tensor(np.random.randint(1, 4, size=(ns, 3)))
+
+    snapshots = shadow_snapshots(psi, pauli_strings, measurement_only=True, sub=[0, 1])
+    assert snapshots.shape == (ns, 1, 2)

tests/test_simplify.py

@@ -44,3 +44,25 @@ def test_rank_simplify():
 
     nodes = simplify._full_rank_simplify([f, g, h])
     assert len(nodes) == 2
+
+
+def test_simplify_extra():
+    from tensorcircuit import simplify
+    import tensorcircuit as tc
+
+    a = tn.Node(np.ones([2, 2]), name="a")
+    b = tn.Node(np.ones([2, 2]), name="b")
+    a[1] ^ b[0]
+    nodes = simplify._full_rank_simplify([a, b])
+    assert len(nodes) == 1
+
+    # _full_light_cone_cancel
+    c = tc.Circuit(2)
+    c.h(0)
+    c.cx(0, 1)
+    c.h(0)
+    # usually used in expectation where the psi and its conj can cancel
+    # but we can just call it on any nodes list
+    qir = c.to_qir()
+    nodes = [g["gate"] for g in qir]
+    simplify._full_light_cone_cancel(nodes)