From 0d18f7c6e7820b78e338470cc2ed2045644f127e Mon Sep 17 00:00:00 2001
From: Leo Fang <leof@nvidia.com>
Date: Wed, 12 Jul 2023 14:21:34 -0700
Subject: [PATCH 1/3] sync with internal repo1 (commit b0bf87218)

---
 python/README.md                              |  31 +-
 python/builder/pep517.py                      |   4 +-
 python/builder/utils.py                       |  47 +-
 python/cuquantum/__init__.py                  |   8 +
 python/cuquantum/_version.py                  |   2 +-
 python/cuquantum/custatevec/custatevec.pxd    |  22 +-
 python/cuquantum/custatevec/custatevec.pyx    | 491 ++++++++++-
 .../_internal/circuit_converter_utils.py      |  36 +-
 .../_internal/circuit_parser_utils_qiskit.py  |  23 +-
 .../_internal/decomposition_utils.py          | 101 ++-
 .../cutensornet/_internal/einsum_parser.py    |  11 +-
 python/cuquantum/cutensornet/cutensornet.pxd  |  82 +-
 python/cuquantum/cutensornet/cutensornet.pyx  | 832 +++++++++++++++++-
 .../experimental/tensor_network.py            |  14 +-
 python/cuquantum/cutensornet/tensor.py        |  95 +-
 .../cuquantum/cutensornet/tensor_network.py   |   8 +-
 python/cuquantum/utils.pyx                    |  38 +
 python/samples/custatevec/batched_abs2sum.py  |  52 ++
 python/samples/custatevec/batched_collapse.py |  68 ++
 .../custatevec/batched_gate_application.py    |  78 ++
 python/samples/custatevec/batched_measure.py  |  59 ++
 python/samples/custatevec/initialize_sv.py    |  37 +
 .../approxTN/tensor_svd_example.py            |  22 +-
 .../samples/cutensornet/coarse/example12.py   |   1 +
 .../high_level/marginal_example.py            | 123 +++
 .../high_level/sampling_example.py            | 119 +++
 .../tensor/example11-svd_algorithms.py        |  27 +
 .../tensornet_example_gradients.py            | 342 +++++++
 .../tn_algorithms/mps_algorithms.ipynb        | 413 +++++++--
 python/setup.py                               |  18 +-
 python/tests/cuquantum_tests/__init__.py      |  13 +
 .../custatevec_tests/test_custatevec.py       | 707 +++++++++++----
 .../cutensornet_tests/__init__.py             |   2 +
 .../cutensornet_tests/approxTN_utils.py       |  46 +-
 .../cutensornet_tests/circuit_utils.py        | 405 ++++++++-
 .../cuquantum_tests/cutensornet_tests/data.py |  19 +-
 .../cutensornet_tests/test_cutensornet.py     | 455 ++++++----
 .../cutensornet_tests/test_experimental.py    |  28 +-
 .../cutensornet_tests/test_internal.py        |  23 +
 .../cutensornet_tests/test_options.py         |   2 +-
 .../cutensornet_tests/test_tensor.py          |  71 +-
 .../cutensornet_tests/test_utils.py           |  38 +-
 samples/custatevec/CMakeLists.txt             |  39 +-
 samples/custatevec/Makefile                   |  47 +-
 samples/custatevec/batched_abs2sum.cu         |  82 ++
 samples/custatevec/batched_collapse.cu        | 103 +++
 .../custatevec/batched_gate_application.cu    | 109 +++
 samples/custatevec/batched_measure.cu         |  92 ++
 samples/custatevec/initialize_sv.cu           |  68 ++
 samples/cutensornet/CMakeLists.txt            |  18 +-
 samples/cutensornet/Makefile                  |  33 +-
 samples/cutensornet/README.md                 |  17 +
 .../approxTN/tensor_svd_example.cu            |  26 +-
 .../high_level/marginal_example.cu            | 199 +++++
 .../high_level/sampling_example.cu            | 184 ++++
 samples/cutensornet/tensornet_example.cu      |   2 +-
 .../tensornet_example_gradients.cu            | 540 ++++++++++++
 57 files changed, 5827 insertions(+), 745 deletions(-)
 create mode 100644 python/samples/custatevec/batched_abs2sum.py
 create mode 100644 python/samples/custatevec/batched_collapse.py
 create mode 100644 python/samples/custatevec/batched_gate_application.py
 create mode 100644 python/samples/custatevec/batched_measure.py
 create mode 100644 python/samples/custatevec/initialize_sv.py
 create mode 100755 python/samples/cutensornet/high_level/marginal_example.py
 create mode 100755 python/samples/cutensornet/high_level/sampling_example.py
 create mode 100644 python/samples/cutensornet/tensor/example11-svd_algorithms.py
 create mode 100644 python/samples/cutensornet/tensornet_example_gradients.py
 create mode 100644 samples/custatevec/batched_abs2sum.cu
 create mode 100644 samples/custatevec/batched_collapse.cu
 create mode 100644 samples/custatevec/batched_gate_application.cu
 create mode 100644 samples/custatevec/batched_measure.cu
 create mode 100644 samples/custatevec/initialize_sv.cu
 create mode 100644 samples/cutensornet/high_level/marginal_example.cu
 create mode 100644 samples/cutensornet/high_level/sampling_example.cu
 create mode 100644 samples/cutensornet/tensornet_example_gradients.cu

diff --git a/python/README.md b/python/README.md
index fb5a57e..b40cadf 100644
--- a/python/README.md
+++ b/python/README.md
@@ -13,9 +13,10 @@ If you already have a Conda environment set up, it is the easiest to install cuQ
 ```
 conda install -c conda-forge cuquantum-python
 ```
-The Conda solver will install all required dependencies for you.
-
-**Note**: Currently CUDA 12 support is pending the NVIDIA-led community effort ([conda-forge/staged-recipes#21382](https://github.com/conda-forge/staged-recipes/issues/21382)). Once conda-forge supports CUDA 12 we will make compatible conda packages available.
+The Conda solver will install all required dependencies for you. If you need to select a particular CUDA version, say CUDA 12.0, please issue the following command:
+```
+conda install -c conda-forge cuquantum-python cuda-version=12.0
+```
 
 ### Install cuQuantum Python from PyPI
 
@@ -26,12 +27,12 @@ you can also install cuQuantum Python this way:
 pip install cuquantum-python-cuXX
 ```
 with `XX` being `11` (for CUDA 11) or `12` (for CUDA 12).
-The `pip` solver will also install all dependencies, with the exception of CuPy, for you (including both cuTENSOR and cuQuantum wheels). Please follow
-[CuPy's installation guide](https://docs.cupy.dev/en/stable/install.html).
+The `pip` solver will also install all required dependencies for you (including both cuTENSOR and cuQuantum wheels).
 
 Notes:
 
-- Users can install cuQuantum Python using `pip install cuquantum-python`, which will attempt to detect the current CUDA environment and choose the appropriate wheel to install. In the event of detection failure, CUDA 11 is assumed. This is subject to change in the future. Installing wheels with the `-cuXX` suffix is encouraged.
+- Users can install cuQuantum Python using `pip install --no-cache-dir cuquantum-python`, which will attempt to detect the current CUDA environment and choose the appropriate wheel to install. In the event of detection failure, CUDA 11 is assumed. This is subject to change in the future. Installing wheels with the `-cuXX` suffix is encouraged. `--no-cache-dir` is required when using `pip` 23.1+.
+- CuPy also uses a similar auto-detection mechanism to determine the correct wheel to install. If in doubt, or if installing `cuquantum-python-cu11`, please follow [CuPy's installation guide](https://docs.cupy.dev/en/stable/install.html) and install it manually.
 - To manually manage all Python dependencies, append `--no-deps` to `pip install` to bypass the `pip` solver, see below.
 
 ### Building and installing cuQuantum Python from source
@@ -41,10 +42,10 @@ Notes:
 The build-time dependencies of the cuQuantum Python package include:
 
 * CUDA Toolkit 11.x or 12.x
-* cuStateVec 1.3.0+
-* cuTensorNet 2.1.0+
+* cuStateVec 1.4.0+
+* cuTensorNet 2.2.0+
 * cuTENSOR 1.6.1+
-* Python 3.8+
+* Python 3.9+
 * Cython >=0.29.22,<3
 * pip 21.3.1+
 * [packaging](https://packaging.pypa.io/en/latest/)
@@ -84,12 +85,12 @@ Runtime dependencies of the cuQuantum Python package include:
 * An NVIDIA GPU with compute capability 7.0+
 * Driver: Linux (450.80.02+ for CUDA 11, 525.60.13+ for CUDA 12)
 * CUDA Toolkit 11.x or 12.x
-* cuStateVec 1.3.0+
-* cuTensorNet 2.1.0+
+* cuStateVec 1.4.0+
+* cuTensorNet 2.2.0+
 * cuTENSOR 1.6.1+
-* Python 3.8+
-* NumPy v1.19+
-* CuPy v9.5.0+ (see [installation guide](https://docs.cupy.dev/en/stable/install.html))
+* Python 3.9+
+* NumPy v1.21+
+* CuPy v10.0.0+ (see [installation guide](https://docs.cupy.dev/en/stable/install.html))
 * PyTorch v1.10+ (optional, see [installation guide](https://pytorch.org/get-started/locally/))
 * Qiskit v0.24.0+ (optional, see [installation guide](https://qiskit.org/documentation/getting_started.html))
 * Cirq v0.6.0+ (optional, see [installation guide](https://quantumai.google/cirq/install))
@@ -100,7 +101,7 @@ If you install everything from conda-forge, all the required dependencies are ta
 If you install the pip wheels, CuPy, cuTENSOR and cuQuantum (but not CUDA Toolkit or the driver,
 please make sure the CUDA libraries are visible through your `LD_LIBRARY_PATH`) are installed for you.
 
-If you build cuQuantum Python from source, please make sure the paths to the CUDA, cuQuantum, and cuTENSOR libraries are added
+If you build cuQuantum Python from source, please make sure that the paths to the CUDA, cuQuantum, and cuTENSOR libraries are added
 to your `LD_LIBRARY_PATH` environment variable, and that a compatible CuPy is installed.
 
 Known issues:
diff --git a/python/builder/pep517.py b/python/builder/pep517.py
index 57174b1..66f7c09 100644
--- a/python/builder/pep517.py
+++ b/python/builder/pep517.py
@@ -30,8 +30,8 @@ def get_requires_for_build_wheel(config_settings=None):
     # set up version constraints: note that CalVer like 22.03 is normalized to
     # 22.3 by setuptools, so we must follow the same practice in the constraints;
     # also, we don't need the patch number here
-    cuqnt_require = [f'custatevec-cu{utils.cuda_major_ver}~=1.3',   # ">=1.3.0,<2"
-                     f'cutensornet-cu{utils.cuda_major_ver}~=2.1',  # ">=2.1.0,<3"
+    cuqnt_require = [f'custatevec-cu{utils.cuda_major_ver}~=1.4',   # ">=1.4.0,<2"
+                     f'cutensornet-cu{utils.cuda_major_ver}~=2.2',  # ">=2.2.0,<3"
                     ]
 
     return _build_meta.get_requires_for_build_wheel(config_settings) + cuqnt_require
diff --git a/python/builder/utils.py b/python/builder/utils.py
index fac5607..95f5c8a 100644
--- a/python/builder/utils.py
+++ b/python/builder/utils.py
@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import os
-import platform
 import re
 import site
 import sys
@@ -57,13 +56,10 @@ def check_cuda_version():
 # We support CUDA 11/12 starting 23.03
 cuda_ver = check_cuda_version()
 if cuda_ver == '11.0':
-    cutensor_ver = cuda_ver
     cuda_major_ver = '11'
 elif '11.0' < cuda_ver < '12.0':
-    cutensor_ver = '11'
     cuda_major_ver = '11'
 elif '12.0' <= cuda_ver < '13.0':
-    cutensor_ver = '12'
     cuda_major_ver = '12'
 else:
     raise RuntimeError(f"Unsupported CUDA version: {cuda_ver}")
@@ -79,20 +75,6 @@ def run(self):
         building_wheel = True
         super().run()
 
-    def finalize_options(self):
-        super().finalize_options()
-        self.root_is_pure = False
-
-    def get_tag(self):
-        # hack: passing --build-options in cmdline no longer works with PEP 517 backend,
-        # so we need to overwrite --plat-name here
-        # refs:
-        #   - https://github.com/pypa/build/issues/480
-        #   - https://github.com/scikit-build/ninja-python-distributions/pull/85
-        impl_tag, abi_tag, _ = super().get_tag()
-        plat_tag = f"manylinux2014_{platform.machine()}"
-        return impl_tag, abi_tag, plat_tag
-
 
 class build_ext(_build_ext):
 
@@ -131,28 +113,14 @@ def _set_library_roots(self):
                 else:
                     cutensornet_root = cuquantum_root
 
-        # search order:
-        # 1. installed "cutensor" package
-        # 2. env var
-        for path in py_paths:
-            path = os.path.join(path, 'cutensor')
-            if os.path.isdir(os.path.join(path, 'include')):
-                cutensor_root = path
-                break
-        else:
-            try:
-                cutensor_root = os.environ['CUTENSOR_ROOT']
-            except KeyError as e:
-                raise RuntimeError('cuTENSOR is not found, please set $CUTENSOR_ROOT') from e
-
-        return custatevec_root, cutensornet_root, cutensor_root
+        return custatevec_root, cutensornet_root
 
     def _prep_includes_libs_rpaths(self):
         """
         Set global vars cusv_incl_dir, cutn_incl_dir, cusv_lib_dir, cutn_lib_dir,
         cusv_lib, cutn_lib, and extra_linker_flags.
         """
-        custatevec_root, cutensornet_root, cutensor_root = self._set_library_roots()
+        custatevec_root, cutensornet_root = self._set_library_roots()
 
         global cusv_incl_dir, cutn_incl_dir
         cusv_incl_dir = [os.path.join(cuda_path, 'include'),
@@ -165,22 +133,20 @@ def _prep_includes_libs_rpaths(self):
         cusv_lib_dir = [os.path.join(custatevec_root, 'lib'),
                         os.path.join(custatevec_root, 'lib64')]
         cutn_lib_dir = [os.path.join(cutensornet_root, 'lib'),
-                        os.path.join(cutensornet_root, 'lib64'),
-                        os.path.join(cutensor_root, 'lib'),  # wheel
-                        os.path.join(cutensor_root, 'lib', cutensor_ver)]  # tarball
+                        os.path.join(cutensornet_root, 'lib64')]
 
         global cusv_lib, cutn_lib, extra_linker_flags
         if not building_wheel:
             # Note: with PEP-517 the editable mode would not build a wheel for installation
             # (and we purposely do not support PEP-660).
             cusv_lib = ['custatevec']
-            cutn_lib = ['cutensornet', 'cutensor']
+            cutn_lib = ['cutensornet']
             extra_linker_flags = []
         else:
             # Note: soname = library major version
-            # We don't need to link to cuBLAS/cuSOLVER at build time (TODO: perhaps cuTENSOR too...?)
+            # We don't need to link to cuBLAS/cuSOLVER/cuTensor at build time
             cusv_lib = [':libcustatevec.so.1']
-            cutn_lib = [':libcutensornet.so.2', ':libcutensor.so.1']
+            cutn_lib = [':libcutensornet.so.2']
             # The rpaths must be adjusted given the following full-wheel installation:
             # - cuquantum-python: site-packages/cuquantum/{custatevec, cutensornet}/  [=$ORIGIN]
             # - cusv & cutn:      site-packages/cuquantum/lib/
@@ -201,7 +167,6 @@ def _prep_includes_libs_rpaths(self):
         print("CUDA path:", cuda_path)
         print("cuStateVec path:", custatevec_root)
         print("cuTensorNet path:", cutensornet_root)
-        print("cuTENSOR path:", cutensor_root)
         print("*"*80+"\n")
 
     def build_extension(self, ext):
diff --git a/python/cuquantum/__init__.py b/python/cuquantum/__init__.py
index fb9ef70..3c9acbc 100644
--- a/python/cuquantum/__init__.py
+++ b/python/cuquantum/__init__.py
@@ -16,9 +16,14 @@
         custatevec.Pauli,
         custatevec.MatrixLayout,
         custatevec.MatrixType,
+        custatevec.MatrixMapType,
         custatevec.Collapse,
         custatevec.SamplerOutput,
         custatevec.DeviceNetworkType,
+        cutensornet.NetworkAttribute,
+        custatevec.CommunicatorType,
+        custatevec.DataTransferType,
+        custatevec.StateVectorType,
         cutensornet.ContractionOptimizerInfoAttribute,
         cutensornet.ContractionOptimizerConfigAttribute,
         cutensornet.ContractionAutotunePreferenceAttribute,
@@ -32,6 +37,9 @@
         cutensornet.TensorSVDPartition,
         cutensornet.TensorSVDInfoAttribute,
         cutensornet.GateSplitAlgo,
+        cutensornet.StatePurity,
+        cutensornet.MarginalAttribute,
+        cutensornet.SamplerAttribute,
         ):
     cutensornet._internal.enum_utils.add_enum_class_doc(enum, chomp="_ATTRIBUTE|_PREFERENCE_ATTRIBUTE")
 
diff --git a/python/cuquantum/_version.py b/python/cuquantum/_version.py
index 872e436..19b2289 100644
--- a/python/cuquantum/_version.py
+++ b/python/cuquantum/_version.py
@@ -5,4 +5,4 @@
 # Note: cuQuantum Python follows the cuQuantum SDK version, which is now
 # switched to YY.MM and is different from individual libraries' (semantic)
 # versioning scheme.
-__version__ = '23.03.0'
+__version__ = '23.06.0'
diff --git a/python/cuquantum/custatevec/custatevec.pxd b/python/cuquantum/custatevec/custatevec.pxd
index 5975a88..c654a5a 100644
--- a/python/cuquantum/custatevec/custatevec.pxd
+++ b/python/cuquantum/custatevec/custatevec.pxd
@@ -14,6 +14,14 @@ from cuquantum.utils cimport (DataType, DeviceAllocType, DeviceFreeType, int2,
 
 
 cdef extern from '<custatevec.h>' nogil:
+    # cuStateVec consts
+    const int CUSTATEVEC_VER_MAJOR
+    const int CUSTATEVEC_VER_MINOR
+    const int CUSTATEVEC_VER_PATCH
+    const int CUSTATEVEC_VERSION
+    const int CUSTATEVEC_ALLOCATOR_NAME_LEN
+    const int CUSTATEVEC_MAX_SEGMENT_MASK_SIZE
+
     # cuStateVec types
     ctypedef void* _Handle 'custatevecHandle_t'
     ctypedef int64_t _Index 'custatevecIndex_t'
@@ -24,10 +32,7 @@ cdef extern from '<custatevec.h>' nogil:
         void* ctx
         DeviceAllocType device_alloc
         DeviceFreeType device_free
-
-        # Cython limitation: cannot use C defines in declaring a static array,
-        # so we just have to hard-code CUSTATEVEC_ALLOCATOR_NAME_LEN here...
-        char name[64]
+        char name[CUSTATEVEC_ALLOCATOR_NAME_LEN]
     ctypedef void(*LoggerCallbackData 'custatevecLoggerCallbackData_t')(
         int32_t logLevel,
         const char* functionName,
@@ -69,6 +74,10 @@ cdef extern from '<custatevec.h>' nogil:
         CUSTATEVEC_MATRIX_TYPE_UNITARY
         CUSTATEVEC_MATRIX_TYPE_HERMITIAN
 
+    ctypedef enum _MatrixMapType 'custatevecMatrixMapType_t':
+        CUSTATEVEC_MATRIX_MAP_TYPE_BROADCAST
+        CUSTATEVEC_MATRIX_MAP_TYPE_MATRIX_INDEXED
+
     ctypedef enum _CollapseOp 'custatevecCollapseOp_t':
         CUSTATEVEC_COLLAPSE_NONE
         CUSTATEVEC_COLLAPSE_NORMALIZE_AND_ZERO
@@ -92,6 +101,11 @@ cdef extern from '<custatevec.h>' nogil:
         CUSTATEVEC_DATA_TRANSFER_TYPE_RECV
         CUSTATEVEC_DATA_TRANSFER_TYPE_SEND_RECV
 
+    ctypedef enum _StateVectorType 'custatevecStateVectorType_t':
+        CUSTATEVEC_STATE_VECTOR_TYPE_ZERO
+        CUSTATEVEC_STATE_VECTOR_TYPE_UNIFORM
+        CUSTATEVEC_STATE_VECTOR_TYPE_GHZ
+        CUSTATEVEC_STATE_VECTOR_TYPE_W
 
     # cuStateVec consts
     int CUSTATEVEC_VER_MAJOR
diff --git a/python/cuquantum/custatevec/custatevec.pyx b/python/cuquantum/custatevec/custatevec.pyx
index 502776a..86fca61 100644
--- a/python/cuquantum/custatevec/custatevec.pyx
+++ b/python/cuquantum/custatevec/custatevec.pyx
@@ -46,18 +46,32 @@ cdef extern from * nogil:
     int custatevecAbs2SumArray(
         _Handle, const void*, DataType, const uint32_t, double*, const int32_t*,
         const uint32_t, const int32_t*, const int32_t*, const uint32_t)
+    int custatevecAbs2SumArrayBatched(
+        _Handle, const void*, DataType, const uint32_t, const uint32_t,
+        const _Index, double*, const _Index, const int32_t*,
+        const uint32_t, const _Index*, const int32_t*, const uint32_t)
     int custatevecCollapseOnZBasis(
         _Handle, void*, DataType, const uint32_t, const int32_t, const int32_t*,
         const uint32_t, double)
     int custatevecCollapseByBitString(
         _Handle, void*, DataType, const uint32_t, const int32_t*, const int32_t*,
         const uint32_t, double)
+    int custatevecCollapseByBitStringBatchedGetWorkspaceSize(
+        _Handle, const uint32_t, const _Index*, const double*, size_t*)
+    int custatevecCollapseByBitStringBatched(
+        _Handle, void*, DataType, const uint32_t, const uint32_t,
+        const _Index, const _Index*, const int32_t*, const uint32_t,
+        const double*, void*, size_t)
     int custatevecMeasureOnZBasis(
         _Handle, void*, DataType, const uint32_t, int32_t*, const int32_t*,
         const uint32_t, const double, _CollapseOp)
     int custatevecBatchMeasure(
         _Handle, void*, DataType, const uint32_t, int32_t*, const int32_t*,
         const uint32_t, const double, _CollapseOp)
+    int custatevecMeasureBatched(
+        _Handle, void*, DataType, const uint32_t, const uint32_t, const _Index,
+        _Index*, const int32_t*, const uint32_t,
+        const double*, _CollapseOp)
     int custatevecBatchMeasureWithOffset(
         _Handle, void*, DataType, const uint32_t, int32_t*, const int32_t*,
         const uint32_t, const double, _CollapseOp, const double, const double)
@@ -74,6 +88,17 @@ cdef extern from * nogil:
         DataType, _MatrixLayout, const int32_t, const int32_t*,
         const uint32_t, const int32_t*, const int32_t*, const uint32_t,
         _ComputeType, void*, size_t)
+    int custatevecApplyMatrixBatchedGetWorkspaceSize(
+        _Handle, DataType, const uint32_t, const uint32_t, const _Index,
+        _MatrixMapType, const int32_t*, const void*, DataType,
+        _MatrixLayout, const int32_t, const uint32_t, const uint32_t,
+        const uint32_t, _ComputeType, size_t*)
+    int custatevecApplyMatrixBatched(
+        _Handle, void*, DataType, const uint32_t, const uint32_t, _Index,
+        _MatrixMapType, const int32_t*, const void*, DataType,
+        _MatrixLayout, const int32_t, const uint32_t, const int32_t*,
+        const uint32_t, const int32_t*, const int32_t*, const uint32_t,
+        _ComputeType, void*, size_t)
     int custatevecComputeExpectationGetWorkspaceSize(
         _Handle, DataType, const uint32_t, const void*, DataType, _MatrixLayout,
         const uint32_t, _ComputeType, size_t*)
@@ -132,6 +157,8 @@ cdef extern from * nogil:
     int custatevecTestMatrixType(
         _Handle, double*, _MatrixType, const void*, DataType, _MatrixLayout,
         const uint32_t, const int32_t, _ComputeType, void*, size_t)
+    int custatevecInitializeStateVector(
+        _Handle, void*, DataType, const uint32_t, _StateVectorType)
     int custatevecGetDeviceMemHandler(_Handle, _DeviceMemHandler*)
     int custatevecSetDeviceMemHandler(_Handle, const _DeviceMemHandler*)
 
@@ -418,7 +445,6 @@ cpdef abs2sum_array(
 
         mask_len (uint32_t): The length of ``mask_ordering``.
 
-
     .. seealso:: `custatevecAbs2SumArray`
     """
     # bit_ordering can be a pointer address, or a Python sequence
@@ -456,6 +482,85 @@ cpdef abs2sum_array(
     check_status(status)
 
 
+cpdef abs2sum_array_batched(
+        intptr_t handle, intptr_t batched_svs, int sv_data_type, uint32_t
+        n_index_bits, uint32_t n_svs, _Index sv_stride,
+        intptr_t abs2sum, _Index abs2sum_stride,
+        bit_ordering, uint32_t bit_ordering_len,
+        mask_bit_string, mask_ordering, uint32_t mask_len):
+    """Calculates the batched sum of squared absolute values for a given set of
+    index bits.
+
+    Args:
+        handle (intptr_t): The library handle.
+        batched_svs (intptr_t): The pointer address (as Python :class:`int`) to
+            the batched statevectors (on device).
+        sv_data_type (cuquantum.cudaDataType): The data type of the statevector.
+        n_index_bits (uint32_t): The number of index bits.
+        n_svs (uint32_t): The number of batched statevectors.
+        sv_stride (int64_t): The stride between each state vector in the batch.
+        abs2sum (intptr_t): The pointer address (as Python :class:`int`) to the
+            array (on either host or device) that would hold the sums.
+        abs2sum_stride (int64_t): The stride between each ``abs2sum`` array in
+            the batch.
+        bit_ordering: A host array of index bit ordering. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of index bit ordering
+
+        bit_ordering_len (uint32_t): The length of ``bit_ordering``.
+        mask_bit_string: An array for specifying mask values. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of mask values on host
+
+        mask_ordering: A host array of mask ordering. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of index bit ordering
+
+        mask_len (uint32_t): The length of ``mask_ordering``.
+
+    .. seealso:: `custatevecAbs2SumArrayBatched`
+    """
+    # bit_ordering can be a pointer address, or a Python sequence
+    cdef vector[int32_t] bitOrderingData
+    cdef int32_t* bitOrderingPtr
+    if cpython.PySequence_Check(bit_ordering):
+        bitOrderingData = bit_ordering
+        bitOrderingPtr = bitOrderingData.data()
+    else:  # a pointer address
+        bitOrderingPtr = <int32_t*><intptr_t>bit_ordering
+
+    # mask_bit_string can be a pointer address, or a Python sequence
+    cdef vector[_Index] maskBitStringData
+    cdef _Index* maskBitStringPtr
+    if cpython.PySequence_Check(mask_bit_string):
+        maskBitStringData = mask_bit_string
+        maskBitStringPtr = maskBitStringData.data()
+    else:  # a pointer address
+        maskBitStringPtr = <_Index*><intptr_t>mask_bit_string
+
+    # mask_ordering can be a pointer address, or a Python sequence
+    cdef vector[int32_t] maskOrderingData
+    cdef int32_t* maskOrderingPtr
+    if cpython.PySequence_Check(mask_ordering):
+        maskOrderingData = mask_ordering
+        maskOrderingPtr = maskOrderingData.data()
+    else:  # a pointer address
+        maskOrderingPtr = <int32_t*><intptr_t>mask_ordering
+
+    with nogil:
+        status = custatevecAbs2SumArrayBatched(
+            <_Handle>handle, <void*>batched_svs, <DataType>sv_data_type,
+            n_index_bits, n_svs, sv_stride,
+            <double*>abs2sum, abs2sum_stride,
+            bitOrderingPtr, bit_ordering_len,
+            maskBitStringPtr, maskOrderingPtr, mask_len)
+    check_status(status)
+
+
 cpdef collapse_on_z_basis(
         intptr_t handle, intptr_t sv, int sv_data_type, uint32_t n_index_bits,
         int32_t parity, basis_bits, uint32_t n_basis_bits, double norm):
@@ -548,6 +653,134 @@ cpdef collapse_by_bitstring(
     check_status(status)
 
 
+cpdef size_t collapse_by_bitstring_batched_get_workspace_size(
+        intptr_t handle, uint32_t n_svs, bit_strings, norms) except*:
+    """Computes the required workspace size for
+    :func:`collapse_by_bitstring_batched`.
+
+    Args:
+        handle (intptr_t): The library handle.
+        n_svs (uint32_t): The number of batched statevectors.
+        bit_strings: An array of bit strings. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of bits on host
+
+        norms: An array of normalization factors for the statevectors after
+            collapse. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of normalization factors on host
+
+    .. seealso:: `custatevecCollapseByBitStringBatchedGetWorkspaceSize`
+    """
+    # bit_strings can be a pointer address, or a Python sequence
+    cdef vector[_Index] bitStringsData
+    cdef _Index* bitStringsPtr
+    if cpython.PySequence_Check(bit_strings):
+        bitStringsData = bit_strings
+        bitStringsPtr = bitStringsData.data()
+    else:  # a pointer address
+        bitStringsPtr = <_Index*><intptr_t>bit_strings
+
+    # norms can be a pointer address, or a Python sequence
+    cdef vector[double] normsData
+    cdef double* normsPtr
+    if cpython.PySequence_Check(norms):
+        normsData = norms
+        normsPtr = normsData.data()
+    else:  # a pointer address
+        normsPtr = <double*><intptr_t>norms
+
+    cdef size_t workspace_size
+    with nogil:
+        status = custatevecCollapseByBitStringBatchedGetWorkspaceSize(
+            <_Handle>handle, n_svs, bitStringsPtr, normsPtr, &workspace_size)
+    check_status(status)
+
+    return workspace_size
+
+
+cpdef collapse_by_bitstring_batched(
+        intptr_t handle, intptr_t batched_svs, int sv_data_type, 
+        uint32_t n_index_bits, uint32_t n_svs, _Index sv_stride,
+        bit_strings, bit_ordering, uint32_t bit_string_len, norms,
+        intptr_t workspace, size_t workspace_size):
+    """Collapse the batched statevectors to the states specified by the given
+    bit strings.
+
+    Args:
+        handle (intptr_t): The library handle.
+        batched_svs (intptr_t): The pointer address (as Python :class:`int`) to
+            the batched statevectors (on device).
+        sv_data_type (cuquantum.cudaDataType): The data type of the
+            statevectors.
+        n_index_bits (uint32_t): The number of index bits.
+        n_svs (uint32_t): The number of batched statevectors.
+        sv_stride (int64_t): The stride between each state vector in the batch.
+        bit_strings: An array of bit strings. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of bits on host
+
+        bit_ordering: A host array of bit string ordering. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of bit ordering
+
+        bit_string_len (uint32_t): The length of individual ``bit_string``.
+        norms: An array of normalization factors for the statevectors after
+            collapse. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of normalization factors on host
+
+        workspace (intptr_t): The pointer address (as Python :class:`int`) to the
+            workspace (on device).
+        workspace_size (size_t): The workspace size (in bytes).
+
+    .. seealso:: `custatevecCollapseByBitStringBatched`
+    """
+    # bit_strings can be a pointer address, or a Python sequence
+    cdef vector[_Index] bitStringsData
+    cdef _Index* bitStringsPtr
+    if cpython.PySequence_Check(bit_strings):
+        bitStringsData = bit_strings
+        bitStringsPtr = bitStringsData.data()
+    else:  # a pointer address
+        bitStringsPtr = <_Index*><intptr_t>bit_strings
+
+    # bit_ordering can be a pointer address, or a Python sequence
+    cdef vector[int32_t] bitOrderingData
+    cdef int32_t* bitOrderingPtr
+    if cpython.PySequence_Check(bit_ordering):
+        bitOrderingData = bit_ordering
+        bitOrderingPtr = bitOrderingData.data()
+    else:  # a pointer address
+        bitOrderingPtr = <int32_t*><intptr_t>bit_ordering
+
+    # norms can be a pointer address, or a Python sequence
+    cdef vector[double] normsData
+    cdef double* normsPtr
+    if cpython.PySequence_Check(norms):
+        normsData = norms
+        normsPtr = normsData.data()
+    else:  # a pointer address
+        normsPtr = <double*><intptr_t>norms
+
+    with nogil:
+        status = custatevecCollapseByBitStringBatched(
+            <_Handle>handle, <void*>batched_svs, <DataType>sv_data_type,
+            n_index_bits, n_svs, sv_stride,
+            bitStringsPtr, bitOrderingPtr, bit_string_len, normsPtr,
+            <void*>workspace, workspace_size)
+    check_status(status)
+
+
 cpdef int measure_on_z_basis(
         intptr_t handle, intptr_t sv, int sv_data_type, uint32_t n_index_bits,
         basis_bits, const uint32_t n_basis_bits, double rand_num,
@@ -635,6 +868,66 @@ cpdef batch_measure(
     check_status(status)
 
 
+cpdef measure_batched(
+        intptr_t handle, intptr_t batched_svs, int sv_data_type,
+        uint32_t n_index_bits, uint32_t n_svs, int64_t sv_stride,
+        intptr_t bit_strings, bit_ordering, const uint32_t bit_string_len,
+        rand_nums, int collapse):
+    """Performs measurement of a batched of statevectors.
+
+    Args:
+        handle (intptr_t): The library handle.
+        batched_svs (intptr_t): The pointer address (as Python :class:`int`) to
+            the batched statevectors (on device).
+        sv_data_type (cuquantum.cudaDataType): The data type of the statevector.
+        n_index_bits (uint32_t): The number of index bits.
+        n_svs (uint32_t): The number of batched statevectors.
+        sv_stride (int64_t): The stride between each state vector in the batch.
+        bit_strings (intptr_t): The pointer address (as Python :class:`int`) to
+            a host or device array of measured bit strings.
+        bit_ordering: A host array of bit string ordering. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of bit ordering
+
+        bit_string_len (uint32_t): The length of ``bit_string``.
+        rand_nums (double): An array of random numbers in [0, 1). It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of random numbers
+
+        collapse (Collapse): Indicate the collapse operation.
+
+    .. seealso:: `custatevecMeasureBatched`
+    """
+    # bit_ordering can be a pointer address, or a Python sequence
+    cdef vector[int32_t] bitOrderingData
+    cdef int32_t* bitOrderingPtr
+    if cpython.PySequence_Check(bit_ordering):
+        bitOrderingData = bit_ordering
+        bitOrderingPtr = bitOrderingData.data()
+    else:  # a pointer address
+        bitOrderingPtr = <int32_t*><intptr_t>bit_ordering
+
+    # rand_nums can be a pointer address, or a Python sequence
+    cdef vector[double] randNumsData
+    cdef double* randNumsPtr
+    if cpython.PySequence_Check(rand_nums):
+        randNumsData = rand_nums
+        randNumsPtr = randNumsData.data()
+    else:  # a pointer address
+        randNumsPtr = <double*><intptr_t>rand_nums
+
+    with nogil:
+        status = custatevecMeasureBatched(
+            <_Handle>handle, <void*>batched_svs, <DataType>sv_data_type,
+            n_index_bits, n_svs, sv_stride,
+            <_Index*>bit_strings, bitOrderingPtr, bit_string_len,
+            randNumsPtr, <_CollapseOp>collapse)
+    check_status(status)
+
+
 cpdef batch_measure_with_offset(
         intptr_t handle, intptr_t sv, int sv_data_type,
         uint32_t n_index_bits, intptr_t bit_string, bit_ordering,
@@ -882,6 +1175,171 @@ cpdef apply_matrix(
     check_status(status)
 
 
+cpdef size_t apply_matrix_batched_get_workspace_size(
+        intptr_t handle, int sv_data_type, uint32_t n_index_bits,
+        uint32_t n_svs, _Index sv_stride,
+        int map_type, matrix_indices, intptr_t matrices, int matrix_data_type,
+        int layout, int32_t adjoint, uint32_t n_matrices,
+        uint32_t n_targets, uint32_t n_controls, int compute_type) except*:
+    """Computes the required workspace size for :func:`apply_matrix_batched`.
+
+    Args:
+        handle (intptr_t): The library handle.
+        sv_data_type (cuquantum.cudaDataType): The data type of the statevector.
+        n_index_bits (uint32_t): The number of index bits.
+        n_svs (uint32_t): The number of batched statevectors.
+        sv_stride (int64_t): The stride between each state vector in the batch.
+        map_type (MatrixMapType): Specify the way to assign matrices.
+        matrix_indices: An array of matrix indices to indicate, in order, which
+            matrix is to be applied to the statevectors in the batch. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of bits on host
+
+        matrices (intptr_t): The pointer address (as Python :class:`int`) to the
+            matrices (on either host or device).
+        matrix_data_type (cuquantum.cudaDataType): The data type of the matrix.
+        layout (MatrixLayout): The memory layout the the matrix.
+        adjoint (int32_t): Whether the adjoint of the matrix would be applied.
+        n_matrices (uint32_t): The number of matrices.
+        n_targets (uint32_t): The length of ``targets``.
+        n_controls (uint32_t): The length of ``controls``.
+        compute_type (cuquantum.ComputeType): The compute type of matrix
+            multiplication.
+
+    Returns:
+        size_t: The required workspace size (in bytes).
+
+    .. seealso:: `custatevecApplyMatrixBatchedGetWorkspaceSize`
+    """
+    # matrix_indices can be a pointer address, or a Python sequence
+    cdef vector[int32_t] matrixIndicesData
+    cdef int32_t* matrixIndicesPtr
+    if cpython.PySequence_Check(matrix_indices):
+        matrixIndicesData = matrix_indices
+        matrixIndicesPtr = matrixIndicesData.data()
+    else:  # a pointer address
+        matrixIndicesPtr = <int32_t*><intptr_t>matrix_indices
+
+    cdef size_t extraWorkspaceSizeInBytes
+    with nogil:
+        status = custatevecApplyMatrixBatchedGetWorkspaceSize(
+            <_Handle>handle, <DataType>sv_data_type, n_index_bits,
+            n_svs, sv_stride, <_MatrixMapType>map_type,
+            matrixIndicesPtr, <void*>matrices, <DataType>matrix_data_type,
+            <_MatrixLayout>layout, adjoint, n_matrices,
+            n_targets, n_controls, <_ComputeType>compute_type,
+            &extraWorkspaceSizeInBytes)
+    check_status(status)
+    return extraWorkspaceSizeInBytes
+
+
+cpdef apply_matrix_batched(
+        intptr_t handle, intptr_t batched_svs, int sv_data_type,
+        uint32_t n_index_bits, uint32_t n_svs, _Index sv_stride,
+        int map_type, matrix_indices, intptr_t matrices, int matrix_data_type,
+        int layout, int32_t adjoint, uint32_t n_matrices,
+        targets, uint32_t n_targets,
+        controls, control_bit_values, uint32_t n_controls,
+        int compute_type, intptr_t workspace, size_t workspace_size):
+    """Apply the specified gate matrices to the batched statevectors.
+
+    Args:
+        handle (intptr_t): The library handle.
+        batched_svs (intptr_t): The pointer address (as Python :class:`int`) to
+            the batched statevectors (on device).
+        sv_data_type (cuquantum.cudaDataType): The data type of the statevectors.
+        n_index_bits (uint32_t): The number of index bits.
+        n_svs (uint32_t): The number of batched statevectors.
+        sv_stride (int64_t): The stride between each state vector in the batch.
+        map_type (MatrixMapType): Specify the way to assign matrices.
+        matrix_indices: An array of matrix indices to indicate, in order, which
+            matrix is to be applied to the statevectors in the batch. It can be
+
+            - an :class:`int` as the pointer address to the array (on host or
+              device)
+            - a Python sequence of bits on host
+
+        matrices (intptr_t): The pointer address (as Python :class:`int`) to the
+            matrices (on either host or device).
+        matrix_data_type (cuquantum.cudaDataType): The data type of the matrix.
+        layout (MatrixLayout): The memory layout the the matrix.
+        adjoint (int32_t): Whether the adjoint of the matrix would be applied.
+        n_matrices (uint32_t): The number of matrices.
+        targets: A host array of target bits. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of target bits
+
+        n_targets (uint32_t): The length of ``targets``.
+        controls: A host array of control bits. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of control bits
+
+        control_bit_values: A host array of control bit values. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of control bit values
+
+        n_controls (uint32_t): The length of ``controls``.
+        compute_type (cuquantum.ComputeType): The compute type of matrix
+            multiplication.
+        workspace (intptr_t): The pointer address (as Python :class:`int`) to the
+            workspace (on device).
+        workspace_size (size_t): The workspace size (in bytes).
+
+    .. seealso:: `custatevecApplyMatrixBatched`
+    """
+    # matrix_indices can be a pointer address, or a Python sequence
+    cdef vector[int32_t] matrixIndicesData
+    cdef int32_t* matrixIndicesPtr
+    if cpython.PySequence_Check(matrix_indices):
+        matrixIndicesData = matrix_indices
+        matrixIndicesPtr = matrixIndicesData.data()
+    else:  # a pointer address
+        matrixIndicesPtr = <int32_t*><intptr_t>matrix_indices
+
+    # targets can be a pointer address, or a Python sequence
+    cdef vector[int32_t] targetsData
+    cdef int32_t* targetsPtr
+    if cpython.PySequence_Check(targets):
+        targetsData = targets
+        targetsPtr = targetsData.data()
+    else:  # a pointer address
+        targetsPtr = <int32_t*><intptr_t>targets
+
+    # controls can be a pointer address, or a Python sequence
+    cdef vector[int32_t] controlsData
+    cdef int32_t* controlsPtr
+    if cpython.PySequence_Check(controls):
+        controlsData = controls
+        controlsPtr = controlsData.data()
+    else:  # a pointer address
+        controlsPtr = <int32_t*><intptr_t>controls
+
+    # control_bit_values can be a pointer address, or a Python sequence
+    cdef vector[int32_t] controlBitValuesData
+    cdef int32_t* controlBitValuesPtr
+    if cpython.PySequence_Check(control_bit_values):
+        controlBitValuesData = control_bit_values
+        controlBitValuesPtr = controlBitValuesData.data()
+    else:  # a pointer address
+        controlBitValuesPtr = <int32_t*><intptr_t>control_bit_values
+
+    with nogil:
+        status = custatevecApplyMatrixBatched(
+            <_Handle>handle, <void*>batched_svs, <DataType>sv_data_type,
+            n_index_bits, n_svs, sv_stride, <_MatrixMapType>map_type,
+            matrixIndicesPtr, <void*>matrices, <DataType>matrix_data_type,
+            <_MatrixLayout>layout, adjoint, n_matrices,
+            targetsPtr, n_targets,
+            controlsPtr, controlBitValuesPtr, n_controls,
+            <_ComputeType>compute_type, <void*>workspace, workspace_size)
+    check_status(status)
+
+
 cpdef size_t compute_expectation_get_workspace_size(
         intptr_t handle, int sv_data_type, uint32_t n_index_bits, intptr_t matrix,
         int matrix_data_type, int layout, uint32_t n_basis_bits, int compute_type) except*:
@@ -1908,6 +2366,26 @@ cpdef double test_matrix_type(
     return residualNorm
 
 
+cpdef initialize_state_vector(
+        intptr_t handle, intptr_t sv, int sv_data_type, uint32_t n_index_bits,
+        int sv_type):
+    """Initialize the state vector.
+
+    Args:
+        handle (intptr_t): The library handle.
+        sv (intptr_t): The pointer address (as Python :class:`int`) to the
+            statevector (on device).
+        sv_data_type (cuquantum.cudaDataType): The data type of the statevector.
+        n_index_bits (uint32_t): The number of index bits.
+        sv_type (StateVectorType): The target quantum state.
+    """
+    with nogil:
+        status = custatevecInitializeStateVector(
+            <_Handle>handle, <void*>sv, <DataType>sv_data_type, n_index_bits,
+            <_StateVectorType>sv_type)
+    check_status(status)
+
+
 cpdef set_device_mem_handler(intptr_t handle, handler):
     """ Set the device memory handler for cuTensorNet.
 
@@ -2709,6 +3187,11 @@ class MatrixType(IntEnum):
     UNITARY = CUSTATEVEC_MATRIX_TYPE_UNITARY
     HERMITIAN = CUSTATEVEC_MATRIX_TYPE_HERMITIAN
 
+class MatrixMapType(IntEnum):
+    """See `custatevecMatrixMapType_t`."""
+    BROADCAST = CUSTATEVEC_MATRIX_MAP_TYPE_BROADCAST
+    MATRIX_INDEXED = CUSTATEVEC_MATRIX_MAP_TYPE_MATRIX_INDEXED
+
 class Collapse(IntEnum):
     """See `custatevecCollapseOp_t`."""
     NONE = CUSTATEVEC_COLLAPSE_NONE
@@ -2737,6 +3220,12 @@ class DataTransferType(IntEnum):
     RECV = CUSTATEVEC_DATA_TRANSFER_TYPE_RECV
     SEND_RECV = CUSTATEVEC_DATA_TRANSFER_TYPE_SEND_RECV
 
+class StateVectorType(IntEnum):
+    """See `custatevecStateVectorType_t`."""
+    ZERO = CUSTATEVEC_STATE_VECTOR_TYPE_ZERO
+    UNIFORM = CUSTATEVEC_STATE_VECTOR_TYPE_UNIFORM
+    GHZ = CUSTATEVEC_STATE_VECTOR_TYPE_GHZ
+    W = CUSTATEVEC_STATE_VECTOR_TYPE_W
 
 del IntEnum
 
diff --git a/python/cuquantum/cutensornet/_internal/circuit_converter_utils.py b/python/cuquantum/cutensornet/_internal/circuit_converter_utils.py
index 26bd8ea..6f30798 100644
--- a/python/cuquantum/cutensornet/_internal/circuit_converter_utils.py
+++ b/python/cuquantum/cutensornet/_internal/circuit_converter_utils.py
@@ -2,12 +2,15 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import types
+
 try:
     import cirq
     from . import circuit_parser_utils_cirq
 except ImportError:
     cirq = circuit_parser_utils_cirq = None
 import cupy as cp
+import numpy as np
 try:
     import qiskit
     from . import circuit_parser_utils_qiskit
@@ -15,15 +18,18 @@
     qiskit = circuit_parser_utils_qiskit = None
 
 from .tensor_wrapper import _get_backend_asarray_func
+from ...utils import WHITESPACE_UNICODE
+
 
 EINSUM_SYMBOLS_BASE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+WHITESPACE_SYMBOLS_ID = None
 
 CIRQ_MIN_VERSION = '0.6.0'
-QISKIT_MIN_VERSION = '0.24.0' # qiskit metapackage version
+QISKIT_MIN_VERSION = '0.24.0'  # qiskit metapackage version
 
-import types
 EMPTY_DICT = types.MappingProxyType({})
 
+
 def check_version(package_name, version, minimum_version):
     """
     Check if the current version of a package is above the required minimum.
@@ -35,15 +41,35 @@ def check_version(package_name, version, minimum_version):
                                   f'current version: {version}')
     return None
 
+
 def _get_symbol(i):
     """
-    Return a Unicode as label for index.
+    Return a unicode as label for index. Whitespace unicode characters are skipped.
 
-    .. note:: This function is adopted from `opt_einsum <https://optimized-einsum.readthedocs.io/en/stable/_modules/opt_einsum/parser.html#get_symbol>`_
+    This function can offer 1113955 (= sys.maxunicode - 140 - 16) unique symbols.
     """
     if i < 52:
         return EINSUM_SYMBOLS_BASE[i]
-    return chr(i + 140)
+
+    global WHITESPACE_SYMBOLS_ID
+    if WHITESPACE_SYMBOLS_ID is None:
+        whitespace = WHITESPACE_UNICODE
+        WHITESPACE_SYMBOLS_ID = np.asarray([ord(c) for c in whitespace], dtype=np.int32)
+        WHITESPACE_SYMBOLS_ID = WHITESPACE_SYMBOLS_ID[WHITESPACE_SYMBOLS_ID >= 192]
+
+    # leave "holes" in the integer -> unicode mapping to avoid using whitespaces as symbols
+    i += 140
+    offset = 0
+    for hole in WHITESPACE_SYMBOLS_ID:  # loop size = 16
+        if i + offset < hole:
+            break
+        offset += 1
+
+    try:
+        return chr(i + offset)
+    except ValueError as e:
+        raise ValueError(f"{i=} would exceed unicode limit") from e
+
 
 def infer_parser(circuit):
     """
diff --git a/python/cuquantum/cutensornet/_internal/circuit_parser_utils_qiskit.py b/python/cuquantum/cutensornet/_internal/circuit_parser_utils_qiskit.py
index c0c7f56..c2e4837 100644
--- a/python/cuquantum/cutensornet/_internal/circuit_parser_utils_qiskit.py
+++ b/python/cuquantum/cutensornet/_internal/circuit_parser_utils_qiskit.py
@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import cupy as cp
+import numpy as np
 from qiskit import QuantumCircuit
 from qiskit.circuit import Barrier, ControlledGate, Delay, Gate, Measure
 from qiskit.extensions import UnitaryGate
@@ -26,13 +27,14 @@ def get_inverse_circuit(circuit):
     """
     return circuit.inverse()
 
-def get_decomposed_gates(circuit, qubit_map=None, gates=None, gate_process_func=None):
+def get_decomposed_gates(circuit, qubit_map=None, gates=None, gate_process_func=None, global_phase=0):
     """
     Return the gate sequence for the given circuit. Compound gates/instructions will be decomposed 
     to either standard gates or customized unitary gates.
     """
     if gates is None:
         gates = []
+    global_phase += circuit.global_phase
     for operation, gate_qubits, _ in circuit:
         if qubit_map:
             gate_qubits = [qubit_map[q] for q in gate_qubits]
@@ -52,8 +54,8 @@ def get_decomposed_gates(circuit, qubit_map=None, gates=None, gate_process_func=
                 raise ValueError(f'operation type {type(operation)} not supported')
         # for composite gate, must provide a map from the sub circuit to the original circuit
         next_qubit_map = dict(zip(operation.definition.qubits, gate_qubits))
-        gates = get_decomposed_gates(operation.definition, qubit_map=next_qubit_map, gates=gates, gate_process_func=gate_process_func)
-    return gates
+        gates, global_phase = get_decomposed_gates(operation.definition, qubit_map=next_qubit_map, gates=gates, gate_process_func=gate_process_func, global_phase=global_phase)
+    return gates, global_phase
 
 def unfold_circuit(circuit, dtype='complex128', backend=cp):
     """
@@ -75,12 +77,14 @@ def unfold_circuit(circuit, dtype='complex128', backend=cp):
     def gate_process_func(operation, gate_qubits):
         tensor = operation.to_matrix().reshape((2,2)*len(gate_qubits))
         tensor = asarray(tensor, dtype=dtype)
-        if isinstance(operation, ControlledGate):
-            # in qiskit notation, qubit at high index is the target qubit
-            gate_qubits = gate_qubits[::-1]
-        return tensor, gate_qubits
+        # in qiskit notation, qubits are labelled in the inverse order
+        return tensor, gate_qubits[::-1]
     
-    gates = get_decomposed_gates(circuit, gate_process_func=gate_process_func)
+    gates, global_phase = get_decomposed_gates(circuit, gate_process_func=gate_process_func, global_phase=0)
+    if global_phase != 0:
+        phase = np.exp(1j*global_phase)
+        phase_gate = asarray([[phase, 0], [0, phase]], dtype=dtype)
+        gates = [(phase_gate, qubits[:1]), ] + gates
 
     return qubits, gates
 
@@ -96,7 +100,7 @@ def get_lightcone_circuit(circuit, coned_qubits):
         A :class:`qiskit.QuantumCircuit` object that potentially contains less number of gates
     """
     coned_qubits = set(coned_qubits)
-    gates = get_decomposed_gates(circuit)
+    gates, global_phase = get_decomposed_gates(circuit)
     newqc = QuantumCircuit(circuit.qubits)
     ix = len(gates)
     tail_operations = []
@@ -109,4 +113,5 @@ def get_lightcone_circuit(circuit, coned_qubits):
             coned_qubits |= qubit_set
     for operation, gate_qubits in gates[:ix] + tail_operations[::-1]:
         newqc.append(operation, gate_qubits)
+    newqc.global_phase = global_phase
     return newqc
diff --git a/python/cuquantum/cutensornet/_internal/decomposition_utils.py b/python/cuquantum/cutensornet/_internal/decomposition_utils.py
index 7ada989..56c911f 100644
--- a/python/cuquantum/cutensornet/_internal/decomposition_utils.py
+++ b/python/cuquantum/cutensornet/_internal/decomposition_utils.py
@@ -33,14 +33,23 @@
                     'L2': cutn.TensorSVDNormalization.L2,
                     'LInf': cutn.TensorSVDNormalization.LINF}
 
+SVD_ALGORITHM_MAP = {'gesvd': cutn.TensorSVDAlgo.GESVD,
+                     'gesvdj': cutn.TensorSVDAlgo.GESVDJ,
+                     'gesvdp': cutn.TensorSVDAlgo.GESVDP,
+                     'gesvdr': cutn.TensorSVDAlgo.GESVDR}
+
+SVD_ALGORITHM_MAP_TO_STRING = dict((val, key) for key, val in SVD_ALGORITHM_MAP.items())
+
 SVD_METHOD_CONFIG_MAP = {'abs_cutoff': cutn.TensorSVDConfigAttribute.ABS_CUTOFF,
                         'rel_cutoff': cutn.TensorSVDConfigAttribute.REL_CUTOFF, 
                         'partition': cutn.TensorSVDConfigAttribute.S_PARTITION, 
-                        'normalization': cutn.TensorSVDConfigAttribute.S_NORMALIZATION}
+                        'normalization': cutn.TensorSVDConfigAttribute.S_NORMALIZATION,
+                        'algorithm': cutn.TensorSVDConfigAttribute.ALGO}
 
 SVD_INFO_MAP = {'full_extent': cutn.TensorSVDInfoAttribute.FULL_EXTENT,
                 'reduced_extent': cutn.TensorSVDInfoAttribute.REDUCED_EXTENT,
-                'discarded_weight': cutn.TensorSVDInfoAttribute.DISCARDED_WEIGHT}
+                'discarded_weight': cutn.TensorSVDInfoAttribute.DISCARDED_WEIGHT,
+                'algorithm': cutn.TensorSVDInfoAttribute.ALGO}
 
 
 def compute_combined_size(size_dict, modes):
@@ -202,32 +211,44 @@ def parse_decomposition(subscripts, *operands):
     return operands, inputs, outputs, size_dict, mode_map_user_to_ord, mode_map_ord_to_user, mid_extent
 
 
-def get_svd_config_info_scalar_attr(handle, obj_type, obj, attr):
+def get_svd_config_info_scalar_attr(handle, obj_type, obj, attr, svd_algorithm=None):
     """
     Get the data for given attribute of SVDConfig or SVDInfo.
     """
     if obj_type == 'config':
-        dtype_getter = cutn.tensor_svd_config_get_attribute_dtype
+        if attr != cutn.TensorSVDConfigAttribute.ALGO_PARAMS:
+            dtype = cutn.tensor_svd_config_get_attribute_dtype(attr)
+        else:
+            if svd_algorithm not in (cutn.TensorSVDAlgo.GESVDJ, cutn.TensorSVDAlgo.GESVDR):
+                return None
+            dtype = cutn.tensor_svd_algo_params_get_dtype(svd_algorithm)
         getter = cutn.tensor_svd_config_get_attribute
     elif obj_type == 'info':
-        dtype_getter = cutn.tensor_svd_info_get_attribute_dtype
+        if attr != cutn.TensorSVDInfoAttribute.ALGO_STATUS:
+            dtype = cutn.tensor_svd_info_get_attribute_dtype(attr)
+        else:
+            if svd_algorithm not in (cutn.TensorSVDAlgo.GESVDJ, cutn.TensorSVDAlgo.GESVDP):
+                return None
+            dtype = cutn.tensor_svd_algo_status_get_dtype(svd_algorithm)
         getter = cutn.tensor_svd_info_get_attribute
     else:
         raise ValueError("object type must be either config or info")
-
-    dtype = dtype_getter(attr)
     data = numpy.empty((1,), dtype=dtype)
     getter(handle, obj, attr, data.ctypes.data, data.dtype.itemsize)
     return data
 
 
-def set_svd_config_scalar_attr(handle, obj, attr, data):
+def set_svd_config_scalar_attr(handle, obj, attr, data, svd_algorithm=None):
     """
     Set the data for given attribute of SVDConfig.
     """
-    dtype_getter = cutn.tensor_svd_config_get_attribute_dtype
     setter = cutn.tensor_svd_config_set_attribute
-    dtype = dtype_getter(attr)
+    if attr != cutn.TensorSVDConfigAttribute.ALGO_PARAMS:
+        dtype = cutn.tensor_svd_config_get_attribute_dtype(attr)
+    else:
+        if svd_algorithm not in (cutn.TensorSVDAlgo.GESVDJ, cutn.TensorSVDAlgo.GESVDR):
+            raise ValueError(f"Algorithm specific parameters not supported for {svd_algorithm}")
+        dtype = cutn.tensor_svd_algo_params_get_dtype(svd_algorithm)
     if not isinstance(data, numpy.ndarray):
         data = numpy.asarray(data, dtype=dtype)
     setter(handle, obj, attr, data.ctypes.data, data.dtype.itemsize)
@@ -237,16 +258,24 @@ def parse_svd_config(handle, svd_config, svd_method, logger=None):
     """
     Given an SVDMethod object, set the corresponding attributes in the SVDConfig.
     """
+    svd_algorithm = None
     for method_attr, attr in SVD_METHOD_CONFIG_MAP.items():
         data = getattr(svd_method, method_attr)
         if method_attr == 'partition':
             data = PARTITION_MAP[data]
         elif method_attr == 'normalization':
             data = NORMALIZATION_MAP[data]
+        elif method_attr == 'algorithm':
+            svd_algorithm = data = SVD_ALGORITHM_MAP[data]
         set_svd_config_scalar_attr(handle, svd_config, attr, data)
         if logger is not None:
             logger.info(f"The SVDConfig attribute '{method_attr}' has been set to {data}.")
 
+    algo_params = svd_method._get_algo_params()
+    if algo_params is not None:
+        set_svd_config_scalar_attr(handle, svd_config, cutn.TensorSVDConfigAttribute.ALGO_PARAMS, algo_params, svd_algorithm=svd_algorithm)
+        if logger is not None:
+            logger.info(f"The SVDConfig attribute '{cutn.TensorSVDConfigAttribute.ALGO_PARAMS}' has been set to {algo_params}.")
 
 def get_svd_info_dict(handle, svd_info):
     """
@@ -255,6 +284,13 @@ def get_svd_info_dict(handle, svd_info):
     info = dict()
     for key, attr in SVD_INFO_MAP.items():
         info[key] = get_svd_config_info_scalar_attr(handle, 'info', svd_info, attr).item()
+    svd_algorithm = info['algorithm']
+    algo_status = get_svd_config_info_scalar_attr(handle, 'info', svd_info, cutn.TensorSVDInfoAttribute.ALGO_STATUS, svd_algorithm=svd_algorithm)
+    info['algorithm'] = SVD_ALGORITHM_MAP_TO_STRING[svd_algorithm]
+    if algo_status is not None:
+        for name in algo_status.dtype.names:
+            key = info['algorithm'] + f'_{name}'
+            info[key] = algo_status[name].item()
     return info
 
 
@@ -282,8 +318,6 @@ def parse_decompose_operands_options(options, wrapped_operands, allowed_dtype_na
         with utils.device_ctx(device_id):
             handle = cutn.create()
     
-    blocking = options.blocking is True or operands_location == 'cpu'
-
     dtype_name = utils.get_operands_dtype(wrapped_operands)
     if allowed_dtype_names is not None and dtype_name not in allowed_dtype_names:
         raise ValueError(f"dtype {dtype_name} not supported")
@@ -295,7 +329,7 @@ def parse_decompose_operands_options(options, wrapped_operands, allowed_dtype_na
     internal_options = options.__class__(device_id=device_id,
                                         logger=logger,
                                         handle=handle,
-                                        blocking=blocking,
+                                        blocking=options.blocking,
                                         compute_type=compute_type,
                                         memory_limit=options.memory_limit,
                                         allocator=allocator)
@@ -309,22 +343,31 @@ def allocate_and_set_workspace(handle, allocator, workspace_desc, pref, mem_spac
     """
     workspace_size = cutn.workspace_get_memory_size(handle, workspace_desc, pref, mem_space, workspace_kind)
     # Allocate and set workspace
-    with utils.device_ctx(device_id), stream_ctx:
-        try:
-            logger.debug(f"Allocating memory for {task_name}")
-            workspace_ptr = allocator.memalloc(workspace_size)
-        except TypeError as e:
-            message = "The method 'memalloc' in the allocator object must conform to the interface in the "\
-                    "'BaseCUDAMemoryManager' protocol."
-            raise TypeError(message) from e
-    
-    logger.debug(f"Finished allocating memory of size {formatters.MemoryStr(workspace_size)} for decomposition in the context of stream {stream}.")
-
-    device_ptr = utils.get_ptr_from_memory_pointer(workspace_ptr)
-    cutn.workspace_set_memory(handle, workspace_desc, mem_space, workspace_kind, device_ptr, workspace_size)
-    logger.debug(f"The workspace memory (device pointer = {device_ptr}) has been set in the workspace descriptor.")
-
-    return workspace_ptr
+    if mem_space == cutn.Memspace.DEVICE:
+        with utils.device_ctx(device_id), stream_ctx:
+            try:
+                logger.debug(f"Allocating device memory for {task_name}")
+                workspace_ptr = allocator.memalloc(workspace_size)
+            except TypeError as e:
+                message = "The method 'memalloc' in the allocator object must conform to the interface in the "\
+                        "'BaseCUDAMemoryManager' protocol."
+                raise TypeError(message) from e
+        
+        logger.debug(f"Finished allocating device memory of size {formatters.MemoryStr(workspace_size)} for decomposition in the context of stream {stream}.")
+        device_ptr = utils.get_ptr_from_memory_pointer(workspace_ptr)
+        cutn.workspace_set_memory(handle, workspace_desc, mem_space, workspace_kind, device_ptr, workspace_size)
+        logger.debug(f"The workspace memory (device pointer = {device_ptr}) has been set in the workspace descriptor.")
+        return workspace_ptr
+    elif workspace_size != 0:
+        # host workspace
+        logger.debug(f"Allocating host memory for {task_name}")
+        workspace_host = numpy.empty(workspace_size, dtype=numpy.int8)
+        logger.debug(f"Finished allocating host memory of size {formatters.MemoryStr(workspace_size)} for decomposition.")
+        cutn.workspace_set_memory(handle, workspace_desc, mem_space, workspace_kind, workspace_host.ctypes.data, workspace_size)
+        logger.debug(f"The workspace memory (host pointer = {workspace_host.ctypes.data}) has been set in the workspace descriptor.")
+        return workspace_host
+    else:
+        return None
 
 
 def _destroy_tensor_descriptors(desc_tensors):
diff --git a/python/cuquantum/cutensornet/_internal/einsum_parser.py b/python/cuquantum/cutensornet/_internal/einsum_parser.py
index f3c04a5..44da696 100644
--- a/python/cuquantum/cutensornet/_internal/einsum_parser.py
+++ b/python/cuquantum/cutensornet/_internal/einsum_parser.py
@@ -8,17 +8,20 @@
 
 from collections import Counter
 from itertools import chain
-import string
+import re
+import sys
 
 import numpy as np
 
 from . import formatters
 from .tensor_wrapper import wrap_operands
+from ...utils import WHITESPACE_UNICODE
 
 
 DISALLOWED_LABELS = set(['.', '-', '>'])
 native_to_str = lambda native : "'" + ''.join(s if s is not Ellipsis else '...' for s in native) + "'"
 
+
 def select_morpher(interleaved, mapper=None):
     """
     Select appropriate function for mode label representation based on string or interleaved format.
@@ -48,7 +51,8 @@ def parse_single(single):
     """
     Parse single operand mode labels considering ellipsis. Leading or trailing whitespace, if present, is removed.
     """
-    subexpr = single.strip(string.whitespace).split('...')
+    whitespace = WHITESPACE_UNICODE
+    subexpr = single.strip(whitespace).split('...')
     n = len(subexpr)
     expr = [[Ellipsis]] * (2*n - 1)
     expr[::2] = subexpr
@@ -60,10 +64,11 @@ def check_single(single):
     """
     Check for disallowed characters used as mode labels for a single operand.
     """
+    whitespace = WHITESPACE_UNICODE
     for s in single:
         if s is Ellipsis:
             continue
-        if s in string.whitespace or s in DISALLOWED_LABELS:
+        if s in whitespace or s in DISALLOWED_LABELS:
             return False
 
     return True
diff --git a/python/cuquantum/cutensornet/cutensornet.pxd b/python/cuquantum/cutensornet/cutensornet.pxd
index 3bf3f69..3a21b92 100644
--- a/python/cuquantum/cutensornet/cutensornet.pxd
+++ b/python/cuquantum/cutensornet/cutensornet.pxd
@@ -13,6 +13,13 @@ from cuquantum.utils cimport DataType, DeviceAllocType, DeviceFreeType, Stream
 
 
 cdef extern from '<cutensornet.h>' nogil:
+    # cuTensorNet consts
+    const int CUTENSORNET_MAJOR
+    const int CUTENSORNET_MINOR
+    const int CUTENSORNET_PATCH
+    const int CUTENSORNET_VERSION
+    const int CUTENSORNET_ALLOCATOR_NAME_LEN
+
     # cuTensorNet types
     ctypedef void* _Handle 'cutensornetHandle_t'
     ctypedef int _Status 'cutensornetStatus_t'
@@ -26,6 +33,9 @@ cdef extern from '<cutensornet.h>' nogil:
     ctypedef void* _TensorDescriptor 'cutensornetTensorDescriptor_t'
     ctypedef void* _TensorSVDConfig 'cutensornetTensorSVDConfig_t'
     ctypedef void* _TensorSVDInfo 'cutensornetTensorSVDInfo_t'
+    ctypedef void* _State 'cutensornetState_t'
+    ctypedef void* _StateMarginal 'cutensornetStateMarginal_t'
+    ctypedef void* _StateSampler 'cutensornetStateSampler_t'
 
     # cuTensorNet structs
     ctypedef struct _NodePair 'cutensornetNodePair_t':
@@ -48,14 +58,34 @@ cdef extern from '<cutensornet.h>' nogil:
         void* ctx
         DeviceAllocType device_alloc
         DeviceFreeType device_free
-        # Cython limitation: cannot use C defines in declaring a static array,
-        # so we just have to hard-code CUTENSORNET_ALLOCATOR_NAME_LEN here...
-        char name[64]
+        char name[CUTENSORNET_ALLOCATOR_NAME_LEN]
 
     ctypedef struct _TensorQualifiers 'cutensornetTensorQualifiers_t':
-        int32_t isConjugate # cannot assign default value to fields in cdef structs
-        int32_t isConstant # cannot assign default value to fields in cdef structs
-        
+        # cannot assign default value to fields in cdef structs
+        int32_t isConjugate
+        int32_t isConstant
+        int32_t requiresGradient
+
+    ctypedef struct _TensorIDList 'cutensornetTensorIDList_t':
+        int32_t numTensors
+        int32_t* data
+
+    ctypedef struct _GesvdjParams 'cutensornetGesvdjParams_t':
+        double tol
+        int64_t maxSweeps
+
+    ctypedef struct _GesvdrParams 'cutensornetGesvdrParams_t':
+        int64_t oversampling
+        int64_t niters
+    
+    ctypedef struct _GesvdjStatus 'cutensornetGesvdjStatus_t':
+        double residual
+        int64_t sweeps
+    
+    ctypedef struct _GesvdpStatus 'cutensornetGesvdpStatus_t':
+        double errSigma
+
+    # cuTensorNet function pointers
     ctypedef void(*LoggerCallbackData 'cutensornetLoggerCallbackData_t')(
         int32_t logLevel,
         const char* functionName,
@@ -79,6 +109,10 @@ cdef extern from '<cutensornet.h>' nogil:
         CUTENSORNET_OPTIMIZER_COST_TIME
         CUTENSORNET_OPTIMIZER_COST_TIME_TUNED
 
+    ctypedef enum _SmartOption 'cutensornetSmartOption_t':
+        CUTENSORNET_SMART_OPTION_DISABLED
+        CUTENSORNET_SMART_OPTION_ENABLED
+
     ctypedef enum _ContractionOptimizerConfigAttribute 'cutensornetContractionOptimizerConfigAttributes_t':
         CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_GRAPH_NUM_PARTITIONS
         CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_GRAPH_CUTOFF_SIZE
@@ -98,6 +132,8 @@ cdef extern from '<cutensornet.h>' nogil:
         CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SIMPLIFICATION_DISABLE_DR
         CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SEED
         CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_COST_FUNCTION_OBJECTIVE
+        CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_CACHE_REUSE_NRUNS
+        CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SMART_OPTION
 
     ctypedef enum _ContractionOptimizerInfoAttribute 'cutensornetContractionOptimizerInfoAttributes_t':
         CUTENSORNET_CONTRACTION_OPTIMIZER_INFO_NUM_SLICES
@@ -137,6 +173,14 @@ cdef extern from '<cutensornet.h>' nogil:
         CUTENSORNET_TENSOR_SVD_CONFIG_REL_CUTOFF
         CUTENSORNET_TENSOR_SVD_CONFIG_S_NORMALIZATION
         CUTENSORNET_TENSOR_SVD_CONFIG_S_PARTITION
+        CUTENSORNET_TENSOR_SVD_CONFIG_ALGO
+        CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS
+    
+    ctypedef enum _TensorSVDAlgo 'cutensornetTensorSVDAlgo_t':
+        CUTENSORNET_TENSOR_SVD_ALGO_GESVD
+        CUTENSORNET_TENSOR_SVD_ALGO_GESVDJ
+        CUTENSORNET_TENSOR_SVD_ALGO_GESVDP
+        CUTENSORNET_TENSOR_SVD_ALGO_GESVDR
 
     ctypedef enum _TensorSVDNormalization 'cutensornetTensorSVDNormalization_t':
         CUTENSORNET_TENSOR_SVD_NORMALIZATION_NONE
@@ -154,14 +198,26 @@ cdef extern from '<cutensornet.h>' nogil:
         CUTENSORNET_TENSOR_SVD_INFO_FULL_EXTENT
         CUTENSORNET_TENSOR_SVD_INFO_REDUCED_EXTENT
         CUTENSORNET_TENSOR_SVD_INFO_DISCARDED_WEIGHT
+        CUTENSORNET_TENSOR_SVD_INFO_ALGO
+        CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS
 
     ctypedef enum _GateSplitAlgo 'cutensornetGateSplitAlgo_t':
         CUTENSORNET_GATE_SPLIT_ALGO_DIRECT
         CUTENSORNET_GATE_SPLIT_ALGO_REDUCED
-
-    # cuTensorNet consts
-    int CUTENSORNET_MAJOR
-    int CUTENSORNET_MINOR
-    int CUTENSORNET_PATCH
-    int CUTENSORNET_VERSION
-    int CUTENSORNET_ALLOCATOR_NAME_LEN
+    
+    ctypedef enum _StatePurity 'cutensornetStatePurity_t':
+        CUTENSORNET_STATE_PURITY_PURE
+    
+    ctypedef enum _MarginalAttribute 'cutensornetMarginalAttributes_t':
+        CUTENSORNET_MARGINAL_OPT_NUM_HYPER_SAMPLES
+    
+    ctypedef enum _SamplerAttribute 'cutensornetSamplerAttributes_t':
+        CUTENSORNET_SAMPLER_OPT_NUM_HYPER_SAMPLES
+
+    ctypedef enum _NetworkAttribute 'cutensornetNetworkAttributes_t':
+        CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_CONSTANT
+        CUTENSORNET_NETWORK_INPUT_TENSORS_CONSTANT
+        CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_CONJUGATED
+        CUTENSORNET_NETWORK_INPUT_TENSORS_CONJUGATED
+        CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_REQUIRE_GRAD
+        CUTENSORNET_NETWORK_INPUT_TENSORS_REQUIRE_GRAD
diff --git a/python/cuquantum/cutensornet/cutensornet.pyx b/python/cuquantum/cutensornet/cutensornet.pyx
index f9b93a3..a5d0c09 100644
--- a/python/cuquantum/cutensornet/cutensornet.pyx
+++ b/python/cuquantum/cutensornet/cutensornet.pyx
@@ -38,6 +38,10 @@ cdef extern from * nogil:
         int32_t, const int64_t[], const int64_t[], const int32_t[],
         DataType, _ComputeType, _NetworkDescriptor*)
     int cutensornetDestroyNetworkDescriptor(_NetworkDescriptor)
+    int cutensornetNetworkGetAttribute(
+        _Handle, _NetworkDescriptor, _NetworkAttribute, void*, size_t)
+    int cutensornetNetworkSetAttribute(
+        _Handle, _NetworkDescriptor, _NetworkAttribute, void*, size_t)
     int cutensornetGetOutputTensorDetails(
         const _Handle, const _NetworkDescriptor,
         int32_t*, size_t*, int32_t*, int64_t*, int64_t*)
@@ -68,15 +72,15 @@ cdef extern from * nogil:
         void* const, uint64_t)
     int cutensornetWorkspaceSetMemory(
         const _Handle, _WorkspaceDescriptor, _Memspace,
-        _WorkspaceKind,
-        void* const, int64_t)
+        _WorkspaceKind, void* const, int64_t)
     int cutensornetWorkspaceGet(
         const _Handle, const _WorkspaceDescriptor, _Memspace,
         void**, uint64_t*)
     int cutensornetWorkspaceGetMemory(
         const _Handle, const _WorkspaceDescriptor, _Memspace,
-        _WorkspaceKind,
-        void**, int64_t*)
+        _WorkspaceKind, void**, int64_t*)
+    int cutensornetWorkspacePurgeCache(
+        _Handle, _WorkspaceDescriptor, _Memspace)
     int cutensornetDestroyWorkspaceDescriptor(_WorkspaceDescriptor)
 
     # optimizer info
@@ -224,6 +228,47 @@ cdef extern from * nogil:
     int cutensornetDistributedGetProcRank(_Handle, int*)
     int cutensornetDistributedSynchronize(_Handle)
 
+    # gradients
+    int cutensornetComputeGradientsBackward(
+        const _Handle, _ContractionPlan, const void* const[],
+        void*, void* const[], int32_t, _WorkspaceDescriptor, Stream)
+
+    # high level API
+    # state preparation
+    int cutensornetCreateState(
+        const _Handle, _StatePurity, int32_t, const int64_t*, 
+        DataType, _State*)
+    int cutensornetDestroyState(_State)
+    int cutensornetStateApplyTensor(
+        const _Handle, _State, int32_t, const int32_t*, void*, 
+        const int64_t*, const int32_t, const int32_t, const int32_t, int64_t*)
+    int cutensornetStateUpdateTensor(
+        const _Handle, _State, int64_t, void*, int32_t)
+    
+    # marginals
+    int cutensornetCreateMarginal(
+        const _Handle, _State, int32_t, const int32_t*,
+        int32_t, const int32_t*, const int64_t*, _StateMarginal*)
+    int cutensornetMarginalConfigure(
+        const _Handle, _StateMarginal, _MarginalAttribute, const void*, size_t)
+    int cutensornetMarginalPrepare(
+        const _Handle, _StateMarginal, size_t, _WorkspaceDescriptor, Stream)
+    int cutensornetMarginalCompute(
+        const _Handle, _StateMarginal, const int64_t*, _WorkspaceDescriptor, void*, Stream)
+    int cutensornetDestroyMarginal(_StateMarginal)
+
+    # sampling
+    int cutensornetCreateSampler(
+        const _Handle, _State, int32_t, const int32_t*, _StateSampler*)
+    int cutensornetSamplerConfigure(
+        const _Handle, _StateSampler, _SamplerAttribute, const void*, size_t)
+    int cutensornetSamplerPrepare(
+        const _Handle, _StateSampler, size_t, _WorkspaceDescriptor, Stream)
+    int cutensornetSamplerSample(
+        const _Handle, _StateSampler, int64_t,
+        _WorkspaceDescriptor, int64_t*, Stream)
+    int cutensornetDestroySampler(_StateSampler)
+
 
 class cuTensorNetError(RuntimeError):
     def __init__(self, status):
@@ -519,6 +564,93 @@ cpdef destroy_network_descriptor(intptr_t tn_desc):
     check_status(status)
 
 
+######################### Python specific utility #########################
+
+tensor_id_list_dtype = _numpy.dtype(
+    {'names':['num_tensors','data'],
+     'formats': (_numpy.int32, _numpy.intp),
+     'itemsize': sizeof(_TensorIDList),
+    }, align=True
+)
+
+cdef dict network_sizes = {
+    CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_CONSTANT: _numpy.int32,
+    CUTENSORNET_NETWORK_INPUT_TENSORS_CONSTANT: tensor_id_list_dtype,
+    CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_CONJUGATED: _numpy.int32,
+    CUTENSORNET_NETWORK_INPUT_TENSORS_CONJUGATED: tensor_id_list_dtype,
+    CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_REQUIRE_GRAD: _numpy.int32,
+    CUTENSORNET_NETWORK_INPUT_TENSORS_REQUIRE_GRAD: tensor_id_list_dtype,
+}
+
+cpdef network_get_attribute_dtype(int attr):
+    """Get the Python data type of the corresponding network descriptor
+    attribute.
+
+    Args:
+        attr (NetworkAttribute): The attribute to query.
+
+    Returns:
+        The data type of the queried attribute.
+
+    .. note:: This API has no C counterpart and is a convenient helper for
+        allocating memory for :func:`network_get_attribute` and
+        :func:`network_set_attribute`.
+    """
+    return network_sizes[attr]
+
+###########################################################################
+
+
+cpdef network_get_attribute(
+        intptr_t handle, intptr_t tn_desc, int attr,
+        intptr_t buf, size_t size):
+    """Get the network descriptor attribute.
+
+    Args:
+        handle (intptr_t): The library handle.
+        tn_desc (intptr_t): The tensor network descriptor.
+        attr (NetworkAttribute): The attribute to query.
+        buf (intptr_t): The pointer address (as Python :class:`int`) for storing
+            the returned attribute value.
+        size (size_t): The size of ``buf`` (in bytes).
+
+    .. note:: To compute ``size``, use the itemsize of the corresponding data
+        type, which can be queried using :func:`network_get_attribute_dtype`.
+
+    .. seealso:: `cutensornetNetworkGetAttribute`
+    """
+    with nogil:
+        status = cutensornetNetworkGetAttribute(
+            <_Handle>handle, <_NetworkDescriptor>tn_desc,
+            <_NetworkAttribute>attr, <void*>buf, size)
+    check_status(status)
+
+
+cpdef network_set_attribute(
+        intptr_t handle, intptr_t tn_desc, int attr,
+        intptr_t buf, size_t size):
+    """Set the network descriptor attribute.
+
+    Args:
+        handle (intptr_t): The library handle.
+        tn_desc (intptr_t): The tensor network descriptor.
+        attr (NetworkAttribute): The attribute to set.
+        buf (intptr_t): The pointer address (as Python :class:`int`) to the
+            attribute data.
+        size (size_t): The size of ``buf`` (in bytes).
+
+    .. note:: To compute ``size``, use the itemsize of the corresponding data
+        type, which can be queried using :func:`network_get_attribute_dtype`.
+
+    .. seealso:: `cutensornetNetworkSetAttribute`
+    """
+    with nogil:
+        status = cutensornetNetworkSetAttribute(
+            <_Handle>handle, <_NetworkDescriptor>tn_desc,
+            <_NetworkAttribute>attr, <void*>buf, size)
+    check_status(status)
+
+
 cpdef tuple get_output_tensor_details(intptr_t handle, intptr_t tn_desc):
     """Get the output tensor's metadata.
 
@@ -875,6 +1007,25 @@ cpdef tuple workspace_get_memory(
     return (<intptr_t>workspace_ptr, workspace_size)
 
 
+cpdef workspace_purge_cache(
+        intptr_t handle, intptr_t workspace, int mem_space):
+    """Purge the cached data in the specified memory space.
+
+    Args:
+        handle (intptr_t): The library handle.
+        workspace (intptr_t): The workspace descriptor.
+        mem_space (Memspace): The memory space for the workspace being
+            queried.
+
+    .. seealso:: `cutensornetWorkspacePurgeCache`
+    """
+    with nogil:
+        status = cutensornetWorkspacePurgeCache(
+            <_Handle>handle, <_WorkspaceDescriptor>workspace,
+            <_Memspace>mem_space)
+    check_status(status)
+
+
 cpdef intptr_t create_contraction_optimizer_info(
         intptr_t handle, intptr_t tn_desc) except*:
     """Create a contraction optimizer info object.
@@ -995,6 +1146,34 @@ slicing_config_dtype = _numpy.dtype(
     }, align=True
 )
 
+gesvdj_params_dtype = _numpy.dtype(
+    {'names': ('tol','max_sweeps'),
+     'formats': (_numpy.float64, _numpy.int32),
+     'itemsize': sizeof(_GesvdjParams),
+    }, align=True
+)
+
+gesvdr_params_dtype = _numpy.dtype(
+    {'names': ('oversampling','niters'),
+     'formats': (_numpy.int64, _numpy.int64),
+     'itemsize': sizeof(_GesvdrParams),
+    }, align=True
+)
+
+gesvdj_status_dtype = _numpy.dtype(
+    {'names': ('residual', 'sweeps'),
+     'formats': (_numpy.float64, _numpy.int32),
+     'itemsize': sizeof(_GesvdjStatus),
+    }, align=True
+)
+
+gesvdp_status_dtype = _numpy.dtype(
+    {'names': ('err_sigma', ),
+     'formats': (_numpy.float64, ),
+     'itemsize': sizeof(_GesvdpStatus),
+    }, align=True
+)
+
 cdef dict contract_opti_info_sizes = {
     CUTENSORNET_CONTRACTION_OPTIMIZER_INFO_NUM_SLICES: _numpy.int64,
     CUTENSORNET_CONTRACTION_OPTIMIZER_INFO_NUM_SLICED_MODES: _numpy.int32,
@@ -1220,6 +1399,8 @@ cdef dict contract_opti_cfg_sizes = {
     CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SIMPLIFICATION_DISABLE_DR: _numpy.int32,
     CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SEED: _numpy.int32,
     CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_COST_FUNCTION_OBJECTIVE: _numpy.int32,  # = sizeof(enum value)
+    CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_CACHE_REUSE_NRUNS: _numpy.int32,
+    CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SMART_OPTION: _numpy.int32,  # = sizeof(enum value)
 }
 
 cpdef contraction_optimizer_config_get_attribute_dtype(int attr):
@@ -1245,6 +1426,9 @@ cpdef contraction_optimizer_config_get_attribute_dtype(int attr):
     elif attr == CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_COST_FUNCTION_OBJECTIVE:
         if _numpy.dtype(dtype).itemsize != sizeof(_OptimizerCost):
             warnings.warn("binary size may be incompatible")
+    elif attr == CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SMART_OPTION:
+        if _numpy.dtype(dtype).itemsize != sizeof(_SmartOption):
+            warnings.warn("binary size may be incompatible")
     return dtype
 
 ###########################################################################
@@ -2028,13 +2212,22 @@ cdef dict tensor_svd_cfg_sizes = {
     CUTENSORNET_TENSOR_SVD_CONFIG_REL_CUTOFF: _numpy.float64,
     CUTENSORNET_TENSOR_SVD_CONFIG_S_NORMALIZATION: _numpy.int32,  # = sizeof(enum value)
     CUTENSORNET_TENSOR_SVD_CONFIG_S_PARTITION: _numpy.int32,  # = sizeof(enum value)
+    CUTENSORNET_TENSOR_SVD_CONFIG_ALGO: _numpy.int32, # = sizeof(enum value)
+}
+
+cdef dict svd_algo_params_sizes = {
+    CUTENSORNET_TENSOR_SVD_ALGO_GESVDJ: gesvdj_params_dtype,
+    CUTENSORNET_TENSOR_SVD_ALGO_GESVDR: gesvdr_params_dtype
 }
 
 cpdef tensor_svd_config_get_attribute_dtype(int attr):
     """Get the Python data type of the corresponding tensor SVD config attribute.
 
     Args:
-        attr (TensorSVDConfigAttribute): The attribute to query.
+        attr (TensorSVDConfigAttribute): The attribute to query. 
+            The enum CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS is not supported, 
+            the dtype of which can be queried by :func:`tensor_svd_algo_params_get_dtype`.
+
 
     Returns:
         The data type of the queried attribute.
@@ -2043,6 +2236,8 @@ cpdef tensor_svd_config_get_attribute_dtype(int attr):
         allocating memory for :func:`tensor_svd_config_get_attribute`
         and :func:`tensor_svd_config_set_attribute`.
     """
+    if attr == CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS:
+        raise ValueError("For CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS, use `tensor_svd_algo_params_get_dtype` to get the dtype")
     dtype = tensor_svd_cfg_sizes[attr]
     if attr == CUTENSORNET_TENSOR_SVD_CONFIG_S_NORMALIZATION:
         if _numpy.dtype(dtype).itemsize != sizeof(_TensorSVDNormalization):
@@ -2050,8 +2245,28 @@ cpdef tensor_svd_config_get_attribute_dtype(int attr):
     elif attr == CUTENSORNET_TENSOR_SVD_CONFIG_S_PARTITION:
         if _numpy.dtype(dtype).itemsize != sizeof(_TensorSVDPartition):
             warnings.warn("binary size may be incompatible")
+    elif attr == CUTENSORNET_TENSOR_SVD_CONFIG_ALGO:
+        if _numpy.dtype(dtype).itemsize != sizeof(_TensorSVDAlgo):
+            warnings.warn("binary size may be incompatible")
     return dtype
 
+cpdef tensor_svd_algo_params_get_dtype(int svd_algo):
+    """Get the Python data type of the corresponding tensor SVD parameters attribute.
+    
+    Args:
+        svd_algo (TensorSVDAlgo): The SVD algorithm to query.
+    
+    Returns:
+        The data type of algorithm parameters for the queried SVD algorithm. The returned dtype is always
+        a valid NumPy dtype object.
+
+    .. note:: This API has no C counterpart and is a convenient helper for
+        allocating memory for `CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS`.
+    """
+    if svd_algo not in svd_algo_params_sizes:
+        raise ValueError(f"Algorithm {svd_algo} does not support tunable parameters.")
+    return svd_algo_params_sizes[svd_algo]
+
 ###########################################################################
 
 
@@ -2145,6 +2360,12 @@ cdef dict tensor_svd_info_sizes = {
     CUTENSORNET_TENSOR_SVD_INFO_FULL_EXTENT: _numpy.int64,
     CUTENSORNET_TENSOR_SVD_INFO_REDUCED_EXTENT: _numpy.int64,
     CUTENSORNET_TENSOR_SVD_INFO_DISCARDED_WEIGHT: _numpy.float64,
+    CUTENSORNET_TENSOR_SVD_INFO_ALGO: _numpy.int32, # = sizeof(enum value)
+}
+
+cdef dict svd_algo_status_sizes = {
+    CUTENSORNET_TENSOR_SVD_ALGO_GESVDJ: gesvdj_status_dtype,
+    CUTENSORNET_TENSOR_SVD_ALGO_GESVDP: gesvdp_status_dtype
 }
 
 cpdef tensor_svd_info_get_attribute_dtype(int attr):
@@ -2152,6 +2373,8 @@ cpdef tensor_svd_info_get_attribute_dtype(int attr):
 
     Args:
         attr (TensorSVDInfoAttribute): The attribute to query.
+            The enum CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS is not supported, 
+            the dtype of which can be queried by :func:`tensor_svd_algo_status_get_dtype`.
 
     Returns:
         The data type of the queried attribute. The returned dtype is always
@@ -2161,8 +2384,27 @@ cpdef tensor_svd_info_get_attribute_dtype(int attr):
         allocating memory for :func:`tensor_svd_info_get_attribute`.
 
     """
+    if attr == CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS:
+        raise ValueError("For CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS, use `tensor_svd_algo_status_get_dtype` to get the dtype")
     return tensor_svd_info_sizes[attr]
 
+cpdef tensor_svd_algo_status_get_dtype(int svd_algo):
+    """Get the Python data type of the corresponding tensor SVD status attribute.
+    
+    Args:
+        svd_algo (TensorSVDAlgo): The SVD algorithm to query.
+    
+    Returns:
+        The data type of algorithm status for the queried SVD algorithm. The returned dtype is always
+        a valid NumPy dtype object.
+
+    .. note:: This API has no C counterpart and is a convenient helper for
+        allocating memory for `CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS`.
+    """
+    if svd_algo not in svd_algo_status_sizes:
+        raise ValueError(f"Algorithm {svd_algo} does not support tunable parameters.")
+    return svd_algo_status_sizes[svd_algo]
+
 ###########################################################################
 
 
@@ -2482,6 +2724,557 @@ cpdef distributed_synchronize(intptr_t handle):
     check_status(status)
 
 
+cpdef compute_gradients_backward(
+        intptr_t handle, intptr_t plan,
+        raw_data_in, intptr_t output_gradient, gradients, bint accumulate_output,
+        intptr_t workspace, intptr_t stream):
+    """Compute the gradients of the network w.r.t. the input tensors whose
+    gradients are required.
+
+    The input tensors should form a tensor network that is prescribed by the
+    tensor network descriptor that was used to create the contraction plan.
+
+    .. warning::
+
+        This function is experimental and is subject to change in future
+        releases.
+
+    Args:
+        handle (intptr_t): The library handle.
+        plan (intptr_t): The contraction plan handle.
+        raw_data_in: A host array of pointer addresses (as Python :class:`int`) for
+            each input tensor (on device). It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+
+        output_gradient (intptr_t): The pointer address (as Python :class:`int`)
+            to the gradient w.r.t. the output tensor (on device).
+        gradients: A host array of pointer addresses (as Python :class:`int`) for
+            each gradient tensor (on device). It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+
+        accumulate_output (bool): Whether to accumulate the data in
+            ``gradients``.
+        workspace (intptr_t): The workspace descriptor.
+        stream (intptr_t): The CUDA stream handle (``cudaStream_t`` as Python
+            :class:`int`).
+
+    .. seealso:: `cutensornetComputeGradientsBackward`
+    """
+    warnings.warn("compute_gradients_backward() is an experimental API and "
+                  "subject to future changes", stacklevel=2)
+
+    # raw_data_in can be a pointer address, or a Python sequence
+    cdef vector[intptr_t] rawDataInData
+    cdef void** rawDataInPtr
+    if cpython.PySequence_Check(raw_data_in):
+        rawDataInData = raw_data_in
+        rawDataInPtr = <void**>(rawDataInData.data())
+    else:  # a pointer address
+        rawDataInPtr = <void**><intptr_t>raw_data_in
+
+    # gradients can be a pointer address, or a Python sequence
+    cdef vector[intptr_t] gradientsData
+    cdef void** gradientsPtr
+    if cpython.PySequence_Check(gradients):
+        gradientsData = gradients
+        gradientsPtr = <void**>(gradientsData.data())
+    else:  # a pointer address
+        gradientsPtr = <void**><intptr_t>gradients
+
+    with nogil:
+        status = cutensornetComputeGradientsBackward(
+            <_Handle>handle, <_ContractionPlan>plan,
+            rawDataInPtr, <void*>output_gradient, gradientsPtr,
+            <int32_t>accumulate_output,
+            <_WorkspaceDescriptor>workspace, <Stream>stream)
+    check_status(status)
+
+
+cpdef intptr_t create_state(
+        intptr_t handle, 
+        int purity, int32_t n_state_modes, 
+        state_mode_extents, int data_type) except*:
+    """Create a tensor network state.
+
+    Args:
+        handle (intptr_t): The library handle.
+        purity (cuquantum.cutensornet.StatePurity): The tensor network state purity.
+        n_state_modes (int32_t): The number of modes of the tensor network states. 
+        state_mode_extents: A host array of extents for each state mode. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+        
+        data_type (cuquantum.cudaDataType): The data type of the tensor network state.
+
+    Returns:
+        intptr_t: An opaque tensor network state handle (as Python :class:`int`).
+
+    .. seealso:: `cutensornetCreateState`
+    """
+    # state_mode_extents can be a pointer address, or a Python sequence
+    cdef vector[int64_t] stateModesExtentsData
+    cdef int64_t* stateModesExtentsPtr
+    if cpython.PySequence_Check(state_mode_extents):
+        if len(state_mode_extents) != n_state_modes:
+            raise ValueError("size of state_mode_extents not matching n_state_modes")
+        stateModesExtentsData = state_mode_extents
+        stateModesExtentsPtr = stateModesExtentsData.data()
+    else:  # a pointer address
+        stateModesExtentsPtr = <int64_t*><intptr_t>state_mode_extents
+    
+    cdef _State state
+    with nogil:
+        status = cutensornetCreateState(
+            <_Handle>handle, <_StatePurity>purity, n_state_modes, 
+            stateModesExtentsPtr, <DataType>data_type, &state)
+    check_status(status)
+    return <intptr_t>state
+
+
+cpdef destroy_state(intptr_t state):
+    """Destroy a tensor network state.
+
+    Args:
+        state (intptr_t): The tensor network state.
+
+    .. seealso:: `cutensornetDestroyState`
+    """
+    with nogil:
+        status = cutensornetDestroyState(<_State>state)
+    check_status(status)
+
+
+cpdef int64_t state_apply_tensor(
+        intptr_t handle, intptr_t state, int32_t n_state_modes, 
+        state_modes, intptr_t tensor_data, tensor_mode_strides, 
+        int32_t immutable, int32_t adjoint, int32_t unitary):
+    """Apply a tensor operator to the tensor network state.
+
+    Args:
+        handle (intptr_t): The library handle.
+        state (intptr_t): The tensor network state.
+        n_state_modes (int32_t): The number of state modes that the tensor applies on.
+        state_modes: A host array of modes to specify where the tensor is applied to. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+         
+        tensor_data (intptr_t): The tensor data.
+        tensor_mode_strides: A host array of strides for each mode. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+
+        immutable (int32_t): Whether the tensor is immutable
+        adjoint (int32_t): Whether the tensor should be considered as adjoint.
+        unitary (int32_t): Whether the tensor represents a unitary operation.
+    
+    Returns:
+        tensor_id (int64_t): The id that is assigned to the tensor.
+
+    .. seealso:: `cutensornetStateApplyTensor`
+    """
+    # state_modes can be a pointer address, or a Python sequence
+    cdef int64_t tensor_id
+    cdef vector[int32_t] stateModesData
+    cdef int32_t* stateModesPtr
+    if cpython.PySequence_Check(state_modes):
+        if len(state_modes) != n_state_modes:
+            raise ValueError("size of state_modes not matching n_state_modes")
+        stateModesData = state_modes
+        stateModesPtr = stateModesData.data()
+    else:  # a pointer address
+        stateModesPtr = <int32_t*><intptr_t>state_modes
+    
+    # tensor_mode_strides can be a pointer address, or a Python sequence
+    cdef vector[int64_t] tensorModesStridesData
+    cdef int64_t* tensorModesStridesPtr
+    if cpython.PySequence_Check(tensor_mode_strides):
+        tensorModesStridesData = tensor_mode_strides
+        tensorModesStridesPtr = tensorModesStridesData.data()
+    else:  # a pointer address
+        tensorModesStridesPtr = <int64_t*><intptr_t>tensor_mode_strides
+    
+    with nogil:
+        status = cutensornetStateApplyTensor(
+            <_Handle>handle, <_State>state, n_state_modes, stateModesPtr, <void*>tensor_data, 
+            tensorModesStridesPtr, immutable, adjoint, unitary, &tensor_id)
+    check_status(status)
+    return tensor_id
+
+
+cpdef state_update_tensor(
+        intptr_t handle, intptr_t state, 
+        int64_t tensor_id, intptr_t tensor_data, int32_t unitary):
+    """Update a tensor operand that has been applied to the tensor network state.
+
+    Args:
+        handle (intptr_t): The library handle.
+        state (intptr_t): The tensor network state.
+        tensor_id (int64_t): The id that is assigned to the tensor.        
+        tensor_data (intptr_t): The tensor data.
+        adjoint (int32_t): Whether the tensor should be considered as adjoint.
+        unitary (int32_t): Whether the tensor represents a unitary operation.
+
+    .. seealso:: `cutensornetStateUpdateTensor`
+    """
+    with nogil:
+        status = cutensornetStateUpdateTensor(
+            <_Handle>handle, <_State>state, tensor_id, <void*>tensor_data, unitary)
+    check_status(status)
+
+
+cpdef intptr_t create_marginal(
+        intptr_t handle, intptr_t state, 
+        int32_t n_marginal_modes, marginal_modes, 
+        int32_t n_projected_modes, projected_modes, marginal_tensor_strides) except*:
+    """Create a representation for the tensor network state marginal distribution.
+
+    Args:
+        handle (intptr_t): The library handle.
+        state (intptr_t): The tensor network state.
+        n_marginal_modes (int32_t): The number of modes for the marginal.
+        marginal_modes: A host array of modes for the marginal. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+        
+        n_projected_modes (int32_t): The number of modes that are projected out for the marginal.
+        projected_modes: A host array of projected modes for the marginal. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+        
+        marginal_tensor_strides: A host array of strides for the marginal modes. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+
+    Returns:
+        intptr_t: An opaque tensor network state marginal handle (as Python :class:`int`).
+
+    .. seealso:: `cutensornetCreateMarginal`
+    """
+    # marginal_modes can be a pointer address, or a Python sequence
+    cdef vector[int32_t] marginalModesData
+    cdef int32_t* marginalModesPtr
+    if cpython.PySequence_Check(marginal_modes):
+        if len(marginal_modes) != n_marginal_modes:
+            raise ValueError("size of marginal_modes not matching n_marginal_modes")
+        marginalModesData = marginal_modes
+        marginalModesPtr = marginalModesData.data()
+    else:  # a pointer address
+        marginalModesPtr = <int32_t*><intptr_t>marginal_modes
+    
+    # projected_modes can be a pointer address, or a Python sequence
+    cdef vector[int32_t] projectedModesData
+    cdef int32_t* projectedModesPtr
+    if cpython.PySequence_Check(projected_modes):
+        if len(projected_modes) != n_projected_modes:
+            raise ValueError("size of projected_modes not matching n_projected_modes")
+        projectedModesData = projected_modes
+        projectedModesPtr = projectedModesData.data()
+    else:  # a pointer address
+        projectedModesPtr = <int32_t*><intptr_t>projected_modes
+    
+    # marginal_tensor_strides can be a pointer address, or a Python sequence
+    cdef vector[int64_t] marginalTensorStridesData
+    cdef int64_t* marginalTensorStridesPtr
+    if cpython.PySequence_Check(marginal_tensor_strides):
+        marginalTensorStridesData = marginal_tensor_strides
+        marginalTensorStridesPtr = marginalTensorStridesData.data()
+    else:  # a pointer address
+        marginalTensorStridesPtr = <int64_t*><intptr_t>marginal_tensor_strides
+    
+    cdef _StateMarginal marginal
+    with nogil:
+        status = cutensornetCreateMarginal(
+            <_Handle>handle, <_State>state, 
+            n_marginal_modes, marginalModesPtr,
+            n_projected_modes, projectedModesPtr, 
+            marginalTensorStridesPtr, &marginal)
+    check_status(status)
+    return <intptr_t>marginal
+
+
+cdef dict marginal_attribute_sizes = {
+    CUTENSORNET_MARGINAL_OPT_NUM_HYPER_SAMPLES: _numpy.int64
+}
+
+
+cpdef marginal_get_attribute_dtype(int attr):
+    """Get the Python data type of the corresponding marginal attribute.
+
+    Args:
+        attr (MarginalAttribute): The attribute to query.
+
+    Returns:
+        The data type of the queried attribute. The returned dtype is always
+        a valid NumPy dtype object.
+
+    .. note:: This API has no C counterpart and is a convenient helper for
+        allocating memory for :func:`marginal_configure`.
+    """
+    return marginal_attribute_sizes[attr]
+    
+
+cpdef marginal_configure(intptr_t handle, intptr_t marginal, int attr, intptr_t buf, size_t size):
+    """Configures computation of the tensor network state marginal distribution.
+
+    Args:
+        handle (intptr_t): The library handle.
+        marginal (intptr_t): The tensor network marginal computation handle.
+        attr (MarginalAttribute): The attribute to configure.
+        buf (intptr_t): The pointer address (as Python :class:`int`) for storing
+            the returned attribute value.
+        size (size_t): The size of ``buf`` (in bytes).
+
+    .. note:: To compute ``size``, use the itemsize of the corresponding data
+        type, which can be queried using :func:`marginal_get_attribute_dtype`.
+
+    .. seealso:: `cutensornetMarginalConfigure`
+    """
+    with nogil:
+        status = cutensornetMarginalConfigure(
+            <_Handle>handle, <_StateMarginal>marginal,
+            <_MarginalAttribute>attr,
+            <void*>buf, size)
+    check_status(status)
+
+
+cpdef marginal_prepare(
+        intptr_t handle, intptr_t marginal, 
+        size_t max_workspace_size_device, intptr_t workspace, intptr_t stream):
+    """Prepares computation of the tensor network state marginal distribution.
+
+    Args:
+        handle (intptr_t): The library handle.
+        marginal (intptr_t): The tensor network marginal computation handle.
+        max_workspace_size_device (size_t): The maximal device workspace size (in bytes) allowed 
+            for the mariginal computation.
+        workspace (intptr_t): The workspace descriptor.
+        stream (intptr_t): The CUDA stream handle (``cudaStream_t`` as Python
+            :class:`int`).
+
+    .. seealso:: `cutensornetMarginalPrepare`
+    """
+    with nogil:
+        status = cutensornetMarginalPrepare(
+            <_Handle>handle, <_StateMarginal>marginal,
+            max_workspace_size_device, <_WorkspaceDescriptor>workspace, <Stream>stream)
+    check_status(status)
+
+
+cpdef marginal_compute(
+        intptr_t handle, intptr_t marginal, projected_mode_values, 
+        intptr_t workspace, intptr_t marginal_tensor, intptr_t stream):
+    """Computes the tensor network state marginal distribution.
+
+    Args:
+        handle (intptr_t): The library handle.
+        marginal (intptr_t): The tensor network marginal computation handle.
+        projected_mode_values: A host array of values for the projected modes. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+        
+        workspace (intptr_t): The workspace descriptor.
+        marginal_tensor (intptr_t): The pointer address (as Python :class:`int`) for storing
+            the computed marginals.
+        stream (intptr_t): The CUDA stream handle (``cudaStream_t`` as Python
+            :class:`int`).
+
+    .. seealso:: `cutensornetMarginalCompute`
+    """
+    # projected_mode_values can be a pointer address, or a Python sequence
+    cdef vector[int64_t] projectedModeValuesData
+    cdef int64_t* projectedModeValuesPtr
+    if cpython.PySequence_Check(projected_mode_values):
+        projectedModeValuesData = projected_mode_values
+        projectedModeValuesPtr = projectedModeValuesData.data()
+    else:  # a pointer address
+        projectedModeValuesPtr = <int64_t*><intptr_t>projected_mode_values
+    
+    with nogil:
+        status = cutensornetMarginalCompute(
+            <_Handle>handle, <_StateMarginal>marginal,
+            projectedModeValuesPtr, <_WorkspaceDescriptor>workspace, 
+            <void*>marginal_tensor, <Stream>stream)
+    check_status(status)
+
+
+cpdef destroy_marginal(intptr_t marginal):
+    """Destroy a tensor network marginal representation.
+
+    Args:
+        marginal (intptr_t): The tensor network marginal distribution.
+
+    .. seealso:: `cutensornetDestroyMarginal`
+    """
+    with nogil:
+        status = cutensornetDestroyMarginal(<_StateMarginal>marginal)
+    check_status(status)
+
+
+cpdef intptr_t create_sampler(
+        intptr_t handle, intptr_t state, 
+        int32_t n_modes_to_sample, modes_to_sample) except*:
+    """Creates a tensor network state sampler.
+
+    Args:
+        handle (intptr_t): The library handle.
+        state (intptr_t): The tensor network state.
+        n_modes_to_sample (int32_t): The number of modes to sample for the sampler.
+        modes_to_sample: A host array of modes for the sampler. It can be
+
+            - an :class:`int` as the pointer address to the array
+            - a Python sequence of :class:`int`
+        
+    Returns:
+        intptr_t: An opaque tensor network state sampler handle (as Python :class:`int`).
+
+    .. seealso:: `cutensornetCreateSampler`
+    """
+    # modes_to_sample can be a pointer address, or a Python sequence
+    cdef vector[int32_t] modesData
+    cdef int32_t* modesPtr
+    if cpython.PySequence_Check(modes_to_sample):
+        if len(modes_to_sample) != n_modes_to_sample:
+            raise ValueError("size of modes_to_sample not matching n_modes_to_sample")
+        modesData = modes_to_sample
+        modesPtr = modesData.data()
+    else:  # a pointer address
+        modesPtr = <int32_t*><intptr_t>modes_to_sample
+    
+    cdef _StateSampler sampler
+    with nogil:
+        status = cutensornetCreateSampler(
+            <_Handle>handle, <_State>state, 
+            n_modes_to_sample, modesPtr, &sampler)
+    check_status(status)
+    return <intptr_t> sampler
+
+
+cdef dict sampler_attribute_sizes = {
+    CUTENSORNET_SAMPLER_OPT_NUM_HYPER_SAMPLES: _numpy.int64
+}
+
+
+cpdef sampler_get_attribute_dtype(int attr):
+    """Get the Python data type of the corresponding sampler attribute.
+
+    Args:
+        attr (SamplerAttribute): The attribute to query.
+
+    Returns:
+        The data type of the queried attribute. The returned dtype is always
+        a valid NumPy dtype object.
+
+    .. note:: This API has no C counterpart and is a convenient helper for
+        allocating memory for :func:`sampler_configure`.
+    """
+    return sampler_attribute_sizes[attr]
+
+
+cpdef sampler_configure(
+        intptr_t handle, intptr_t sampler, int attr, intptr_t buf, size_t size):
+    """Configures the tensor network state sampler.
+
+    Args:
+        handle (intptr_t): The library handle.
+        sampler (intptr_t): The tensor network sampler handle.
+        attr (SamplerAttribute): The attribute to configure.
+        buf (intptr_t): The pointer address (as Python :class:`int`) for storing
+            the returned attribute value.
+        size (size_t): The size of ``buf`` (in bytes).
+
+    .. note:: To compute ``size``, use the itemsize of the corresponding data
+        type, which can be queried using :func:`sampler_get_attribute_dtype`.
+
+    .. seealso:: `cutensornetSamplerConfigure`
+    """
+    with nogil:
+        status = cutensornetSamplerConfigure(
+            <_Handle>handle, <_StateSampler>sampler,
+            <_SamplerAttribute>attr,
+            <void*>buf, size)
+    check_status(status)
+
+
+cpdef sampler_prepare(
+        intptr_t handle, intptr_t sampler, size_t max_workspace_size_device, intptr_t workspace, intptr_t stream):
+    """Prepares computation of the tensor network state marginal distribution.
+
+    Args:
+        handle (intptr_t): The library handle.
+        sampler (intptr_t): The tensor network sampler.
+        max_workspace_size_device (size_t): The maximal device workspace size (in bytes) allowed 
+            for the sampling computation.
+        workspace (intptr_t): The workspace descriptor.
+        stream (intptr_t): The CUDA stream handle (``cudaStream_t`` as Python
+            :class:`int`).
+
+    .. seealso:: `cutensornetSamplerPrepare`
+    """
+    with nogil:
+        status = cutensornetSamplerPrepare(
+            <_Handle>handle, <_StateSampler>sampler,
+            max_workspace_size_device, <_WorkspaceDescriptor>workspace, <Stream>stream)
+    check_status(status)
+
+
+cpdef sampler_sample(
+        intptr_t handle, intptr_t sampler, int64_t n_shots,
+        intptr_t workspace, intptr_t samples, intptr_t stream):
+    """Computes the tensor network state marginal distribution.
+
+    Args:
+        handle (intptr_t): The library handle.
+        sampler (intptr_t): The tensor network sampler.
+        n_shots (int64_t): The number of shots.
+        workspace (intptr_t): The workspace descriptor.
+        samples (intptr_t): The pointer address (as Python :class:`int`) for storing
+            the computed samples.
+        stream (intptr_t): The CUDA stream handle (``cudaStream_t`` as Python
+            :class:`int`).
+
+    .. seealso:: `cutensornetSamplerSample`
+    """
+    with nogil:
+        status = cutensornetSamplerSample(
+            <_Handle>handle, <_StateSampler>sampler, n_shots, 
+            <_WorkspaceDescriptor>workspace, 
+            <int64_t*>samples, <Stream>stream)
+    check_status(status)
+
+
+cpdef destroy_sampler(intptr_t sampler):
+    """Destroy a tensor network state sampler.
+
+    Args:
+        sampler (intptr_t): The tensor network state sampler.
+
+    .. seealso:: `cutensornetDestroySampler`
+    """
+    with nogil:
+        status = cutensornetDestroySampler(<_StateSampler>sampler)
+    check_status(status)
+
+
+class NetworkAttribute(IntEnum):
+    """See `cutensornetNetworkAttributes_t`."""
+    INPUT_TENSORS_NUM_CONSTANT = CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_CONSTANT
+    INPUT_TENSORS_CONSTANT = CUTENSORNET_NETWORK_INPUT_TENSORS_CONSTANT
+    INPUT_TENSORS_NUM_CONJUGATED = CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_CONJUGATED
+    INPUT_TENSORS_CONJUGATED = CUTENSORNET_NETWORK_INPUT_TENSORS_CONJUGATED
+    INPUT_TENSORS_NUM_REQUIRE_GRAD = CUTENSORNET_NETWORK_INPUT_TENSORS_NUM_REQUIRE_GRAD
+    INPUT_TENSORS_REQUIRE_GRAD = CUTENSORNET_NETWORK_INPUT_TENSORS_REQUIRE_GRAD
+
 class GraphAlgo(IntEnum):
     """See `cutensornetGraphAlgo_t`."""
     RB = CUTENSORNET_GRAPH_ALGO_RB
@@ -2518,6 +3311,8 @@ class ContractionOptimizerConfigAttribute(IntEnum):
     SIMPLIFICATION_DISABLE_DR = CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SIMPLIFICATION_DISABLE_DR
     SEED = CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SEED
     COST_FUNCTION_OBJECTIVE = CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_COST_FUNCTION_OBJECTIVE
+    CACHE_REUSE_NRUNS = CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_CACHE_REUSE_NRUNS
+    SMART_OPTION = CUTENSORNET_CONTRACTION_OPTIMIZER_CONFIG_SMART_OPTION
 
 class ContractionOptimizerInfoAttribute(IntEnum):
     """See `cutensornetContractionOptimizerInfoAttributes_t`."""
@@ -2563,6 +3358,8 @@ class TensorSVDConfigAttribute(IntEnum):
     REL_CUTOFF = CUTENSORNET_TENSOR_SVD_CONFIG_REL_CUTOFF
     S_NORMALIZATION = CUTENSORNET_TENSOR_SVD_CONFIG_S_NORMALIZATION
     S_PARTITION = CUTENSORNET_TENSOR_SVD_CONFIG_S_PARTITION
+    ALGO = CUTENSORNET_TENSOR_SVD_CONFIG_ALGO
+    ALGO_PARAMS = CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS
 
 class TensorSVDNormalization(IntEnum):
     """See `cutensornetTensorSVDNormalization_t`."""
@@ -2583,12 +3380,33 @@ class TensorSVDInfoAttribute(IntEnum):
     FULL_EXTENT = CUTENSORNET_TENSOR_SVD_INFO_FULL_EXTENT
     REDUCED_EXTENT = CUTENSORNET_TENSOR_SVD_INFO_REDUCED_EXTENT
     DISCARDED_WEIGHT = CUTENSORNET_TENSOR_SVD_INFO_DISCARDED_WEIGHT
+    ALGO = CUTENSORNET_TENSOR_SVD_INFO_ALGO
+    ALGO_STATUS = CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS
+
+class TensorSVDAlgo(IntEnum):
+    """See `cutensornetTensorSVDAlgo_t`."""
+    GESVD = CUTENSORNET_TENSOR_SVD_ALGO_GESVD
+    GESVDJ = CUTENSORNET_TENSOR_SVD_ALGO_GESVDJ
+    GESVDP = CUTENSORNET_TENSOR_SVD_ALGO_GESVDP
+    GESVDR = CUTENSORNET_TENSOR_SVD_ALGO_GESVDR
 
 class GateSplitAlgo(IntEnum):
     """See `cutensornetGateSplitAlgo_t`."""
     DIRECT = CUTENSORNET_GATE_SPLIT_ALGO_DIRECT
     REDUCED = CUTENSORNET_GATE_SPLIT_ALGO_REDUCED
 
+class StatePurity(IntEnum):
+    """See `cutensornetStatePurity_t`."""
+    PURE = CUTENSORNET_STATE_PURITY_PURE
+
+class MarginalAttribute(IntEnum):
+    """See `cutensornetMarginalAttributes_t`."""
+    OPT_NUM_HYPER_SAMPLES = CUTENSORNET_MARGINAL_OPT_NUM_HYPER_SAMPLES
+
+class SamplerAttribute(IntEnum):
+    """See `cutensornetSamplerAttributes_t`."""
+    OPT_NUM_HYPER_SAMPLES = CUTENSORNET_SAMPLER_OPT_NUM_HYPER_SAMPLES
+
 del IntEnum
 
 
@@ -2600,8 +3418,8 @@ VERSION = CUTENSORNET_VERSION
 
 # numpy dtypes 
 tensor_qualifiers_dtype = _numpy.dtype(
-    {'names':('is_conjugate', 'is_constant', ),
-     'formats': (_numpy.int32, _numpy.int32, ),
+    {'names':('is_conjugate', 'is_constant', 'requires_gradient'),
+     'formats': (_numpy.int32, _numpy.int32, _numpy.int32, ),
      'itemsize': sizeof(_TensorQualifiers),
     }, align=True
 )
diff --git a/python/cuquantum/cutensornet/experimental/tensor_network.py b/python/cuquantum/cutensornet/experimental/tensor_network.py
index 14a1ef0..9c8c450 100644
--- a/python/cuquantum/cutensornet/experimental/tensor_network.py
+++ b/python/cuquantum/cutensornet/experimental/tensor_network.py
@@ -81,19 +81,22 @@ def _gate_split(wrapped_operands, inputs, outputs, size_dict, max_mid_extent, al
             gate_algorithm, svd_config, options.compute_type, workspace_desc)
             
         # Allocate and set workspace
-        workspace_ptr = decomposition_utils.allocate_and_set_workspace(handle, options.allocator, workspace_desc, 
-                    cutn.WorksizePref.MIN, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH, options.device_id, 
+        workspaces = dict()
+        for mem_space in (cutn.Memspace.DEVICE, cutn.Memspace.HOST):
+            workspaces[mem_space] = decomposition_utils.allocate_and_set_workspace(handle, options.allocator, workspace_desc, 
+                    cutn.WorksizePref.MIN, mem_space, cutn.WorkspaceKind.SCRATCH, options.device_id, 
                     stream, stream_ctx, options.logger, task_name='contract decomposition')
 
         options.logger.info("Starting contract-decompose (gate split)...")
         timing =  bool(options.logger and options.logger.handlers)
-        if options.blocking:
+        blocking = options.blocking is True or operands_location == 'cpu'
+        if blocking:
             options.logger.info("This call is blocking and will return only after the operation is complete.")
         else:
             options.logger.info("This call is non-blocking and will return immediately after the operation is launched on the device.")
 
         svd_info = cutn.create_tensor_svd_info(handle)
-        with utils.device_ctx(options.device_id), utils.cuda_call_ctx(stream, options.blocking, timing) as (last_compute_event, elapsed):
+        with utils.device_ctx(options.device_id), utils.cuda_call_ctx(stream, blocking, timing) as (last_compute_event, elapsed):
             cutn.gate_split(handle, 
                 input_tensor_descriptors[0], wrapped_operands[0].data_ptr, 
                 input_tensor_descriptors[1], wrapped_operands[1].data_ptr, 
@@ -122,6 +125,9 @@ def _gate_split(wrapped_operands, inputs, outputs, size_dict, max_mid_extent, al
             if reduced_extent != mid_extent:
                 s.tensor = s.tensor[:reduced_extent]
     finally:
+        # when host workspace is allocated, synchronize stream before return
+        if workspaces[cutn.Memspace.HOST] is not None:
+            stream.synchronize()
         # Free resources
         decomposition_utils._destroy_tensor_descriptors(input_tensor_descriptors)
         decomposition_utils._destroy_tensor_descriptors(output_tensor_descriptors)
diff --git a/python/cuquantum/cutensornet/tensor.py b/python/cuquantum/cutensornet/tensor.py
index 71de016..52f13d3 100644
--- a/python/cuquantum/cutensornet/tensor.py
+++ b/python/cuquantum/cutensornet/tensor.py
@@ -13,6 +13,8 @@
 import re
 from typing import Optional
 
+import numpy
+
 from . import cutensornet as cutn
 from .configuration import NetworkOptions
 from ._internal import decomposition_utils
@@ -22,6 +24,7 @@
 DecompositionOptions = dataclasses.make_dataclass("DecompositionOptions", fields=[(field.name, field.type, field) for field in dataclasses.fields(NetworkOptions)], bases=(NetworkOptions,))
 DecompositionOptions.__doc__ = re.sub(":class:`cuquantum.Network` object", ":func:`cuquantum.cutensornet.tensor.decompose` and :func:`cuquantum.cutensornet.experimental.contract_decompose` functions", NetworkOptions.__doc__)
 
+
 def decompose(
     subscripts, 
     operand, 
@@ -252,7 +255,6 @@ def decompose(
 
         # Create workspace descriptor
         workspace_desc = cutn.create_workspace_descriptor(handle)
-        workspace_ptr = None
         
         # Compute required workspace size
         if isinstance(method, QRMethod):
@@ -268,21 +270,24 @@ def decompose(
             ValueError("method must be either a QRMethod/SVDMethod object or a dict that can be used to construct QRMethod/SVDMethod")
         
         # Allocate and set workspace
-        workspace_ptr = decomposition_utils.allocate_and_set_workspace(handle, options.allocator, workspace_desc, 
-                    cutn.WorksizePref.MIN, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH, options.device_id, 
-                    stream, stream_ctx, options.logger, task_name='tensor decomposition')
+        workspaces = dict()
+        for mem_space in (cutn.Memspace.DEVICE, cutn.Memspace.HOST):
+            workspaces[mem_space] = decomposition_utils.allocate_and_set_workspace(handle, options.allocator, workspace_desc, 
+                        cutn.WorksizePref.MIN, mem_space, cutn.WorkspaceKind.SCRATCH, options.device_id, 
+                        stream, stream_ctx, options.logger, task_name='tensor decomposition')
         
         svd_info_obj = None
 
         # Perform QR/SVD computation
         logger.info("Starting tensor decomposition...")
-        if options.blocking:
+        blocking = options.blocking is True or operands_location == 'cpu'
+        if blocking:
             logger.info("This call is blocking and will return only after the operation is complete.")
         else:
             logger.info("This call is non-blocking and will return immediately after the operation is launched on the device.")
         timing =  bool(logger and logger.handlers)
         if isinstance(method, QRMethod):
-            with utils.device_ctx(options.device_id), utils.cuda_call_ctx(stream, options.blocking, timing) as (last_compute_event, elapsed):
+            with utils.device_ctx(options.device_id), utils.cuda_call_ctx(stream, blocking, timing) as (last_compute_event, elapsed):
                 cutn.tensor_qr(handle, 
                     *input_descriptors, wrapped_operands[0].data_ptr,
                     output_descriptors[0], output_operands[0].data_ptr,
@@ -293,7 +298,7 @@ def decompose(
                 logger.info(f"The QR decomposition took {elapsed.data:.3f} ms to complete.")
         elif isinstance(method, SVDMethod):
             svd_info = cutn.create_tensor_svd_info(handle)
-            with utils.device_ctx(options.device_id), utils.cuda_call_ctx(stream, options.blocking, timing) as (last_compute_event, elapsed):
+            with utils.device_ctx(options.device_id), utils.cuda_call_ctx(stream, blocking, timing) as (last_compute_event, elapsed):
                 cutn.tensor_svd(handle, 
                     *input_descriptors, wrapped_operands[0].data_ptr, 
                     output_descriptors[0], output_operands[0].data_ptr, 
@@ -312,6 +317,9 @@ def decompose(
             if s is not None and reduced_extent != mid_extent:
                 s.tensor = s.tensor[:reduced_extent]
     finally:
+        # when host workspace is allocated, synchronize stream before return
+        if workspaces[cutn.Memspace.HOST] is not None:
+            stream.synchronize()
         # Free resources
         if svd_config is not None:
             cutn.destroy_tensor_svd_config(svd_config)
@@ -355,14 +363,36 @@ class SVDInfo:
         full_extent: The total number of singular values after matricization (before truncation). 
         reduced_extent: The number of remaining singular values after truncation. 
         discarded_weight: The discarded weight for the truncation.
+        algorithm: The algorithm used in the SVD execution.
+        gesvdj_residual: The residual for full gesvdj execution. 
+        gesvdj_sweeps: The number of iterations used in the gesvdj execution.
+        gesvdp_err_sigma: The error sigma in the gesvdp execution.
+    
+    .. note::
+        
+        When the SVD algorithm is set to ``"gesvdr"`` with fixed extent truncation enabled in :class:`cuquantum.cutensornet.tensor.SVDMethod`, 
+        the discarded weight will not be computed.
     """
 
     reduced_extent: int 
     full_extent: int
     discarded_weight: float
+    algorithm: str
+    gesvdj_residual: Optional[float] = None
+    gesvdj_sweeps: Optional[int] = None
+    gesvdp_err_sigma: Optional[float] = None
 
     def __str__(self):
+        svd_details = f"Algorithm = {self.algorithm}"      
+        if self.gesvdj_residual is not None:
+            svd_details += f", residual= {self.gesvdj_residual}"
+        if self.gesvdj_sweeps is not None:
+            svd_details += f", sweeps = {self.gesvdj_sweeps}"
+        if self.gesvdp_err_sigma is not None:
+            svd_details += f", sigma error = {self.gesvdp_err_sigma}"
+
         s = f"""SVD Information at Runtime:
+    {svd_details}
     Total number of singular values after matricization = {self.full_extent}
     Number of singular values after truncation = {self.reduced_extent}
     Discarded weight for the truncation = {self.discarded_weight}"""
@@ -384,6 +414,16 @@ class SVDMethod:
             :func:`cuquantum.cutensornet.experimental.contract_decompose` will be `None`.
         normalization: The specified norm of the singular values (after truncation) will be normalized to 1. 
             Currently supports ``None``, ``"L1"``, ``"L2"`` and ``"LInf"``. 
+        algorithm: The SVD algorithm to use. Currently supports ``"gesvd"`` (default), ``"gesvdj"``, ``"gesvdp"`` and ``"gesvdr"``. 
+        gesvdj_tol: The tolerance to use when ``algorithm`` is set to ``"gesvdj"``. Default 0 denotes machine precision.
+        gesvdj_max_sweeps: The maximal number of sweeps when ``algorithm`` is set to ``"gesvdj"``. Default 0 denotes 100.
+        gesvdr_oversampling: The size of oversampling when ``algorithm`` is set to ``"gesvdr"``. Default 0 denotes the lower of 4 times ``max_extent`` and the difference between full rank and ``max_extent``.
+        gesvdr_niters: The number of iteration of power method when ``algorithm`` is set to ``"gesvdr"`` and the default (0) is 10.
+    
+    .. note::
+        
+        For detailed explanation on the different SVD algorithms and the corresponding parameters, 
+        please refer to `cuSolver documentation page <https://docs.nvidia.com/cuda/cusolver/index.html#cusolverdn-dense-lapack-function-reference>`_
     
     .. note::
         
@@ -396,10 +436,26 @@ class SVDMethod:
     rel_cutoff: Optional[float] = 0.0
     partition: Optional[str] = None
     normalization: Optional[str] = None
+    algorithm: Optional[str] = 'gesvd'
+    gesvdj_tol: Optional[float] = 0
+    gesvdj_max_sweeps: Optional[int] = 0
+    gesvdr_oversampling: Optional[int] = 0
+    gesvdr_niters: Optional[int] = 0
 
     def __str__(self):
 
+        svd_details = f"Algorithm = {self.algorithm}"      
+        if self.gesvdj_tol is not None:
+            svd_details += f", tolerance = {self.gesvdj_tol}"
+        if self.gesvdj_max_sweeps is not None:
+            svd_details += f", max sweeps = {self.gesvdj_max_sweeps}"
+        if self.gesvdr_oversampling is not None:
+            svd_details += f", oversampling = {self.gesvdr_oversampling}"
+        if self.gesvdr_niters is not None:
+            svd_details += f", niters = {self.gesvdr_niters}"
+        
         s = f"""SVD Method:
+    {svd_details}
     Maxmial number of singular values = {self.max_extent}
     Absolute value cutoff = {self.abs_cutoff} 
     Relative value cutoff = {self.rel_cutoff}
@@ -407,3 +463,28 @@ def __str__(self):
     Singular values normalization = {self.normalization}"""
 
         return s
+    
+    def __post_init__(self):
+        if self.algorithm not in ('gesvd', 'gesvdj', 'gesvdr', 'gesvdp'):
+            raise ValueError(f"SVD algorithm {self.algorithm} not supported; currently supports gesvd, gesvdj, gesvdr, gesvdp")
+        
+        if (self.gesvdj_tol !=0 or self.gesvdj_max_sweeps !=0) and self.algorithm != 'gesvdj':
+            raise ValueError(f"gesvdj_tol and gesvdj_max_sweeps can only be set when algorithm is set to gesvdj, found algorithm {self.algorithm}")
+        
+        if (self.gesvdr_oversampling !=0 or self.gesvdr_niters !=0) and self.algorithm != 'gesvdr':
+            raise ValueError(f"gesvdr_oversample and gesvdr_niters can only be set when algorithm is set to gesvdr, found algorithm {self.algorithm}")
+    
+    def _get_algo_params(self):
+        initialized = False
+        if self.algorithm in ('gesvdj', 'gesvdr'):
+            dtype = cutn.tensor_svd_algo_params_get_dtype(decomposition_utils.SVD_ALGORITHM_MAP[self.algorithm])
+            algo_params = numpy.zeros(1, dtype=dtype)
+            for name in dtype.names:
+                value = getattr(self, f'{self.algorithm}_{name}')
+                if value != 0:
+                    algo_params[name] = value
+                    initialized = True
+        if initialized:
+            return algo_params
+        else:
+            return None
diff --git a/python/cuquantum/cutensornet/tensor_network.py b/python/cuquantum/cutensornet/tensor_network.py
index f27eed1..c6f4528 100644
--- a/python/cuquantum/cutensornet/tensor_network.py
+++ b/python/cuquantum/cutensornet/tensor_network.py
@@ -532,7 +532,13 @@ def contract_path(self, optimize=None, **kwargs):
             self._set_optimizer_options(optimize)
             # Find "optimal" path.
             self.logger.info("Finding optimal path as well as sliced modes...")
-            cutn.contraction_optimize(self.handle, self.network, self.optimizer_config_ptr, self.memory_limit, self.optimizer_info_ptr)
+            try:
+                cutn.contraction_optimize(
+                    self.handle, self.network, self.optimizer_config_ptr, self.memory_limit, self.optimizer_info_ptr)
+            except cutn.cuTensorNetError as e:
+                if 'INTERRUPTED' in str(e):
+                    raise KeyboardInterrupt from e
+                raise
             self.logger.info("Finished finding optimal path as well as sliced modes.")
         else:
             self.logger.info("Setting user-provided path...")
diff --git a/python/cuquantum/utils.pyx b/python/cuquantum/utils.pyx
index 9e0a71b..d3d6bc7 100644
--- a/python/cuquantum/utils.pyx
+++ b/python/cuquantum/utils.pyx
@@ -145,3 +145,41 @@ class libraryPropertyType(IntEnum):
     PATCH_LEVEL = 2
 
 del IntEnum
+
+
+# Defined in CPython:
+# https://github.com/python/cpython/blob/26bc2cc06128890ac89492eca20e83abe0789c1c/Objects/unicodetype_db.h#L6311-L6349
+cdef int[29] _WHITESPACE_UNICODE_INTS = [
+    0x0009,
+    0x000A,
+    0x000B,
+    0x000C,
+    0x000D,
+    0x001C,
+    0x001D,
+    0x001E,
+    0x001F,
+    0x0020,
+    0x0085,
+    0x00A0,
+    0x1680,
+    0x2000,
+    0x2001,
+    0x2002,
+    0x2003,
+    0x2004,
+    0x2005,
+    0x2006,
+    0x2007,
+    0x2008,
+    0x2009,
+    0x200A,
+    0x2028,
+    0x2029,
+    0x202F,
+    0x205F,
+    0x3000,
+]
+
+
+WHITESPACE_UNICODE = ''.join(chr(s) for s in _WHITESPACE_UNICODE_INTS)
diff --git a/python/samples/custatevec/batched_abs2sum.py b/python/samples/custatevec/batched_abs2sum.py
new file mode 100644
index 0000000..343911e
--- /dev/null
+++ b/python/samples/custatevec/batched_abs2sum.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+import cupy as cp
+
+from cuquantum import custatevec as cusv
+from cuquantum import cudaDataType
+
+
+nSVs         = 2
+nIndexBits   = 3
+svStride     = (1 << nIndexBits)
+
+# square absolute values of state vector elements for 0/2-th bits will be summed up
+# bit ordering should only live on host.
+bitOrdering  = np.asarray([1], dtype=np.int32)
+bitStringLen = bitOrdering.size
+
+# 2 state vectors are allocated contiguously in single memory chunk.
+d_svs        = cp.asarray([[0.0  + 0.0j,  0.0  + 0.1j,  0.1  + 0.1j,  0.1  + 0.2j, 
+                            0.2  + 0.2j,  0.3  + 0.3j,  0.3  + 0.4j,  0.4  + 0.5j],
+                           [0.25 + 0.25j, 0.25 + 0.25j, 0.25 + 0.25j, 0.25 + 0.25j,
+                            0.25 + 0.25j, 0.25 + 0.25j, 0.25 + 0.25j, 0.25 + 0.25j]], dtype=cp.complex64)
+
+abs2sumStride = 2
+batchedAbs2sumSize = nSVs * abs2sumStride
+
+# abs2sum arrays are allocated contiguously in single memory chunk
+# Note: abs2sum can also live on the host.
+abs2sum = cp.empty(batchedAbs2sumSize, dtype=cp.float64)
+abs2sum_res = cp.asarray([0.27, 0.73, 0.5, 0.5], dtype=cp.float64)
+
+###################################################################################
+
+# cuStateVec handle initialization
+handle = cusv.create()
+
+# compute abs2sum arrays
+cusv.abs2sum_array_batched(
+    handle, d_svs.data.ptr, cudaDataType.CUDA_C_32F, nIndexBits, nSVs, svStride,
+    abs2sum.data.ptr, abs2sumStride,
+    bitOrdering.ctypes.data, bitStringLen, 0, 0, 0)
+
+# destroy handle
+cusv.destroy(handle)
+
+# check result
+if not cp.allclose(abs2sum_res, abs2sum):
+    raise ValueError("results mismatch")
+print("test passed")
diff --git a/python/samples/custatevec/batched_collapse.py b/python/samples/custatevec/batched_collapse.py
new file mode 100644
index 0000000..b33fc18
--- /dev/null
+++ b/python/samples/custatevec/batched_collapse.py
@@ -0,0 +1,68 @@
+# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+import cupy as cp
+
+from cuquantum import custatevec as cusv
+from cuquantum import cudaDataType
+
+
+nSVs         = 2
+nIndexBits   = 3
+svStride     = (1 << nIndexBits)
+
+# 2 state vectors are allocated contiguously in single memory chunk.
+d_svs        = cp.asarray([[0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                            0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.4+0.5j],
+                           [0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                            0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.4+0.5j]], dtype=cp.complex64)
+
+d_svs_res    = cp.asarray([[0.0+0.0j, 0.0+1.0j, 0.0+0.0j, 0.0+0.0j, 
+                            0.0+0.0j, 0.0+0.0j, 0.0+0.0j, 0.0+0.0j],
+                           [0.0+0.0j, 0.0+0.0j, 0.0+0.0j, 0.0+0.0j,
+                            0.0+0.0j, 0.0+0.0j, 0.6+0.8j, 0.0+0.0j]], dtype=cp.complex64)
+
+# 2 bitStrings are allocated contiguously in single memory chunk.
+# The 1st SV collapses to |001> and the 2nd to |110>
+# Note: bitStrings can also live on the host.
+bitStrings   = cp.asarray([0b001, 0b110], dtype=cp.int64)
+
+# bit ordering should only live on host.
+bitOrdering  = np.asarray([0, 1, 2], dtype=np.int32)
+bitStringLen = bitOrdering.size
+
+# 2 norms are allocated contiguously in single memory chunk.
+# Note: norms can also live on the host.
+norms        = cp.asarray([0.01, 0.25], dtype=cp.float64)
+
+###################################################################################
+
+# cuStateVec handle initialization
+handle = cusv.create()
+
+# check the size of external workspace
+extraWorkspaceSizeInBytes = cusv.collapse_by_bitstring_batched_get_workspace_size(
+    handle, nSVs, bitStrings.data.ptr, norms.data.ptr)
+
+# allocate external workspace if necessary
+if extraWorkspaceSizeInBytes > 0:
+    workspace = cp.cuda.alloc(extraWorkspaceSizeInBytes)
+    workspace_ptr = workspace.ptr
+else:
+    workspace_ptr = 0
+
+# collapse the quantum states to the target bitstrings
+cusv.collapse_by_bitstring_batched(
+    handle, d_svs.data.ptr, cudaDataType.CUDA_C_32F, nIndexBits, nSVs, svStride,
+    bitStrings.data.ptr, bitOrdering.ctypes.data, bitStringLen, norms.data.ptr,
+    workspace_ptr, extraWorkspaceSizeInBytes)
+
+# destroy handle
+cusv.destroy(handle)
+
+# check result
+if not cp.allclose(d_svs_res, d_svs):
+    raise ValueError("results mismatch")
+print("test passed")
diff --git a/python/samples/custatevec/batched_gate_application.py b/python/samples/custatevec/batched_gate_application.py
new file mode 100644
index 0000000..37cf6bf
--- /dev/null
+++ b/python/samples/custatevec/batched_gate_application.py
@@ -0,0 +1,78 @@
+# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+import cupy as cp
+
+from cuquantum import custatevec as cusv
+from cuquantum import cudaDataType, ComputeType
+
+
+nSVs          = 2
+nIndexBits    = 3
+svSize        = (1 << nIndexBits)
+svStride      = svSize
+adjoint       = 0
+
+targets       = [2]
+nTargets      = len(targets)
+controls      = [0, 1]
+nControls     = len(controls)
+
+matrixIndices = [1, 0]
+nMatrices     = len(matrixIndices)
+
+# 2 state vectors are allocated contiguously in single memory chunk.
+d_svs         = cp.asarray([[0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                             0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.4+0.5j],
+                            [0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                             0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.4+0.5j]], dtype=cp.complex64)
+
+d_svs_res     = cp.asarray([[0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                            0.2+0.2j, 0.3+0.3j, 0.3+0.4j, -0.4-0.5j],
+                           [0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.4+0.5j, 
+                            0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.1+0.2j]], dtype=cp.complex64)
+
+# 2 gate matrices are allocated contiguously in single memory chunk.
+# Note: gate matrices can also live on the host.
+d_matrices    = cp.asarray([[0.0+0.0j, 1.0+0.0j, 
+                             1.0+0.0j, 0.0+0.0j],
+                            [1.0+0.0j, 0.0+0.0j, 
+                             0.0+0.0j, -1.0+0.0j]], dtype=cp.complex64)
+
+###################################################################################
+
+# cuStateVec handle initialization
+handle = cusv.create()
+
+# check the size of external workspace
+extraWorkspaceSizeInBytes = cusv.apply_matrix_batched_get_workspace_size(
+    handle, cudaDataType.CUDA_C_32F, nIndexBits, nSVs, svStride,
+    cusv.MatrixMapType.MATRIX_INDEXED, matrixIndices, d_matrices.data.ptr,
+    cudaDataType.CUDA_C_32F, cusv.MatrixLayout.ROW, adjoint, nMatrices,
+    nTargets, nControls,
+    ComputeType.COMPUTE_32F)
+
+# allocate external workspace if necessary
+if extraWorkspaceSizeInBytes > 0:
+    workspace = cp.cuda.alloc(extraWorkspaceSizeInBytes)
+    workspace_ptr = workspace.ptr
+else:
+    workspace_ptr = 0
+
+# apply gate
+cusv.apply_matrix_batched(
+    handle, d_svs.data.ptr, cudaDataType.CUDA_C_32F, nIndexBits, nSVs, svStride,
+    cusv.MatrixMapType.MATRIX_INDEXED, matrixIndices, d_matrices.data.ptr,
+    cudaDataType.CUDA_C_32F, cusv.MatrixLayout.ROW, adjoint, nMatrices,
+    targets, nTargets, controls, 0, nControls,
+    ComputeType.COMPUTE_32F, workspace_ptr, extraWorkspaceSizeInBytes)
+
+# destroy handle
+cusv.destroy(handle)
+
+# check result
+if not cp.allclose(d_svs_res, d_svs):
+    raise ValueError("results mismatch")
+print("test passed")
diff --git a/python/samples/custatevec/batched_measure.py b/python/samples/custatevec/batched_measure.py
new file mode 100644
index 0000000..138a4bd
--- /dev/null
+++ b/python/samples/custatevec/batched_measure.py
@@ -0,0 +1,59 @@
+# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import numpy as np
+import cupy as cp
+
+from cuquantum import custatevec as cusv
+from cuquantum import cudaDataType
+
+
+nSVs         = 2
+nIndexBits   = 3
+svStride     = (1 << nIndexBits)
+
+# bit ordering should only live on host.
+bitOrdering  = np.asarray([2, 1, 0], dtype=np.int32)
+bitStringLen = bitOrdering.size
+
+# 2 bitStrings are allocated contiguously in single memory chunk.
+# Note: bitStrings can also live on the host.
+bitStrings   = cp.empty(2, dtype=cp.int64)
+bitStrings_res = cp.asarray([0b100, 0b011], dtype=cp.int64)
+
+# In real appliction, random number in range [0, 1) will be used.
+# Note: norms can also live on the host.
+randnums     = cp.asarray([0.009, 0.5], dtype=cp.float64)
+
+# 2 state vectors are allocated contiguously in single memory chunk.
+d_svs        = cp.asarray([[0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                            0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.4+0.5j],
+                           [0.0+0.0j, 0.0+0.1j, 0.1+0.1j, 0.1+0.2j, 
+                            0.2+0.2j, 0.3+0.3j, 0.3+0.4j, 0.4+0.5j]], dtype=cp.complex64)
+
+d_svs_res    = cp.asarray([[0.0+0.0j, 0.0+1.0j, 0.0+0.0j, 0.0+0.0j, 
+                            0.0+0.0j, 0.0+0.0j, 0.0+0.0j, 0.0+0.0j],
+                           [0.0+0.0j, 0.0+0.0j, 0.0+0.0j, 0.0+0.0j,
+                            0.0+0.0j, 0.0+0.0j, 0.6+0.8j, 0.0+0.0j]], dtype=cp.complex64)
+
+###################################################################################
+
+# cuStateVec handle initialization
+handle = cusv.create()
+
+# batched measurement
+cusv.measure_batched(
+    handle, d_svs.data.ptr, cudaDataType.CUDA_C_32F, nIndexBits, nSVs, svStride,
+    bitStrings.data.ptr, bitOrdering.ctypes.data, bitStringLen,
+    randnums.data.ptr, cusv.Collapse.NORMALIZE_AND_ZERO)
+
+# destroy handle
+cusv.destroy(handle)
+
+# check result
+if not cp.allclose(d_svs_res, d_svs):
+    raise ValueError("results mismatch")
+if not cp.allclose(bitStrings_res, bitStrings):
+    raise ValueError("results mismatch")
+print("test passed")
diff --git a/python/samples/custatevec/initialize_sv.py b/python/samples/custatevec/initialize_sv.py
new file mode 100644
index 0000000..47c84ef
--- /dev/null
+++ b/python/samples/custatevec/initialize_sv.py
@@ -0,0 +1,37 @@
+# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import cupy as cp
+
+from cuquantum import custatevec as cusv
+from cuquantum import cudaDataType
+
+
+nIndexBits   = 3
+svSize       = (1 << nIndexBits)
+
+# populate the device memory with junk values (for illustrative purpose only)
+# (we create a real random array of twice length, and view it as a complex array)
+d_sv         = cp.random.random(2*svSize, dtype=cp.float32).view(cp.complex64)
+
+d_sv_res     = cp.asarray([[1.0+0.0j, 0.0+0.0j, 0.0+0.0j, 0.0+0.0j, 
+                            0.0+0.0j, 0.0+0.0j, 0.0+0.0j, 0.0+0.0j]], dtype=cp.complex64)
+
+###################################################################################
+
+# cuStateVec handle initialization
+handle = cusv.create()
+
+# initialize the state vector
+cusv.initialize_state_vector(
+    handle, d_sv.data.ptr, cudaDataType.CUDA_C_32F, nIndexBits,
+    cusv.StateVectorType.ZERO) 
+
+# destroy handle
+cusv.destroy(handle)
+
+# check result
+if not cp.allclose(d_sv_res, d_sv):
+    raise ValueError("results mismatch")
+print("test passed")
diff --git a/python/samples/cutensornet/approxTN/tensor_svd_example.py b/python/samples/cutensornet/approxTN/tensor_svd_example.py
index 70aeb7b..07a5aac 100644
--- a/python/samples/cutensornet/approxTN/tensor_svd_example.py
+++ b/python/samples/cutensornet/approxTN/tensor_svd_example.py
@@ -91,7 +91,21 @@
 cutn.tensor_svd_config_set_attribute(handle,
     svd_config, cutn.TensorSVDConfigAttribute.REL_CUTOFF, rel_cutoff.ctypes.data, rel_cutoff.dtype.itemsize)
 
-print("Setup SVD truncation parameters.")
+# optional: choose gesvdj algorithm with customized parameters. Default is gesvd.
+algorithm_dtype = cutn.tensor_svd_config_get_attribute_dtype(cutn.TensorSVDConfigAttribute.ALGO)
+algorithm = np.array(cutn.TensorSVDAlgo.GESVDJ, dtype=algorithm_dtype)
+cutn.tensor_svd_config_set_attribute(handle,
+    svd_config, cutn.TensorSVDConfigAttribute.ALGO, algorithm.ctypes.data, algorithm.dtype.itemsize)
+
+algo_params_dtype = cutn.tensor_svd_algo_params_get_dtype(cutn.TensorSVDAlgo.GESVDJ)
+algo_params = np.zeros(1, dtype=algo_params_dtype)
+algo_params['tol'] = 1e-12
+algo_params['max_sweeps'] = 80
+
+cutn.tensor_svd_config_set_attribute(handle,
+    svd_config, cutn.TensorSVDConfigAttribute.ALGO_PARAMS, algo_params.ctypes.data, algo_params.dtype.itemsize)
+
+print("Set up SVDConfig to use gesvdj algorithm with truncation")
 
 # create SVDInfo to record truncation information
 svd_info = cutn.create_tensor_svd_info(handle)
@@ -172,8 +186,14 @@
     svd_info, cutn.TensorSVDInfoAttribute.DISCARDED_WEIGHT, discarded_weight.ctypes.data, discarded_weight.itemsize)
 discarded_weight = float(discarded_weight)
 
+algo_status_dtype = cutn.tensor_svd_algo_status_get_dtype(cutn.TensorSVDAlgo.GESVDJ)
+algo_status = np.empty(1, dtype=algo_status_dtype)
+cutn.tensor_svd_info_get_attribute(handle, 
+    svd_info, cutn.TensorSVDInfoAttribute.ALGO_STATUS, algo_status.ctypes.data, algo_status.itemsize)
+
 print(f"Execution time: {min_time_cutensornet} ms")
 print("SVD truncation info:")
+print(f"GESVDJ residual: {algo_status['residual'].item()}, runtime sweeps = {algo_status['sweeps'].item()}")
 print(f"For fixed extent truncation of {shared_extent}, an absolute cutoff value of {float(abs_cutoff)}, and a relative cutoff value of {float(rel_cutoff)}, full extent {full_extent} is reduced to {reduced_extent}")
 print(f"Discarded weight: {discarded_weight}")
 
diff --git a/python/samples/cutensornet/coarse/example12.py b/python/samples/cutensornet/coarse/example12.py
index 7c939aa..10f2825 100644
--- a/python/samples/cutensornet/coarse/example12.py
+++ b/python/samples/cutensornet/coarse/example12.py
@@ -32,6 +32,7 @@
 
 if flops != flops_np or largest != largest_np:
     message = f""" Results don't match.
+path = {path_np}
 flops: NumPy = {flops_np}, cuTensorNet = {flops},
 largest intermediate: NumPy  = {largest_np}, cuTensorNet = {largest}
 """
diff --git a/python/samples/cutensornet/high_level/marginal_example.py b/python/samples/cutensornet/high_level/marginal_example.py
new file mode 100755
index 0000000..c23e208
--- /dev/null
+++ b/python/samples/cutensornet/high_level/marginal_example.py
@@ -0,0 +1,123 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import cupy as cp
+import numpy as np
+
+import cuquantum
+from cuquantum import cutensornet as cutn
+
+
+print("cuTensorNet-vers:", cutn.get_version())
+dev = cp.cuda.Device()  # get current device
+props = cp.cuda.runtime.getDeviceProperties(dev.id)
+print("===== device info ======")
+print("GPU-name:", props["name"].decode())
+print("GPU-clock:", props["clockRate"])
+print("GPU-memoryClock:", props["memoryClockRate"])
+print("GPU-nSM:", props["multiProcessorCount"])
+print("GPU-major:", props["major"])
+print("GPU-minor:", props["minor"])
+print("========================")
+
+#################################################
+# Marginal computation of a quantum circuit state
+#################################################
+
+# Quantum state configuration
+num_qubits = 16
+dim = 2
+qubits_dims = (dim, ) * num_qubits # qubit size
+marginal_modes = (0, 1) # open qubits
+num_marginal_modes = len(marginal_modes)
+print(f"Quantum circuit with {num_qubits} qubits")
+
+#############
+# cuTensorNet
+#############
+
+handle = cutn.create()
+stream = cp.cuda.Stream()
+data_type = cuquantum.cudaDataType.CUDA_C_64F
+
+# Define quantum gate tensors on device
+gate_h = 2**-0.5 * cp.asarray([[1,1], [1,-1]], dtype='complex128', order='F')
+gate_h_strides = 0
+
+gate_cx = cp.asarray([[1, 0, 0, 0],
+                      [0, 1, 0, 0],
+                      [0, 0, 0, 1],
+                      [0, 0, 1, 0]], dtype='complex128').reshape(2,2,2,2, order='F')
+gate_cx_strides = 0
+
+# Allocate device memory for the reduced density matrix (marginal)
+rdm_shape = (dim, ) * 2 * len(marginal_modes)
+rdm = cp.empty(rdm_shape, dtype='complex128')
+rdm_strides = [stride_in_bytes // rdm.itemsize for stride_in_bytes in rdm.strides]
+
+# Create the initial quantum state
+quantum_state = cutn.create_state(handle, cutn.StatePurity.PURE, num_qubits, qubits_dims, data_type)
+print("Created the initial quantum state")
+
+# Construct the quantum circuit state with gate application
+tensor_id = cutn.state_apply_tensor(
+        handle, quantum_state, 1, (0, ), 
+        gate_h.data.ptr, gate_h_strides, 1, 0, 1)
+
+for i in range(1, num_qubits):
+    tensor_id = cutn.state_apply_tensor(
+        handle, quantum_state, 2, (i-1, i),  # target on i-1 while control on i
+        gate_cx.data.ptr, gate_cx_strides, 1, 0, 1)
+print("Quantum gates applied")
+
+# Specify the desired reduced density matrix (marginal)
+marginal = cutn.create_marginal(handle, quantum_state, num_marginal_modes, marginal_modes, 0, 0, rdm_strides)
+
+free_mem = dev.mem_info[0]
+# use half of the totol free size
+scratch_size = free_mem // 2
+scratch_space = cp.cuda.alloc(scratch_size)
+print(f"Allocated {scratch_size} bytes of scratch memory on GPU")
+
+num_hyper_samples_dtype = cutn.marginal_get_attribute_dtype(cutn.MarginalAttribute.OPT_NUM_HYPER_SAMPLES)
+num_hyper_samples = np.asarray(8, dtype=num_hyper_samples_dtype)
+cutn.marginal_configure(handle, marginal, 
+    cutn.MarginalAttribute.OPT_NUM_HYPER_SAMPLES, 
+    num_hyper_samples.ctypes.data, num_hyper_samples.dtype.itemsize)
+
+# Prepare the specified quantum circuit reduced densitry matrix (marginal)
+work_desc = cutn.create_workspace_descriptor(handle)
+cutn.marginal_prepare(handle, marginal, scratch_size, work_desc, stream.ptr)
+print("Prepared the specified quantum circuit reduced density matrix (marginal)")
+
+workspace_size_d = cutn.workspace_get_memory_size(handle, 
+    work_desc, cutn.WorksizePref.RECOMMENDED, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH)
+
+if workspace_size_d <= scratch_size:
+    cutn.workspace_set_memory(handle, work_desc, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH, scratch_space.ptr, workspace_size_d)
+else:
+    print("Error:Insufficient workspace size on Device")
+    cutn.destroy_workspace_descriptor(work_desc)
+    cutn.destroy_marginal(marginal)
+    cutn.destroy_state(quantum_state)
+    cutn.destroy(handle)
+    del scratch
+    print("Free resource and exit.")
+    exit()
+print("Set the workspace buffer")
+
+# Compute the specified quantum circuit reduced density matrix (marginal)
+cutn.marginal_compute(handle, marginal, 0, work_desc, rdm.data.ptr, stream.ptr)
+stream.synchronize()
+print("Computed the specified quantum circuit reduced density matrix (marginal)")
+
+print(f"Reduced density matrix for {num_marginal_modes} qubits")
+print(rdm.reshape(dim**num_marginal_modes, dim**num_marginal_modes))
+
+cutn.destroy_workspace_descriptor(work_desc)
+cutn.destroy_marginal(marginal)
+cutn.destroy_state(quantum_state)
+cutn.destroy(handle)
+del scratch_space
+print("Free resource and exit.")
\ No newline at end of file
diff --git a/python/samples/cutensornet/high_level/sampling_example.py b/python/samples/cutensornet/high_level/sampling_example.py
new file mode 100755
index 0000000..948d182
--- /dev/null
+++ b/python/samples/cutensornet/high_level/sampling_example.py
@@ -0,0 +1,119 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import cupy as cp
+import numpy as np
+
+import cuquantum
+from cuquantum import cutensornet as cutn
+
+
+print("cuTensorNet-vers:", cutn.get_version())
+dev = cp.cuda.Device()  # get current device
+props = cp.cuda.runtime.getDeviceProperties(dev.id)
+print("===== device info ======")
+print("GPU-name:", props["name"].decode())
+print("GPU-clock:", props["clockRate"])
+print("GPU-memoryClock:", props["memoryClockRate"])
+print("GPU-nSM:", props["multiProcessorCount"])
+print("GPU-major:", props["major"])
+print("GPU-minor:", props["minor"])
+print("========================")
+
+#####################################
+# Sampling of a quantum circuit state
+#####################################
+
+# Quantum state configuration
+num_samples = 100
+num_qubits = 16
+dim = 2
+qubits_dims = (dim, ) * num_qubits # qubit size
+print(f"Quantum circuit with {num_qubits} qubits")
+
+#############
+# cuTensorNet
+#############
+
+handle = cutn.create()
+stream = cp.cuda.Stream()
+data_type = cuquantum.cudaDataType.CUDA_C_64F
+
+# Define quantum gate tensors in host memory
+gate_h = 2**-0.5 * cp.asarray([[1,1], [1,-1]], dtype='complex128', order='F')
+gate_h_strides = 0
+
+gate_cx = cp.asarray([[1, 0, 0, 0],
+                      [0, 1, 0, 0],
+                      [0, 0, 0, 1],
+                      [0, 0, 1, 0]], dtype='complex128').reshape(2,2,2,2, order='F')
+gate_cx_strides = 0
+
+# Allocate device memory for the samples
+samples = np.empty((num_qubits, num_samples), dtype='int64', order='F') # samples are stored in F order with shape (num_qubits, num_qubits)
+# Create the initial quantum state
+quantum_state = cutn.create_state(handle, cutn.StatePurity.PURE, num_qubits, qubits_dims, data_type)
+print("Created the initial quantum state")
+
+# Construct the quantum circuit state with gate application
+tensor_id = cutn.state_apply_tensor(
+        handle, quantum_state, 1, (0, ), 
+        gate_h.data.ptr, gate_h_strides, 1, 0, 1)
+
+for i in range(1, num_qubits):
+    tensor_id = cutn.state_apply_tensor(
+        handle, quantum_state, 2, (i-1, i),  # target on i-1 while control on i
+        gate_cx.data.ptr, gate_cx_strides, 1, 0, 1)
+
+print("Quantum gates applied")
+
+# Create the quantum circuit sampler
+sampler = cutn.create_sampler(handle, quantum_state, num_qubits, 0)
+
+free_mem = dev.mem_info[0]
+# use half of the totol free size
+scratch_size = free_mem // 2
+scratch_space = cp.cuda.alloc(scratch_size)
+print(f"Allocated {scratch_size} bytes of scratch memory on GPU")
+
+num_hyper_samples_dtype = cutn.sampler_get_attribute_dtype(cutn.SamplerAttribute.OPT_NUM_HYPER_SAMPLES)
+num_hyper_samples = np.asarray(8, dtype=num_hyper_samples_dtype)
+cutn.sampler_configure(handle, sampler, 
+    cutn.SamplerAttribute.OPT_NUM_HYPER_SAMPLES, 
+    num_hyper_samples.ctypes.data, num_hyper_samples.dtype.itemsize)
+
+# Prepare the quantum circuit sampler
+work_desc = cutn.create_workspace_descriptor(handle)
+cutn.sampler_prepare(handle, sampler, scratch_size, work_desc, stream.ptr)
+print("Prepared the specified quantum circuit state sampler")
+
+workspace_size_d = cutn.workspace_get_memory_size(handle, 
+    work_desc, cutn.WorksizePref.RECOMMENDED, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH)
+
+if workspace_size_d <= scratch_size:
+    cutn.workspace_set_memory(handle, work_desc, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH, scratch_space.ptr, workspace_size_d)
+else:
+    print("Error:Insufficient workspace size on Device")
+    cutn.destroy_workspace_descriptor(work_desc)
+    cutn.destroy_sampler(sampler)
+    cutn.destroy_state(quantum_state)
+    cutn.destroy(handle)
+    del scratch
+    print("Free resource and exit.")
+    exit()
+print("Set the workspace buffer")
+
+# Sample the quantum circuit state
+cutn.sampler_sample(handle, sampler, num_samples, work_desc, samples.ctypes.data, stream.ptr)
+stream.synchronize()
+print("Performed quantum circuit state sampling")
+print("Bit-string samples:")
+print(samples.T)
+
+cutn.destroy_workspace_descriptor(work_desc)
+cutn.destroy_sampler(sampler)
+cutn.destroy_state(quantum_state)
+cutn.destroy(handle)
+del scratch_space
+print("Free resource and exit.")
diff --git a/python/samples/cutensornet/tensor/example11-svd_algorithms.py b/python/samples/cutensornet/tensor/example11-svd_algorithms.py
new file mode 100644
index 0000000..05ffdea
--- /dev/null
+++ b/python/samples/cutensornet/tensor/example11-svd_algorithms.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+truncated SVD Example using NumPy ndarray with various SVD algorithms.
+
+The decomposition results are also NumPy ndarrays.
+"""
+import numpy as np
+
+from cuquantum import tensor
+
+
+a = np.ones((3,2,4,5))
+
+base_options = {'max_extent': 4,
+                'abs_cutoff': 0.1,
+                'rel_cutoff': 0.1}
+
+
+for algorithm in ('gesvd', 'gesvdj', 'gesvdr', 'gesvdp'):
+    method = tensor.SVDMethod(algorithm=algorithm, **base_options)
+    u, s, v, info = tensor.decompose("ijab->ixa,xbj", a, method=method, return_info=True)
+    print(s)
+    print(info)
+
diff --git a/python/samples/cutensornet/tensornet_example_gradients.py b/python/samples/cutensornet/tensornet_example_gradients.py
new file mode 100644
index 0000000..434f6cd
--- /dev/null
+++ b/python/samples/cutensornet/tensornet_example_gradients.py
@@ -0,0 +1,342 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import cupy as cp
+import numpy as np
+try:
+    import torch
+except ImportError:
+    torch = None
+
+import cuquantum
+from cuquantum import cutensornet as cutn
+
+
+print("cuTensorNet-vers:", cutn.get_version())
+dev = cp.cuda.Device()  # get current device
+props = cp.cuda.runtime.getDeviceProperties(dev.id)
+print("===== device info ======")
+print("GPU-name:", props["name"].decode())
+print("GPU-clock:", props["clockRate"])
+print("GPU-memoryClock:", props["memoryClockRate"])
+print("GPU-nSM:", props["multiProcessorCount"])
+print("GPU-major:", props["major"])
+print("GPU-minor:", props["minor"])
+print("========================")
+
+##########################################################################################
+# Computing: O_{a,m} = A_{a,b,c,d} B_{b,c,d,e} C_{e,g,h} D_{g,h,i,j} E_{i,j,k,l} F_{k,l,m}
+# We will execute the contraction and compute the gradients of input tensors A, B, C
+##########################################################################################
+
+print("Include headers and define data types.")
+
+data_type = cuquantum.cudaDataType.CUDA_R_32F
+compute_type = cuquantum.ComputeType.COMPUTE_32F
+num_inputs = 6
+grad_input_ids = np.asarray((0, 1, 2), dtype=np.int32)
+
+# Create an array of modes
+modes_A = [ord(c) for c in ('a','b','c','d')]
+modes_B = [ord(c) for c in ('b','c','d','e')]
+modes_C = [ord(c) for c in ('e','g','h')]
+modes_D = [ord(c) for c in ('g','h','i','j')]
+modes_E = [ord(c) for c in ('i','j','k','l')]
+modes_F = [ord(c) for c in ('k','l','m')]
+modes_O = [ord(c) for c in ('a','m')]
+
+# Create an array of extents (shapes) for each tensor
+dim = 36
+extent_A = (dim,) * len(modes_A)
+extent_B = (dim,) * len(modes_B)
+extent_C = (dim,) * len(modes_C)
+extent_D = (dim,) * len(modes_D)
+extent_E = (dim,) * len(modes_E)
+extent_F = (dim,) * len(modes_F)
+extent_O = (dim,) * len(modes_O)
+
+print("Define network, modes, and extents.")
+
+#################
+# Initialize data
+#################
+
+A_d = cp.random.random((np.prod(extent_A),), dtype=np.float32)
+B_d = cp.random.random((np.prod(extent_B),), dtype=np.float32)
+C_d = cp.random.random((np.prod(extent_C),), dtype=np.float32)
+D_d = cp.random.random((np.prod(extent_D),), dtype=np.float32)
+E_d = cp.random.random((np.prod(extent_E),), dtype=np.float32)
+F_d = cp.random.random((np.prod(extent_F),), dtype=np.float32)
+O_d = cp.zeros((np.prod(extent_O),), dtype=np.float32)
+raw_data_in_d = (A_d.data.ptr, B_d.data.ptr, C_d.data.ptr, D_d.data.ptr, E_d.data.ptr, F_d.data.ptr)
+
+# allocate buffers for holding the gradients w.r.t. the first 3 input tensors
+grads_d = [cp.empty_like(A_d),
+           cp.empty_like(B_d),
+           cp.empty_like(C_d),
+           None,
+           None,
+           None]
+grads_d_ptr = [grad.data.ptr if grad is not None else 0 for grad in grads_d]
+
+# output gradients (w.r.t itself, so it's all one)
+output_grads_d = cp.ones(extent_O, dtype=np.float32, order='F')
+
+#############
+# cuTensorNet
+#############
+
+stream = cp.cuda.Stream()
+handle = cutn.create()
+
+nmode_A = len(modes_A)
+nmode_B = len(modes_B)
+nmode_C = len(modes_C)
+nmode_D = len(modes_D)
+nmode_E = len(modes_E)
+nmode_F = len(modes_F)
+nmode_O = len(modes_O)
+
+###############################
+# Create Contraction Descriptor
+###############################
+
+modes_in = (modes_A, modes_B, modes_C, modes_D, modes_E, modes_F)
+extents_in = (extent_A, extent_B, extent_C, extent_D, extent_E, extent_F)
+num_modes_in = (nmode_A, nmode_B, nmode_C, nmode_D, nmode_E, nmode_F)
+
+# Strides are optional; if no stride (0) is provided, then cuTensorNet assumes a generalized column-major data layout
+strides_in = (0, 0, 0, 0, 0, 0)
+
+# Set up tensor network
+desc_net = cutn.create_network_descriptor(handle,
+    num_inputs, num_modes_in, extents_in, strides_in, modes_in, 0,  # inputs
+    nmode_O, extent_O, 0, modes_O,  # output
+    data_type, compute_type)
+
+# In this sample we use the new network attributes interface to mark certain
+# input tensors as constant, but we can also use the tensor qualifiers as shown
+# in other samples (ex: tensornet_example_reuse.py)
+net_attr_dtype = cutn.network_get_attribute_dtype(cutn.NetworkAttribute.INPUT_TENSORS_REQUIRE_GRAD)
+tensor_ids = np.zeros(1, dtype=net_attr_dtype)
+tensor_ids['num_tensors'] = grad_input_ids.size
+tensor_ids['data'] = grad_input_ids.ctypes.data
+cutn.network_set_attribute(
+    handle, desc_net, cutn.NetworkAttribute.INPUT_TENSORS_REQUIRE_GRAD,
+    tensor_ids.ctypes.data, tensor_ids.dtype.itemsize)
+
+print("Initialize the cuTensorNet library and create a network descriptor.")
+
+#####################################################
+# Choose workspace limit based on available resources
+#####################################################
+
+free_mem, total_mem = dev.mem_info
+workspace_limit = int(free_mem * 0.9)
+
+#######################
+# Set contraction order
+#######################
+
+# create contraction optimizer info
+optimizer_info = cutn.create_contraction_optimizer_info(handle, desc_net)
+
+# set a predetermined contraction path
+path_dtype = cutn.contraction_optimizer_info_get_attribute_dtype(cutn.ContractionOptimizerInfoAttribute.PATH)
+path = np.asarray([(0, 1), (0, 4), (0, 3), (0, 2), (0, 1)], dtype=np.int32)
+path_obj = np.zeros((1,), dtype=path_dtype)
+path_obj["num_contractions"] = num_inputs - 1
+path_obj["data"] = path.ctypes.data
+
+# provide user-specified contract path
+cutn.contraction_optimizer_info_set_attribute(
+    handle, optimizer_info, cutn.ContractionOptimizerInfoAttribute.PATH, 
+    path_obj.ctypes.data, path_obj.dtype.itemsize)
+
+num_slices = 1
+
+print("Set predetermined contraction path into cuTensorNet optimizer.")
+
+#############################################################
+# Create workspace descriptor, allocate workspace, and set it
+#############################################################
+
+work_desc = cutn.create_workspace_descriptor(handle)
+
+# set SCRATCH workspace, which will be used during each network contraction operation, not needed afterwords
+cutn.workspace_compute_contraction_sizes(handle, desc_net, optimizer_info, work_desc)
+required_scratch_workspace_size = cutn.workspace_get_memory_size(
+    handle, work_desc,
+    cutn.WorksizePref.MIN,
+    cutn.Memspace.DEVICE,
+    cutn.WorkspaceKind.SCRATCH)
+work_scratch = cp.cuda.alloc(required_scratch_workspace_size)
+cutn.workspace_set_memory(
+    handle, work_desc,
+    cutn.Memspace.DEVICE,
+    cutn.WorkspaceKind.SCRATCH,
+    work_scratch.ptr, required_scratch_workspace_size)
+
+# set CACHE workspace, which will be used across network contraction operations
+required_cache_workspace_size = cutn.workspace_get_memory_size(
+    handle, work_desc,
+    cutn.WorksizePref.MIN,
+    cutn.Memspace.DEVICE,
+    cutn.WorkspaceKind.CACHE)
+work_cache = cp.cuda.alloc(required_cache_workspace_size)
+cutn.workspace_set_memory(
+    handle, work_desc,
+    cutn.Memspace.DEVICE,
+    cutn.WorkspaceKind.CACHE,
+    work_cache.ptr, required_cache_workspace_size)
+
+print("Allocated and set up the GPU workspace")
+
+###########################################################
+# Initialize the pair-wise contraction plans (for cuTENSOR)
+###########################################################
+
+plan = cutn.create_contraction_plan(handle, desc_net, optimizer_info, work_desc)
+
+###################################################################################
+# Optional: Auto-tune cuTENSOR's cutensorContractionPlan to pick the fastest kernel
+###################################################################################
+
+pref = cutn.create_contraction_autotune_preference(handle)
+
+num_autotuning_iterations = 5  # may be 0
+n_iter_dtype = cutn.contraction_autotune_preference_get_attribute_dtype(
+    cutn.ContractionAutotunePreferenceAttribute.MAX_ITERATIONS)
+num_autotuning_iterations = np.asarray([num_autotuning_iterations], dtype=n_iter_dtype)
+cutn.contraction_autotune_preference_set_attribute(
+    handle, pref,
+    cutn.ContractionAutotunePreferenceAttribute.MAX_ITERATIONS,
+    num_autotuning_iterations.ctypes.data, num_autotuning_iterations.dtype.itemsize)
+
+# Modify the plan again to find the best pair-wise contractions
+cutn.contraction_autotune(
+    handle, plan, raw_data_in_d, O_d.data.ptr,
+    work_desc, pref, stream.ptr)
+
+cutn.destroy_contraction_autotune_preference(pref)
+ 
+print("Create a contraction plan for cuTENSOR and optionally auto-tune it.")
+ 
+###########
+# Execution
+###########
+
+# create a cutensornetSliceGroup_t object from a range of slice IDs
+slice_group = cutn.create_slice_group_from_id_range(handle, 0, num_slices, 1)
+
+min_time_cutn = 1e100
+num_runs = 3  # to get stable perf results
+e1 = cp.cuda.Event()
+e2 = cp.cuda.Event()
+
+for i in range(num_runs):
+    # Contract over all slices.
+    e1.record(stream)
+    cutn.contract_slices(
+        handle, plan, raw_data_in_d,
+        O_d.data.ptr,
+        False, work_desc, slice_group, stream.ptr)
+    cutn.compute_gradients_backward(
+        handle, plan, raw_data_in_d,
+        output_grads_d.data.ptr,
+        grads_d_ptr,
+        False, work_desc, stream.ptr)
+    cutn.workspace_purge_cache(handle, work_desc, cutn.Memspace.DEVICE)
+    e2.record(stream)
+
+    # Synchronize and measure timing
+    e2.synchronize()
+    time = cp.cuda.get_elapsed_time(e1, e2) / 1000  # ms -> s
+    min_time_cutn = min_time_cutn if min_time_cutn < time else time
+
+print("Contract the network and compute gradients.")
+
+# free up the workspace
+del work_scratch
+del work_cache
+
+# Recall that we set strides to null (0), so the data are in F-contiguous layout,
+# including the gradients (which follow the layout of the input tensors)
+A_d = A_d.reshape(extent_A, order='F')
+B_d = B_d.reshape(extent_B, order='F')
+C_d = C_d.reshape(extent_C, order='F')
+D_d = D_d.reshape(extent_D, order='F')
+E_d = E_d.reshape(extent_E, order='F')
+F_d = F_d.reshape(extent_F, order='F')
+O_d = O_d.reshape(extent_O, order='F')
+grads_d[0] = grads_d[0].reshape(extent_A, order='F')
+grads_d[1] = grads_d[1].reshape(extent_B, order='F')
+grads_d[2] = grads_d[2].reshape(extent_C, order='F')
+
+# Compute the contraction reference using cupy.einsum with the same path
+path = ['einsum_path'] + path.tolist()
+out = cp.einsum("abcd,bcde,egh,ghij,ijkl,klm->am", A_d, B_d, C_d, D_d, E_d, F_d, optimize=path)
+if not cp.allclose(out, O_d):
+    raise RuntimeError("result is incorrect")
+print("Check cuTensorNet contraction result against that of cupy.einsum().")
+
+# Compute the gradient reference using PyTorch
+if torch:
+    if not torch.cuda.is_available():
+        # copy data back to CPU
+        dev = "cpu"
+        func = cp.asnumpy
+        torch_cuda = False
+    else:
+        # zero-copy from CuPy to PyTorch!
+        dev = "cuda"
+        func = (lambda x: x)  # no op
+        torch_cuda = True
+
+    A = torch.as_tensor(func(A_d), device=dev)
+    B = torch.as_tensor(func(B_d), device=dev)
+    C = torch.as_tensor(func(C_d), device=dev)
+    D = torch.as_tensor(func(D_d), device=dev)
+    E = torch.as_tensor(func(E_d), device=dev)
+    F = torch.as_tensor(func(F_d), device=dev)
+    output_grads = torch.as_tensor(func(output_grads_d), device=dev)
+
+    # do not need gradient for the last 3 tensors
+    A.requires_grad_(True)
+    B.requires_grad_(True)
+    C.requires_grad_(True)
+    D.requires_grad_(False)
+    E.requires_grad_(False)
+    F.requires_grad_(False)
+
+    # We can use either torch.einsum or opt_einsum.contract to establish the
+    # computational graph of an einsum op over the PyTorch tensors. Note that
+    # torch.einsum does not support passing custom contraction paths.
+    out = torch.einsum("abcd,bcde,egh,ghij,ijkl,klm->am", A, B, C, D, E, F)
+    out.backward(output_grads)  # backprop to populate the inputs' .grad attributes
+    if not cp.allclose(cp.asarray(out.detach()), O_d):
+        raise RuntimeError("result is incorrect")
+
+    # If using PyTorch CPU tensors, these move data back to GPU for comparison;
+    # otherwise, PyTorch GPU tensors are zero-copied as CuPy arrays.
+    assert cp.allclose(cp.asarray(A.grad), grads_d[0])
+    assert cp.allclose(cp.asarray(B.grad), grads_d[1])
+    assert cp.allclose(cp.asarray(C.grad), grads_d[2])
+    # Note: D.grad, E.grad, and F.grad do not exist
+
+    print("Check cuTensorNet gradient results against those from "
+          f"PyTorch ({'GPU' if torch_cuda else 'GPU'}).")
+
+#######################################################
+
+print(f"Tensor network contraction and back-propagation time (ms): = {min_time_cutn * 1000}")
+
+cutn.destroy_slice_group(slice_group)
+cutn.destroy_contraction_plan(plan)
+cutn.destroy_workspace_descriptor(work_desc)
+cutn.destroy_contraction_optimizer_info(optimizer_info)
+cutn.destroy_network_descriptor(desc_net)
+cutn.destroy(handle)
+
+print("Free resource and exit.")
diff --git a/python/samples/cutensornet/tn_algorithms/mps_algorithms.ipynb b/python/samples/cutensornet/tn_algorithms/mps_algorithms.ipynb
index 74ba4df..c3ccf11 100644
--- a/python/samples/cutensornet/tn_algorithms/mps_algorithms.ipynb
+++ b/python/samples/cutensornet/tn_algorithms/mps_algorithms.ipynb
@@ -15,13 +15,13 @@
    "id": "61d9c687-8903-4429-8e8a-2ba3b1e62c92",
    "metadata": {},
    "source": [
-    "In this notebook we will go over some examples on how to use cuTensorNet to execute basic MPS algorithms for quantum circuit simulation. \n",
+    "In this notebook we will go over some examples on how to use `cuquantum-python` to execute some MPS algorithms for quantum circuit simulation. \n",
     "\n",
     "This notebook will guide you through the following tasks:\n",
     " - I. Initializing an entangled quantum circuit as a basis.\n",
     " - II. Constructing an MPS from a quantum circuit and verifying its correctness.\n",
     " - III. Computing the expectation value of an MPS, with and without canonicalization.\n",
-    " - IV. Performing MPS-MPO multiplication, with and without approximation.\n",
+    " - IV. Performing MPS-MPO multiplication using two different methods and assessing their accuracy for the approximations.\n",
     "\n",
     "Note that we will use `cupy.ndarray` for operands throughout this notebook."
    ]
@@ -68,9 +68,9 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 1207.22x702.333 with 1 Axes>"
+       "<Figure size 1541.66x702.333 with 1 Axes>"
       ]
      },
      "execution_count": 2,
@@ -118,9 +118,9 @@
     "        circuit = cirq.Circuit(add_entangled_layers(cirq.LineQubit.range(num_qubits), reps))\n",
     "    return circuit\n",
     "\n",
-    "# Example using 8 qubits and 6 repeated entangled layers\n",
+    "# Example using 8 qubits and 8 repeated entangled layers\n",
     "num_qubits = 8\n",
-    "reps = 6 # depth/num of layers\n",
+    "reps = 8 # depth/num of layers\n",
     "\n",
     "backend = 'qiskit' # also works for 'cirq'\n",
     "circuit = get_entangled_circuit(num_qubits, reps, backend)\n",
@@ -144,12 +144,12 @@
     "\n",
     "![mps_diagram.png](attachment:7d5870b7-c80c-4190-b2ed-d598e137dcad.png)\n",
     "\n",
-    "<mark>Note:</mark> In this sample, we've inserted a dummy mode at the beginning and the end of the MPS to make it easier to generalize the handling of boundary conditions. This does not affect the outcome. \n",
+    "<mark>Note:</mark> In this sample, we've inserted a dummy mode of size 1 at the beginning and the end of the MPS to make it easier to generalize the handling of boundary conditions. This does not affect the outcome. \n",
     "\n",
     "The MPS representation of the circuit can be obtained by iteratively applying all gates to the initial MPS (typically $|\\Psi_0\\rangle = |00...00\\rangle$). \n",
     "In the subsequent subsections, we'll go through these operations step by step followed by verification of correctness.\n",
     "\n",
-    "## II(a) Initialization\n",
+    "## II(a). Initialization\n",
     "\n",
     "We begin by creating the initial MPS state $|\\Psi_0\\rangle = |00...00\\rangle$. "
    ]
@@ -186,7 +186,7 @@
    "id": "3ec42238-6f74-4998-a5c6-3f28db1e0051",
    "metadata": {},
    "source": [
-    "## II(b) Apply Gates to the MPS\n",
+    "## II(b). Apply Gates to the MPS\n",
     "\n",
     "Given an initial MPS state, we can begin applying all the gates in the quantum circuit to form the final MPS. \n",
     "The diagram below describes the application of single-qubit and two-qubit gates to an MPS. \n",
@@ -197,7 +197,7 @@
     "\n",
     "<mark>Note:</mark> In the case of a two-qubit gate acting on non-adjacent qubits, an iterative swap step is required to first make the two qubits adjacent. \n",
     "There are multiple ways to achieve this goal. The diagram below describes two typical algorithms to swap the qubit indices of adjacent sites. \n",
-    "Before the application of gate, adjacent sites are swapped iteratively until the two involved sites are made adjacent. \n",
+    "Before the application of the gate, adjacent sites are swapped iteratively until the two involved sites are made adjacent. \n",
     "After the gate operand is applied, a reverse swap sweep is also needed to revert back to the original MPS site ordering.\n",
     "\n",
     "![swap_site.png](attachment:bbad5491-2744-4842-9eb8-c5470461ec8b.png)\n",
@@ -219,8 +219,8 @@
       "site 0, shape: (1, 2, 2)\n",
       "site 1, shape: (2, 2, 4)\n",
       "site 2, shape: (4, 2, 8)\n",
-      "site 3, shape: (8, 2, 8)\n",
-      "site 4, shape: (8, 2, 8)\n",
+      "site 3, shape: (8, 2, 16)\n",
+      "site 4, shape: (16, 2, 8)\n",
       "site 5, shape: (8, 2, 4)\n",
       "site 6, shape: (4, 2, 2)\n",
       "site 7, shape: (2, 2, 1)\n"
@@ -305,7 +305,7 @@
     "# For two-qubit gates, an SVD is performed with singular values partitioned onto the two MPS sites equally.\n",
     "# We also set a cutoff value of 1e-12 to filter out computational noise.\n",
     "exact_gate_algorithm = {'qr_method': False, \n",
-    "                      'svd_method':{'partition': 'UV', 'abs_cutoff':1e-12}}\n",
+    "                        'svd_method':{'partition': 'UV', 'abs_cutoff':1e-12}}\n",
     "\n",
     "# Constructing the final MPS\n",
     "for (gate, qubits) in gates:\n",
@@ -347,14 +347,14 @@
      "output_type": "stream",
      "text": [
       "The norm of the MPS: 1.000e+00\n",
-      "State vector difference: 1.166e-15\n"
+      "State vector difference: 1.790e-15\n"
      ]
     }
    ],
    "source": [
     "class MPSContractionHelper:\n",
     "    \"\"\"\n",
-    "    A helper class to compute various quantities for a given MPS.\n",
+    "    A helper class to compute various quantities for a given MPS using exact contraction.\n",
     "    \n",
     "    Interleaved format is used to construct the input args for `cuquantum.contract`. \n",
     "    A concrete example on how the modes are populated for a 7-site MPS is provided below:\n",
@@ -398,7 +398,7 @@
     "            mps_tensors: A list of rank-3 ndarray-like tensor objects. \n",
     "                The indices of the ith tensor are expected to be bonding index to the i-1 tensor, \n",
     "                the physical mode, and then the bonding index to the i+1th tensor.\n",
-    "            options: Specify the contract and decompose options. \n",
+    "            options: Specify the contraction options. \n",
     "\n",
     "        Returns:\n",
     "            The norm of the MPS.\n",
@@ -417,7 +417,7 @@
     "            mps_tensors: A list of rank-3 ndarray-like tensor objects. \n",
     "                The indices of the ith tensor are expected to be bonding index to the i-1 tensor, \n",
     "                the physical mode, and then the bonding index to the i+1th tensor.\n",
-    "            options: Specify the contract and decompose options. \n",
+    "            options: Specify the contraction options. \n",
     "\n",
     "        Returns:\n",
     "            An ndarray-like object as the state vector.\n",
@@ -429,7 +429,7 @@
     "        interleaved_inputs.append(output_modes) # output\n",
     "        return self._contract('sv', interleaved_inputs, options=options)\n",
     "    \n",
-    "    def contract_expectation(self, mps_tensors, operator, qubits, options=None, normalize=False):\n",
+    "    def contract_expectation(self, mps_tensors, operator, qubits, normalize=False, options=None):\n",
     "        \"\"\"\n",
     "        Contract the corresponding tensor network to form the state vector representation of the MPS.\n",
     "\n",
@@ -441,8 +441,8 @@
     "                The modes of the operator are expected to be output qubits followed by input qubits, e.g, \n",
     "                ``A, B, a, b`` where `a, b` denotes the inputs and `A, B'` denotes the outputs. \n",
     "            qubits: A sequence of integers specifying the qubits that the operator is acting on. \n",
-    "            options: Specify the contract and decompose options. \n",
     "            normalize: Whether to scale the expectation value by the normalization factor.\n",
+    "            options: Specify the contraction options. \n",
     "\n",
     "        Returns:\n",
     "            An ndarray-like object as the state vector.\n",
@@ -480,7 +480,7 @@
     "            mpo_tensors: A list of rank-4 ndarray-like tensor objects.\n",
     "                The indics of the ith tensor are expected to be the bonding index to the i-1 tensor, \n",
     "                the output physical mode, the bonding index to the i+1th tensor and then the inputput physical mode.\n",
-    "            options: Specify the contract and decompose options. \n",
+    "            options: Specify the contraction options. \n",
     "\n",
     "        Returns:\n",
     "            An ndarray-like object as the output state vector.\n",
@@ -535,7 +535,7 @@
    "source": [
     "# III. MPS Canonicalization\n",
     "\n",
-    "One nice property of MPS is that its canonical form allows for easy computation of expectation values or reduced density matrices. \n",
+    "One nice property of the MPS is that its canonical form allows for easy computation of expectation values or reduced density matrices. \n",
     "\n",
     "For instance, if one were to compute the expectation value of a two-qubit operator, two approaches shown below can be adopted:\n",
     "- Contraction of the original $\\langle\\Psi|\\hat{O}|\\Psi\\rangle$ tensor network where $|\\Psi\\rangle$ is now an MPS.\n",
@@ -561,8 +561,8 @@
      "output_type": "stream",
      "text": [
       "Expectation value at qubits (2, 3)\n",
-      "<MPS|OP|MPS>: (0.4953677828368589+0.39635222637212664j)\n",
-      "<SV|OP|SV>: (0.495367782836861+0.3963522263721279j)\n",
+      "<MPS|OP|MPS>: (0.34424195503028576+0.38355529480141526j)\n",
+      "<SV|OP|SV>: (0.3442419550302871+0.3835552948014171j)\n",
       "<MPS|OP|MPS> equal to <SV|OP|SV>? : True\n"
      ]
     }
@@ -626,9 +626,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<canonical MPS|OP|canonical MPS> with reduced graph: (0.49536778283685906+0.3963522263721267j)\n",
+      "<canonical MPS|OP|canonical MPS> with reduced graph: (0.34424195503028576+0.38355529480141537j)\n",
       "reduced <canonical MPS|OP|canonical MPS> equal to <MPS|OP|MPS>?: True\n",
-      "original <MPS|OP|MPS> with reduced graph: (1.1231422600031686+0.8532610561182179j)\n",
+      "original <MPS|OP|MPS> with reduced graph: (1.1063549716955885+1.0291661220130142j)\n",
       "Equal to reference?: False (False expected)\n"
      ]
     }
@@ -700,7 +700,7 @@
     "print(f\"reduced <canonical MPS|OP|canonical MPS> equal to <MPS|OP|MPS>?: {is_canonical_expec_equal}\")\n",
     "assert is_canonical_expec_equal\n",
     "\n",
-    "# For validation, we can also try to compute the expectation value (False) from the reduced graph with the original MPS\n",
+    "# For validation, we can also compute the expectation value (wrong) from the reduced graph with the original MPS\n",
     "expec_mps_reduced = contract('ipj,jql,irk,ksl,rspq->', mps_tensors[target_qubits[0]], mps_tensors[target_qubits[1]], mps_tensors[target_qubits[0]].conj(), mps_tensors[target_qubits[1]].conj(), operator, options=options)\n",
     "print(f\"original <MPS|OP|MPS> with reduced graph: {expec_mps_reduced}\")\n",
     "\n",
@@ -726,15 +726,16 @@
     "\n",
     "![mps_mpo.png](attachment:a1e48907-1e5f-498a-bac9-d2f3f238c08c.png)\n",
     "\n",
-    "The following topics will be covered:\n",
+    "We will describe two types of algorithms to perform the multiplication. Specifically, the following topics will be covered:\n",
     "\n",
     "- Initializing a random MPO.\n",
-    "- Contracting MPS and MPO exactly using a simple algorithm and verifying its correctness.\n",
-    "- Evaluating the accuracy of approximate MPS MPO multiplication.\n",
+    "- Contracting MPS and MPO exactly using a direct algorithm and verifying its correctness.\n",
+    "- Contracting MPS and MPO exactly using an algorithm based on density matrix and verifying its correctness.\n",
+    "- Evaluating the accuracy of approximate MPS MPO multiplication using the two algorithms above.\n",
     "\n",
     "## IV(a). Generate a Random MPO\n",
     "\n",
-    "Here we first create a random MPO for subsequent operations."
+    "Here we first create a random MPO for subsequent operations. Like we did with MPS, we will insert a dummpy index in the first and the last MPO tensor."
    ]
   },
   {
@@ -758,7 +759,7 @@
     "        shape = (left_bond, 2, right_bond, 2)\n",
     "        o = cp.random.random(shape) + 1.j * cp.random.random(shape)\n",
     "        # normalize\n",
-    "        o /= contract('aPbp,aPbp->', o, o.conj()) ** .5\n",
+    "        o /= cp.linalg.norm(o)\n",
     "        mpo_tensors.append(o)\n",
     "    return mpo_tensors\n",
     "\n",
@@ -767,25 +768,25 @@
   },
   {
    "attachments": {
-    "61565b4c-c320-42e0-bb0f-8248ce692c5e.png": {
-     "image/png": "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"
+    "987db8fe-d369-4f9e-b96b-461370ba011c.png": {
+     "image/png": "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"
     }
    },
    "cell_type": "markdown",
    "id": "0f80c8e5-dfa5-422c-83c9-7d7ee11bd332",
    "metadata": {},
    "source": [
-    "## IV(b). Exact MPS MPO Multiplication\n",
+    "## IV(b). Exact MPS MPO Multiplication with Direct Algorithm\n",
     "\n",
     "There are various algorithms to perform MPS MPO multiplication. In the diagram below we present one simple algorithm based on direct contraction and SVD. \n",
     "\n",
-    "![mps_mpo_multiplication.png](attachment:61565b4c-c320-42e0-bb0f-8248ce692c5e.png)\n",
+    "![direct_mpo_multiplication.png](attachment:987db8fe-d369-4f9e-b96b-461370ba011c.png)\n",
     "\n",
     "Note that during SVD, we can partition the singular values to the right tensor such that the resulting MPS we obtain is in the right orthogonal gauge.\n",
     "\n",
     "We perform the following checks to verify the correctness of our algorithm:\n",
     "- Comparing the states presented by the output MPS against direct contraction.\n",
-    "- Computing the expectation value of a one-body operator acting on the last qubit using a reduced graph. \n"
+    "- Computing the expectation value of a one-body operator acting on the canonicalization center using a reduced graph. \n"
    ]
   },
   {
@@ -798,7 +799,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "After MPS-MPO multiplication\n",
+      "After exact MPS-MPO multiplication using direct algorithm\n",
       "site 0, shape: (1, 2, 2)\n",
       "site 1, shape: (2, 2, 4)\n",
       "site 2, shape: (4, 2, 8)\n",
@@ -807,113 +808,331 @@
       "site 5, shape: (32, 2, 16)\n",
       "site 6, shape: (16, 2, 2)\n",
       "site 7, shape: (2, 2, 1)\n",
-      "Max absolute difference compared with reference state vector: 2.040e-17\n",
-      "Is the canonicalization center moved to the last site?: True\n"
+      "Max absolute difference compared with reference state vector: 6.934e-18\n",
+      "Is the canonicalization center moved to the right?: True\n"
      ]
     }
    ],
    "source": [
-    "def multiply_mps_mpo(mps_tensors, mpo_tensors, algorithm, options=None):\n",
+    "def multiply_mps_mpo_direct(mps_tensors, mpo_tensors, svd_method, canonical_center=\"right\", options=None):\n",
     "    \"\"\"\n",
-    "    Perform MPS MPO multiplication using the algorithm shown above.\n",
+    "    Perform MPS MPO multiplication using the direct algorithm shown above.\n",
+    "    \n",
+    "    Args:\n",
+    "        mps_tensors: A list of rank-3 ndarray-like tensor objects. \n",
+    "            The indices of the ith tensor is expected to be the bonding index to the i-1 tensor, \n",
+    "            the physical mode and then the bonding index to the i+1th tensor.\n",
+    "        mpo_tensors: A list of rank-4 ndarray-like tensor objects.\n",
+    "            The indics of the ith tensor are expected to be the bonding index to the i-1 tensor, \n",
+    "            the output physical mode, the bonding index to the i+1th tensor and then the inputput physical mode.\n",
+    "        svd_method: A tensor.SVDMethod object specifying the options for the SVD truncation. \n",
+    "            For the direct algorithm, the `partition` attribute must be set to `V` for proper canonicalization.\n",
+    "        canonical_center: A string specifying the final canonicalization center, can be either `left` or `right`.\n",
+    "        options: Specify the contract and decompose options. \n",
     "    \"\"\"\n",
+    "    if svd_method.partition != 'V':\n",
+    "        raise ValueError(f\"The direct algorithm expects SVDMethod.partition to be V, found {svd_method.partition}\")\n",
     "    num_qubits = len(mps_tensors)\n",
-    "    t = contract('ipj,kmlp->ijlm', mps_tensors[0], mpo_tensors[0], options=options)\n",
-    "    output_mps = []\n",
-    "    for i in range(1, num_qubits):\n",
-    "        mps, _, t = contract_decompose('ijlm,jqr,lnsq->imx,xrsn', t, mps_tensors[i], mpo_tensors[i], algorithm=algorithm, options=options)\n",
-    "        output_mps.append(mps)\n",
-    "    t = t.reshape(-1,2,1)\n",
-    "    output_mps.append(t)\n",
+    "    algorithm = {'qr_method': False,\n",
+    "                 'svd_method': svd_method}\n",
+    "    output_mps = [None,] * num_qubits\n",
+    "    X = None\n",
+    "    if canonical_center == 'right':\n",
+    "        for i in range(num_qubits):\n",
+    "            if X is None:\n",
+    "                X = contract('ipj,kmlp->imlj', mps_tensors[i], mpo_tensors[i], options=options)\n",
+    "            else:\n",
+    "                mps, _, X = contract_decompose('imlj,jqr,lnsq->imx,xnsr', X, mps_tensors[i], mpo_tensors[i], algorithm=algorithm, options=options)\n",
+    "                output_mps[i-1] = mps\n",
+    "        output_mps[-1] = X.reshape(-1,2,1)\n",
+    "    elif canonical_center == 'left':\n",
+    "        for i in range(num_qubits-1, -1, -1):\n",
+    "            if X is None:\n",
+    "                X = contract('ipj,kmlp->ikmj', mps_tensors[i], mpo_tensors[i], options=options)\n",
+    "            else:\n",
+    "                mps, _, X = contract_decompose('ikmj,lqi,npkq->xmj,lnpx', X, mps_tensors[i], mpo_tensors[i], algorithm=algorithm, options=options)\n",
+    "                output_mps[i+1] = mps\n",
+    "        output_mps[0] = X.reshape(1,2,-1)\n",
+    "    else:\n",
+    "        raise ValueError(\"canonical_center must be either left or right\")\n",
     "    return output_mps\n",
     "\n",
-    "mult_algorithm = {'qr_method': False,\n",
-    "                  'svd_method': {'partition': 'V', 'rel_cutoff':1e-10}}\n",
-    "new_mps = multiply_mps_mpo(mps_tensors, mpo_tensors, mult_algorithm, options=options)\n",
+    "svd_method = tensor.SVDMethod(partition='V', rel_cutoff=1e-10)\n",
+    "canonical_center = 'right' # target canonicalization center, can be 'left' as well\n",
     "\n",
-    "print(\"After MPS-MPO multiplication\")\n",
-    "for i, o in enumerate(new_mps):\n",
+    "# multiply MPS with MPO using direct algorithm\n",
+    "mps_mpo_direct = multiply_mps_mpo_direct(mps_tensors, mpo_tensors, svd_method, canonical_center=canonical_center, options=options)\n",
+    "\n",
+    "print(\"After exact MPS-MPO multiplication using direct algorithm\")\n",
+    "for i, o in enumerate(mps_mpo_direct):\n",
     "    print(f\"site {i}, shape: {o.shape}\")\n",
     "\n",
     "# compute the state vector after MPS-MPO multiplication\n",
-    "mps_mpo_sv = mps_helper.contract_state_vector(new_mps, options=options)\n",
+    "mps_mpo_sv_direct = mps_helper.contract_state_vector(mps_mpo_direct, options=options)\n",
+    "\n",
     "# reference state vector from full network contraction\n",
-    "mps_mpo_ref = mps_helper.contract_mps_mpo_to_state_vector(mps_tensors, mpo_tensors, options=options)\n",
-    "print(f\"Max absolute difference compared with reference state vector: {abs(mps_mpo_sv-mps_mpo_ref).max():0.3e}\")\n",
-    "assert cp.allclose(mps_mpo_sv, mps_mpo_ref)\n",
+    "mps_mpo_sv_ref = mps_helper.contract_mps_mpo_to_state_vector(mps_tensors, mpo_tensors, options=options)\n",
+    "print(f\"Max absolute difference compared with reference state vector: {abs(mps_mpo_sv_direct-mps_mpo_sv_ref).max():0.3e}\")\n",
+    "assert cp.allclose(mps_mpo_sv_direct, mps_mpo_sv_ref)\n",
     "\n",
-    "# compute the expectation value of an operator on the last qubit\n",
+    "# compute the expectation value of a one body operator on the canonicalization center\n",
     "one_body_operator = cp.random.random([2,2]) + 1j* cp.random.random([2,2])\n",
-    "# reference from contracting the full <MPS|O|MPS> network\n",
-    "expec_one_body_ref = mps_helper.contract_expectation(new_mps, one_body_operator, (num_qubits-1, ), options=options)\n",
-    "# expectation value from the reduced graph on the last qubit\n",
-    "expec_one_body = contract('ipj,iPj,Pp->', new_mps[-1], new_mps[-1].conj(), one_body_operator, options=options)\n",
-    "\n",
-    "is_right_canonical = cp.allclose(expec_one_body, expec_one_body_ref)\n",
-    "print(f\"Is the canonicalization center moved to the last site?: {is_right_canonical}\")\n",
-    "assert is_right_canonical"
+    "operator_site = {'right': num_qubits-1,\n",
+    "                 'left': 0}[canonical_center]\n",
+    "\n",
+    "# reference expectation value from contracting the full <MPS|O|MPS> network\n",
+    "expec_direct_full = mps_helper.contract_expectation(mps_mpo_direct, one_body_operator, (operator_site, ), normalize=True, options=options)\n",
+    "# expectation value from the reduced graph on the canonical center\n",
+    "expec_direct_reduced = contract('ipj,iPj,Pp->', mps_mpo_direct[operator_site], mps_mpo_direct[operator_site].conj(), one_body_operator, options=options)\n",
+    "expec_direct_reduced /= cp.linalg.norm(mps_mpo_direct[operator_site]) ** 2\n",
+    "\n",
+    "is_direct_canonical = cp.allclose(expec_direct_full, expec_direct_reduced)\n",
+    "print(f\"Is the canonicalization center moved to the {canonical_center}?: {is_direct_canonical}\")\n",
+    "assert is_direct_canonical\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "4194c27f-87c2-4671-881c-7ef351c0ecf8",
+   "id": "985449dc-afd0-4d95-96f5-06b8ffed9f1f",
    "metadata": {},
    "source": [
-    "## IV(c). Accuracy of Approximate MPS MPO contraction\n",
+    "## IV(c). Exact MPS MPO Multiplication with Density Matrix Algorithm\n",
     "\n",
-    "In this subsection we present some experiments on MPS-MPO mulitiplication with approximation. \n",
-    "Specifically, we will do a sweep of MPS-MPO multiplication with different constraints on the maximal number of singular values to keep for all connecting bonds.\n",
-    "We examine the accuracy of approximation with the following two criteria:\n",
-    "- The difference in normalized state vector.\n",
-    "- The difference in expectation value of a random operator after normalization."
+    "The density matrix algorithm for MPS MPO multiplication is based on iterative truncation on the density matrix. \n",
+    "For detailed introduction on the algorithm, user may refer to this [tutorial page](https://tensornetwork.org/mps/algorithms/denmat_mpo_mps/) or this [paper](https://iopscience.iop.org/article/10.1088/1742-5468/2007/10/P10014). \n",
+    "Since the truncation is performed on the density matrix, approximation using this algorithm is generally expected to be more accurate than the direct approach. \n",
+    "\n",
+    "In this subsection, we provide a reference implementation in function `multiply_mps_mpo_density_matrix` and verify its correctness using the same checks as we did with the direct algorithm."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
-   "id": "99c9204c-a629-4309-b333-691e8a181088",
+   "id": "68e9d6ef-16dd-4b25-906c-773f1553658f",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "max extent=1, state vector error=4.191e-02, relative error for expectation value=1.770e-02\n",
-      "max extent=2, state vector error=1.544e-02, relative error for expectation value=2.131e-03\n",
-      "max extent=4, state vector error=2.894e-03, relative error for expectation value=2.804e-05\n",
-      "max extent=8, state vector error=2.643e-04, relative error for expectation value=5.410e-07\n",
-      "max extent=12, state vector error=6.573e-05, relative error for expectation value=3.087e-08\n",
-      "max extent=16, state vector error=3.419e-06, relative error for expectation value=8.492e-11\n"
+      "After exact MPS-MPO multiplication using density matrix algorithm\n",
+      "site 0, shape: (1, 2, 2)\n",
+      "site 1, shape: (2, 2, 4)\n",
+      "site 2, shape: (4, 2, 8)\n",
+      "site 3, shape: (8, 2, 15)\n",
+      "site 4, shape: (15, 2, 8)\n",
+      "site 5, shape: (8, 2, 4)\n",
+      "site 6, shape: (4, 2, 2)\n",
+      "site 7, shape: (2, 2, 1)\n",
+      "Max absolute difference compared with reference state vector: 6.240e-09\n",
+      "Is the canonicalization center moved to the right?: True\n"
      ]
     }
    ],
    "source": [
-    "# For a fair comparison between state vectors, in this vector we normalize all state vector\n",
-    "mps_mpo_ref /= cp.linalg.norm(mps_mpo_ref)\n",
+    "def multiply_mps_mpo_density_matrix(mps_tensors, mpo_tensors, svd_method, canonical_center=\"right\", options=None):\n",
+    "    \"\"\"\n",
+    "    Perform MPS MPO multiplication using the density matrix algorithm.\n",
+    "    \n",
+    "    Args:\n",
+    "        mps_tensors: A list of rank-3 ndarray-like tensor objects. \n",
+    "            The indices of the ith tensor is expected to be the bonding index to the i-1 tensor, \n",
+    "            the physical mode and then the bonding index to the i+1th tensor.\n",
+    "        mpo_tensors: A list of rank-4 ndarray-like tensor objects.\n",
+    "            The indics of the ith tensor are expected to be the bonding index to the i-1 tensor, \n",
+    "            the output physical mode, the bonding index to the i+1th tensor and then the inputput physical mode.\n",
+    "        svd_method: A tensor.SVDMethod object specifying the options for the SVD truncation. \n",
+    "            For the density matrix algorithm, the `partition` attribute must be set to `None` for proper canonicalization.\n",
+    "        canonical_center: A string specifying the final canonicalization center, can be either `left` or `right`.\n",
+    "        options: Specify the contract and decompose options. \n",
+    "    \"\"\"\n",
+    "    if svd_method.partition is not None:\n",
+    "        raise ValueError(f\"The density matrix algorithm expects SVDMethod.partition to be None, found {svd_method.partition}\")\n",
+    "    if len(mps_tensors) != len(mpo_tensors):\n",
+    "        raise ValueError(f\"The number of MPS tensor {len(mps_tensors)} does not match that of MPO tensors {len(mpo_tensors)}\")\n",
+    "        \n",
+    "    n = len(mps_tensors)\n",
+    "    algo = {'qr_method': False, 'svd_method': svd_method}\n",
+    "    envs = dict()\n",
+    "    mps_mpo_tensors = []\n",
+    "    for i in range(n):\n",
+    "        # multiply the MPS tensor with the MPO tensor at the same site\n",
+    "        mps_mpo_tensors.append(contract('ijk,lnmj->ilnmk', mps_tensors[i], mpo_tensors[i], options=options))\n",
+    "    new_mps_tensors = [None] * n\n",
+    "    if canonical_center == 'left':\n",
+    "        # construct the environment tensors with an inverse sweep from left to right\n",
+    "        for i in range(n-1):\n",
+    "            if i==0:\n",
+    "                envs[i] = contract('ilnmk,ILnMK->kmKM', mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), options=options)\n",
+    "            else:\n",
+    "                # contract the MPS-MPO with its left env to construct the next env \n",
+    "                envs[i] = contract('ilIL,ilnmk,ILnMK->kmKM', envs[i-1], mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), options=options)\n",
+    "        R_tensor = None\n",
+    "        for i in range(n-1, 0, -1):\n",
+    "            if R_tensor is None:\n",
+    "                # contract and decompose ---MPS_MPO---left_env---MPS_MPO^*--- to compute the new MPS tensor at last site\n",
+    "                u, s, v = contract_decompose('ilIL,ilnmk,ILNMK->xnk,xNK', envs[i-1], mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), algorithm=algo, options=options)\n",
+    "                R_tensor = contract('ilnmk,xnr->ilx', mps_mpo_tensors[i], v, options=options)\n",
+    "            else:\n",
+    "                # contract and decompose R_i---MPS_MPO_i---left_env_i---MPS_MPO_i^*---R_i^* to compute the unitary u as the new compressed MPS tensor\n",
+    "                u, s, v = contract_decompose('ilIL,ilnmk,ILNMK,kmx,KMX->znx,zNX', envs[i-1], mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), R_tensor, R_tensor.conj(), algorithm=algo, options=options)\n",
+    "                # form R_i+1 by contracting MPS_MPO_i, V_i and R_i\n",
+    "                R_tensor = contract('ilnmk,znx,kmx->ilz', mps_mpo_tensors[i], v, R_tensor, options=options)\n",
+    "            new_mps_tensors[i] = u\n",
+    "        # contract MPS_MPO_0 with R_0 as the first MPS tensor\n",
+    "        new_mps_tensors[0] = contract('ilnmk,kmx->inx', mps_mpo_tensors[0], R_tensor, options=options)\n",
+    "    elif canonical_center == 'right':\n",
+    "        # construct the environment tensors with an inverse sweep from right to left\n",
+    "        for i in range(n-1, 0, -1):\n",
+    "            if i == n-1:\n",
+    "                envs[i] = contract('ilnmk,ILnMK->ilIL', mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), options=options)\n",
+    "            else:\n",
+    "                # contract the MPS-MPO with its right env to construct the next env \n",
+    "                envs[i] = contract('kmKM,ilnmk,ILnMK->ilIL', envs[i+1], mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), options=options)\n",
+    "        L_tensor = None\n",
+    "        for i in range(n-1):\n",
+    "            if L_tensor is None:\n",
+    "                # contract and decompose ---MPS_MPO---right_env---MPS_MPO^*--- to compute the new MPS tensor at last site\n",
+    "                u, s, v = contract_decompose('kmKM,ilnmk,ILNMK->inx,INx', envs[i+1], mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), algorithm=algo, options=options)\n",
+    "                L_tensor = contract('ilnmk,rnx->xmk', mps_mpo_tensors[i], v, options=options)\n",
+    "            else:\n",
+    "                # contract and decompose L_i---MPS_MPO_i---right_env_i---MPS_MPO_i^*---L_i^* to compute the unitary u as the new compressed MPS tensor\n",
+    "                u, s, v = contract_decompose('kmKM,ilnmk,ILNMK,xli,XLI->xnz,XNz', envs[i+1], mps_mpo_tensors[i], mps_mpo_tensors[i].conj(), L_tensor, L_tensor.conj(), algorithm=algo, options=options)\n",
+    "                L_tensor = contract('ilnmk,xnz,xli->zmk', mps_mpo_tensors[i], v, L_tensor, options=options)\n",
+    "            new_mps_tensors[i] = u\n",
+    "        # contract the last MPS_MPO with L as the last MPS tensor\n",
+    "        new_mps_tensors[n-1] = contract('ilnmk,xli->xnk', mps_mpo_tensors[n-1], L_tensor, options=options)\n",
+    "    else:\n",
+    "        raise ValueError(\"sweep direction must be either left or right\")\n",
+    "                \n",
+    "    return new_mps_tensors\n",
     "\n",
-    "# We also rescale the expectation values by normalization factor\n",
-    "expec_one_body_ref = mps_helper.contract_expectation(new_mps, one_body_operator, (num_qubits-1, ), options=options, normalize=True)\n",
+    "\n",
+    "svd_method = tensor.SVDMethod(rel_cutoff=1e-10)\n",
+    "\n",
+    "# multiply MPS with MPO using density matrix algorithm\n",
+    "mps_mpo_dm = multiply_mps_mpo_density_matrix(mps_tensors, mpo_tensors, svd_method, canonical_center=canonical_center, options=options)\n",
+    "print(\"After exact MPS-MPO multiplication using density matrix algorithm\")\n",
+    "for i, o in enumerate(mps_mpo_dm):\n",
+    "    print(f\"site {i}, shape: {o.shape}\")\n",
+    "\n",
+    "# compute the state vector after MPS-MPO multiplication\n",
+    "mps_mpo_sv_dm = mps_helper.contract_state_vector(mps_mpo_dm, options=options)\n",
+    "print(f\"Max absolute difference compared with reference state vector: {abs(mps_mpo_sv_dm-mps_mpo_sv_ref).max():0.3e}\")\n",
+    "assert cp.allclose(mps_mpo_sv_dm, mps_mpo_sv_ref)\n",
+    "\n",
+    "# reference from contracting the full <MPS|O|MPS> network\n",
+    "expec_dm_full = mps_helper.contract_expectation(mps_mpo_dm, one_body_operator, (operator_site, ), normalize=True, options=options)\n",
+    "# expectation value from the reduced graph on the canonical center\n",
+    "expec_dm_reduced = contract('ipj,iPj,Pp->', mps_mpo_dm[operator_site], mps_mpo_dm[operator_site].conj(), one_body_operator, options=options)\n",
+    "expec_dm_reduced /= cp.linalg.norm(mps_mpo_dm[operator_site]) ** 2\n",
+    "\n",
+    "is_dm_canonical = cp.allclose(expec_dm_full, expec_dm_reduced)\n",
+    "print(f\"Is the canonicalization center moved to the {canonical_center}?: {is_dm_canonical}\")\n",
+    "assert is_dm_canonical"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4194c27f-87c2-4671-881c-7ef351c0ecf8",
+   "metadata": {},
+   "source": [
+    "## IV(d). Accuracy of Approximate MPS MPO contraction\n",
+    "\n",
+    "In this subsection we present some experiments on the accuracies of the two algorithms for approximate MPS-MPO mulitiplication. \n",
+    "Specifically, we will do a sweep of MPS-MPO multiplication with different constraints on the maximal number of singular values to keep for all connecting bonds.\n",
+    "We examine the accuracy of approximation for these two algorithms with the following two criteria:\n",
+    "- The difference in state vector.\n",
+    "- The difference in expectation value of a random operator after normalization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "99c9204c-a629-4309-b333-691e8a181088",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "err_direct = []\n",
+    "err_dm = []\n",
     "\n",
     "for max_extent in (1, 2, 4, 8, 12, 16):\n",
-    "    naive_algorithm = {'qr_method': False, \n",
-    "                       'svd_method': {'partition': 'V', 'rel_cutoff':1e-10, 'max_extent': max_extent}}\n",
-    "    new_mps = multiply_mps_mpo(mps_tensors, mpo_tensors, naive_algorithm, options=options)\n",
-    "    # compute the normalized state vector\n",
-    "    mps_mpo_sv = mps_helper.contract_state_vector(new_mps, options=options)\n",
-    "    mps_mpo_sv /= cp.linalg.norm(mps_mpo_sv)\n",
-    "    err_sv = abs(mps_mpo_sv-mps_mpo_ref).max()\n",
+    "    svd_setting = {'rel_cutoff': 1e-10, 'max_extent': max_extent}\n",
+    "    \n",
+    "    # 1. Using direct algorithm\n",
+    "    svd_method_direct = tensor.SVDMethod(partition='V', **svd_setting)\n",
+    "    new_mps_direct = multiply_mps_mpo_direct(mps_tensors, mpo_tensors, svd_method_direct, canonical_center=canonical_center, options=options)\n",
+    "    \n",
+    "    # 1a. compute the equivalent state vector\n",
+    "    mps_mpo_sv_direct = mps_helper.contract_state_vector(new_mps_direct, options=options)\n",
+    "    err_sv_direct = abs(mps_mpo_sv_direct - mps_mpo_sv_ref).max()\n",
     "    \n",
-    "    # compute the expectation value with normalization\n",
-    "    expec_one_body = contract('ipj,iPj,Pp->', new_mps[-1], new_mps[-1].conj(), one_body_operator, options=options) \n",
-    "    expec_one_body /= cp.linalg.norm(new_mps[-1]) ** 2\n",
-    "    err_expec = abs(expec_one_body_ref-expec_one_body)/abs(expec_one_body)\n",
+    "    # 1b. compute the expectation value with normalization\n",
+    "    expec_direct = contract('ipj,iPj,Pp->', new_mps_direct[operator_site], new_mps_direct[operator_site].conj(), one_body_operator, options=options) \n",
+    "    expec_direct /= cp.linalg.norm(new_mps_direct[operator_site]) ** 2\n",
+    "    err_expec_direct = abs(1-expec_direct/expec_direct_full)\n",
     "    \n",
-    "    print(f\"max extent={max_extent}, state vector error={err_sv:0.3e}, relative error for expectation value={err_expec:0.3e}\")"
+    "    # 2. Using density matrix algorithm\n",
+    "    svd_method_dm = tensor.SVDMethod(**svd_setting)\n",
+    "    new_mps_dm = multiply_mps_mpo_density_matrix(mps_tensors, mpo_tensors, svd_method_dm, canonical_center=canonical_center, options=options)\n",
+    "    \n",
+    "    # 2a. compute the equivalent state vector\n",
+    "    mps_mpo_sv_dm = mps_helper.contract_state_vector(new_mps_dm, options=options)\n",
+    "    err_sv_dm = abs(mps_mpo_sv_dm - mps_mpo_sv_ref).max()\n",
+    "    \n",
+    "    # 2b. compute the expectation value with normalization\n",
+    "    expec_dm = contract('ipj,iPj,Pp->', new_mps_dm[operator_site], new_mps_dm[operator_site].conj(), one_body_operator, options=options) \n",
+    "    expec_dm /= cp.linalg.norm(new_mps_dm[operator_site]) ** 2\n",
+    "    err_expec_dm = abs(1-expec_dm/expec_dm_full)\n",
+    "    \n",
+    "    err_direct.append([max_extent, err_sv_direct.get(), err_expec_direct.get()])\n",
+    "    err_dm.append([max_extent, err_sv_dm.get(), err_expec_dm.get()])\n",
+    "\n",
+    "err_direct = np.asarray(err_direct)\n",
+    "err_dm = np.asarray(err_dm)\n",
+    "\n",
+    "# making plots\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig, axes = plt.subplots(1,2, figsize=(12,6), sharex=True)\n",
+    "direct_plot_kwargs = {'color': 'k',\n",
+    "                      'marker': 'o',\n",
+    "                      'label': 'Direct Algorithm'}\n",
+    "\n",
+    "dm_plot_kwargs = {'color': 'r',\n",
+    "                  'marker': 'o',\n",
+    "                  'label': 'Density Matrix Algorithm'}\n",
+    "\n",
+    "axes[0].plot(err_direct[:,0], err_direct[:,1], **direct_plot_kwargs)\n",
+    "axes[0].plot(err_dm[:,0], err_dm[:,1], **dm_plot_kwargs)\n",
+    "axes[0].set_yscale('log')\n",
+    "axes[0].legend()\n",
+    "axes[0].set_xlabel('Bond Dimension')\n",
+    "axes[0].set_title('Absolute Error in State Vector')\n",
+    "\n",
+    "axes[1].plot(err_direct[:,0], err_direct[:,2], **direct_plot_kwargs)\n",
+    "axes[1].plot(err_dm[:,0], err_dm[:,2], **dm_plot_kwargs)\n",
+    "axes[1].set_yscale('log')\n",
+    "axes[1].legend()\n",
+    "axes[1].set_xlabel('Bond Dimension')\n",
+    "axes[1].set_title('Relative Error in Expectation Value')\n",
+    "plt.show()\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "ab89e997-b286-4c31-a7e1-562644767c86",
    "metadata": {},
    "outputs": [],
diff --git a/python/setup.py b/python/setup.py
index 7758c34..b69a8a4 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -29,12 +29,17 @@
 # - cuTENSOR version is constrained in the cutensornet-cuXX package, so we don't
 #   need to list it
 install_requires = [
-    'numpy',
-    # 'cupy', # TODO: use "cupy-wheel" once it's stablized, see https://github.com/cupy/cupy/issues/6688
+    'numpy>=1.21',
     # 'torch', # <-- PyTorch is optional; also, the PyPI version does not support GPU...
-    f'custatevec-cu{utils.cuda_major_ver}~=1.3',   # ">=1.3.0,<2"
-    f'cutensornet-cu{utils.cuda_major_ver}~=2.1',  # ">=2.1.0,<3"
-    ]
+    f'custatevec-cu{utils.cuda_major_ver}~=1.4',   # ">=1.4.0,<2"
+    f'cutensornet-cu{utils.cuda_major_ver}~=2.2',  # ">=2.2.0,<3"
+]
+if utils.cuda_major_ver == '11':
+    # CuPy has 3+ wheels for CUDA 11.x, only the cuquantum-python meta package has
+    # a chance to resolve the ambiguity properly
+    pass
+elif utils.cuda_major_ver == '12':
+    install_requires.append('cupy-cuda12x>=10.0')  # no ambiguity
 
 
 # Note: the extension attributes are overwritten in build_extension()
@@ -91,7 +96,6 @@
         "Topic :: Education",
         "Topic :: Scientific/Engineering",
         "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
@@ -104,7 +108,7 @@
     packages=find_packages(include=['cuquantum', 'cuquantum.*']),
     package_data={"": ["*.pxd", "*.pyx", "*.py"],},
     zip_safe=False,
-    python_requires='>=3.8',
+    python_requires='>=3.9',
     install_requires=install_requires,
     tests_require=install_requires+tests_require,
     cmdclass=cmdclass,
diff --git a/python/tests/cuquantum_tests/__init__.py b/python/tests/cuquantum_tests/__init__.py
index 3197836..84da4e4 100644
--- a/python/tests/cuquantum_tests/__init__.py
+++ b/python/tests/cuquantum_tests/__init__.py
@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import atexit
+import glob
 import os
 import sys
 import tempfile
@@ -23,6 +25,15 @@
     sys.path.append(os.getcwd())
 
 
+def clean_up_cffi_files():
+    files = glob.glob(os.path.join(os.getcwd(), "cuquantum_test_cffi*"))
+    for f in files:
+        try:
+            os.remove(f)
+        except FileNotFoundError:
+            pass
+
+
 dtype_to_data_type = {
     numpy.float16: cudaDataType.CUDA_R_16F,
     numpy.float32: cudaDataType.CUDA_R_32F,
@@ -114,6 +125,7 @@ def _get_functor_address(self):
             self.ffi = ffi
             _cffi_mod1 = importlib.import_module(mod_name)
         self.ffi_mod = _cffi_mod1
+        atexit.register(clean_up_cffi_files)
 
         alloc_addr = self._get_address("my_alloc")
         free_addr = self._get_address("my_free")
@@ -173,6 +185,7 @@ def _get_handler_address(self):
             self.ffi = ffi
             _cffi_mod2 = importlib.import_module(mod_name)
         self.ffi_mod = _cffi_mod2
+        atexit.register(clean_up_cffi_files)
 
         h = self.handler = self.ffi_mod.ffi.new("myHandler*")
         self.ffi_mod.lib.init_myHandler(h, self.source.encode())
diff --git a/python/tests/cuquantum_tests/custatevec_tests/test_custatevec.py b/python/tests/cuquantum_tests/custatevec_tests/test_custatevec.py
index 0627318..364d3c3 100644
--- a/python/tests/cuquantum_tests/custatevec_tests/test_custatevec.py
+++ b/python/tests/cuquantum_tests/custatevec_tests/test_custatevec.py
@@ -4,9 +4,9 @@
 
 import copy
 
-import cupy
+import cupy as cp
 from cupy import testing
-import numpy
+import numpy as np
 try:
     from mpi4py import MPI  # init!
 except ImportError:
@@ -39,13 +39,13 @@ def handle():
 
 @testing.parameterize(*testing.product({
     'n_qubits': (3,),
-    'dtype': (numpy.complex64, numpy.complex128),
+    'dtype': (np.complex64, np.complex128),
 }))
 class TestSV:
     # Base class for all statevector tests
 
     def get_sv(self):
-        arr = cupy.zeros((2**self.n_qubits,), dtype=self.dtype)
+        arr = cp.zeros((2**self.n_qubits,), dtype=self.dtype)
         arr[0] = 1  # initialize in |000...00>
         return arr
 
@@ -57,7 +57,50 @@ def _return_data(self, data, name, dtype, return_value):
                 return 0, 0
             else:
                 # return int as void*
-                data = numpy.asarray(data, dtype=dtype)
+                data = np.asarray(data, dtype=dtype)
+                setattr(self, name, data)  # keep data alive
+                return data.ctypes.data, data.size
+        elif return_value == 'seq':
+            # data itself is already a flat sequence
+            return data, len(data)
+        else:
+            assert False
+
+
+@testing.parameterize(*testing.product({
+    'n_svs': (3,),
+    'n_qubits': (4,),
+    'n_extra_qubits': (0, 1),  # for padding purpose
+    'dtype': (np.complex64, np.complex128),
+}))
+class TestBatchedSV:
+    # Base class for all batched statevector tests
+
+    def get_sv(self):
+        arr = cp.zeros((self.n_svs, 2**(self.n_qubits + self.n_extra_qubits)), dtype=self.dtype)
+        arr[:, 0] = 1  # initialize in |000...00>
+        self.sv_stride = 2 ** (self.n_qubits + self.n_extra_qubits)  # in counts, not bytes
+        return arr
+
+    # TODO: make this a static method
+    # TODO: refactor this to a helper class?
+    def _return_data(self, data, name, dtype, return_value):
+        if return_value == 'int_d':
+            if len(data) == 0:
+                # empty, give it a NULL
+                return 0, 0
+            else:
+                # return int as void*
+                data = cp.asarray(data, dtype=dtype)
+                setattr(self, name, data)  # keep data alive
+                return data.data.ptr, data.size
+        if return_value == 'int_h':
+            if len(data) == 0:
+                # empty, give it a NULL
+                return 0, 0
+            else:
+                # return int as void*
+                data = np.asarray(data, dtype=dtype)
                 setattr(self, name, data)  # keep data alive
                 return data.ctypes.data, data.size
         elif return_value == 'seq':
@@ -76,14 +119,14 @@ def multi_gpu_handles(request):
     p2p_required = request.param
 
     for dev in range(n_devices):
-        with cupy.cuda.Device(dev):
+        with cp.cuda.Device(dev):
             h = cusv.create()
             handles.append(h)
             if p2p_required:
                 for peer in range(n_devices):
                     if dev == peer: continue
                     try:
-                        cupy.cuda.runtime.deviceEnablePeerAccess(peer)
+                        cp.cuda.runtime.deviceEnablePeerAccess(peer)
                     except Exception as e:
                         if 'PeerAccessUnsupported' in str(e):
                             pytest.skip("P2P unsupported")
@@ -93,14 +136,14 @@ def multi_gpu_handles(request):
     yield handles
 
     for dev in range(n_devices):
-        with cupy.cuda.Device(dev):
+        with cp.cuda.Device(dev):
             h = handles.pop(0)
             cusv.destroy(h)
             if p2p_required:
                 for peer in range(n_devices):
                     if dev == peer: continue
                     try:
-                        cupy.cuda.runtime.deviceDisablePeerAccess(peer)
+                        cp.cuda.runtime.deviceDisablePeerAccess(peer)
                     except Exception as e:
                         if 'PeerAccessNotEnabled' not in str(e):
                             raise
@@ -120,7 +163,7 @@ def get_exponent(n):
 
 @testing.parameterize(*testing.product({
     'n_qubits': (4,),
-    'dtype': (numpy.complex64, numpy.complex128),
+    'dtype': (np.complex64, np.complex128),
 }))
 class TestMultiGpuSV:
     # TODO: consider making this class more flexible
@@ -133,8 +176,8 @@ def get_sv(self):
 
         self.sub_sv = []
         for dev in range(self.n_devices):
-            with cupy.cuda.Device(dev):
-                self.sub_sv.append(cupy.zeros(
+            with cp.cuda.Device(dev):
+                self.sub_sv.append(cp.zeros(
                     2**self.n_local_bits, dtype=self.dtype))
         self.sub_sv[0][0] = 1  # initialize in |000...00>
         return self.sub_sv
@@ -147,7 +190,7 @@ def _return_data(self, data, name, dtype, return_value):
                 return 0, 0
             else:
                 # return int as void*
-                data = numpy.asarray(data, dtype=dtype)
+                data = np.asarray(data, dtype=dtype)
                 setattr(self, name, data)  # keep data alive
                 return data.ctypes.data, data.size
         elif return_value == 'seq':
@@ -188,7 +231,7 @@ def test_workspace(self, handle):
         # cuStateVec does not like a smaller workspace...
         size = 24*1024**2
         assert size > default_workspace_size
-        memptr = cupy.cuda.alloc(size)
+        memptr = cp.cuda.alloc(size)
         cusv.set_workspace(handle, memptr.ptr, size)  # should not fail
 
     def test_stream(self, handle):
@@ -196,17 +239,34 @@ def test_stream(self, handle):
         assert 0 == cusv.get_stream(handle)
 
         # simple set/get round-trip
-        stream = cupy.cuda.Stream()
+        stream = cp.cuda.Stream()
         cusv.set_stream(handle, stream.ptr)
         assert stream.ptr == cusv.get_stream(handle)
 
 
+class TestInitSV(TestSV):
+
+    @pytest.mark.parametrize('sv_type', cusv.StateVectorType)
+    def test_initialize_state_vector(self, handle, sv_type):
+        sv = self.get_sv()
+        data_type = dtype_to_data_type[self.dtype]
+
+        if sv_type == cusv.StateVectorType.ZERO:
+            sv_orig = sv.copy()  # already zero-init'd
+            sv[:] = 1.  # reset to something else
+        cusv.initialize_state_vector(
+            handle, sv.data.ptr, data_type, self.n_qubits, sv_type)
+        if sv_type == cusv.StateVectorType.ZERO:
+            assert (sv == sv_orig).all()
+        assert cp.allclose(cp.sum(cp.abs(sv)**2), 1.)
+
+
 class TestAbs2Sum(TestSV):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'basis_bits': (numpy.int32, 'int'),},
-            {'basis_bits': (numpy.int32, 'seq'),},
+            {'basis_bits': (np.int32, 'int'),},
+            {'basis_bits': (np.int32, 'seq'),},
         )
     )
     def test_abs2sum_on_z_basis(self, handle, input_form):
@@ -220,21 +280,21 @@ def test_abs2sum_on_z_basis(self, handle, input_form):
         sum0, sum1 = cusv.abs2sum_on_z_basis(
             handle, sv.data.ptr, data_type, self.n_qubits,
             True, True, basis_bits, basis_bits_len)
-        assert numpy.allclose(sum0+sum1, 1)
+        assert np.allclose(sum0+sum1, 1)
         assert (sum0 is not None) and (sum1 is not None)
 
         # case 2: only sum0 is computed
         sum0, sum1 = cusv.abs2sum_on_z_basis(
             handle, sv.data.ptr, data_type, self.n_qubits,
             True, False, basis_bits, basis_bits_len)
-        assert numpy.allclose(sum0, 1)
+        assert np.allclose(sum0, 1)
         assert (sum0 is not None) and (sum1 is None)
 
         # case 3: only sum1 is computed
         sum0, sum1 = cusv.abs2sum_on_z_basis(
             handle, sv.data.ptr, data_type, self.n_qubits,
             False, True, basis_bits, basis_bits_len)
-        assert numpy.allclose(sum1, 0)
+        assert np.allclose(sum1, 0)
         assert (sum0 is None) and (sum1 is not None)
 
         # case 4: none is computed
@@ -245,19 +305,19 @@ def test_abs2sum_on_z_basis(self, handle, input_form):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'bit_ordering': (numpy.int32, 'int'),},
-            {'bit_ordering': (numpy.int32, 'seq'),},
+            {'bit_ordering': (np.int32, 'int'),},
+            {'bit_ordering': (np.int32, 'seq'),},
         )
     )
     @pytest.mark.parametrize(
-        'xp', (numpy, cupy)
+        'xp', (np, cp)
      )
     def test_abs2sum_array_no_mask(self, handle, xp, input_form):
         # change sv from |000> to 1/\sqrt{2} (|001> + |100>)
         sv = self.get_sv()
         sv[0] = 0
-        sv[1] = 1./numpy.sqrt(2)
-        sv[4] = 1./numpy.sqrt(2)
+        sv[1] = 1./np.sqrt(2)
+        sv[4] = 1./np.sqrt(2)
 
         data_type = dtype_to_data_type[self.dtype]
         bit_ordering = list(range(self.n_qubits))
@@ -265,7 +325,7 @@ def test_abs2sum_array_no_mask(self, handle, xp, input_form):
             bit_ordering, 'bit_ordering', *input_form['bit_ordering'])
         # test abs2sum on both host and device
         abs2sum = xp.zeros((2**bit_ordering_len,), dtype=xp.float64)
-        abs2sum_ptr = abs2sum.data.ptr if xp is cupy else abs2sum.ctypes.data
+        abs2sum_ptr = abs2sum.data.ptr if xp is cp else abs2sum.ctypes.data
         cusv.abs2sum_array(
             handle, sv.data.ptr, data_type, self.n_qubits, abs2sum_ptr,
             bit_ordering, bit_ordering_len, 0, 0, 0)
@@ -276,12 +336,96 @@ def test_abs2sum_array_no_mask(self, handle, xp, input_form):
     # TODO(leofang): add more tests for abs2sum_array, such as nontrivial masks
 
 
+class TestBatchedAbs2Sum(TestBatchedSV):
+
+    @pytest.mark.parametrize(
+        'input_form', (
+            {'bit_ordering': (np.int32, 'int_h'),},
+            {'bit_ordering': (np.int32, 'seq'),},
+        )
+    )
+    @pytest.mark.parametrize(
+        'xp', (np, cp)
+     )
+    def test_abs2sum_array_batched_no_mask(self, handle, xp, input_form):
+        # change sv from |0000> to 1/\sqrt{2} (|0001> + |1000>)
+        sv = self.get_sv()
+        sv[..., 0] = 0
+        sv[..., 1] = 1./np.sqrt(2)
+        sv[..., 8] = 1./np.sqrt(2)
+
+        data_type = dtype_to_data_type[self.dtype]
+        bit_ordering = list(range(self.n_qubits))
+        bit_ordering, bit_ordering_len = self._return_data(
+            bit_ordering, 'bit_ordering', *input_form['bit_ordering'])
+
+        # test abs2sum on both host and device
+        abs2sum = xp.zeros((self.n_svs, 2**bit_ordering_len,),
+                           dtype=xp.float64)
+        abs2sum_ptr = abs2sum.data.ptr if xp is cp else abs2sum.ctypes.data
+        cusv.abs2sum_array_batched(
+            handle, sv.data.ptr, data_type, self.n_qubits,
+            self.n_svs, self.sv_stride,
+            abs2sum_ptr, 2**bit_ordering_len,
+            bit_ordering, bit_ordering_len, 0, 0, 0)
+
+        assert xp.allclose(abs2sum.sum(), self.n_svs)
+        assert xp.allclose(abs2sum[..., 1], 0.5)
+        assert xp.allclose(abs2sum[..., 8], 0.5)
+
+    @pytest.mark.parametrize(
+        'input_form', (
+            {'bit_ordering': (np.int32, 'int_h'), 'mask_bit_strings': (np.int64, 'int_h'), },
+            {'bit_ordering': (np.int32, 'int_h'), 'mask_bit_strings': (np.int64, 'int_d'), },
+            {'bit_ordering': (np.int32, 'seq'), 'mask_bit_strings': (np.int64, 'seq'), },
+        )
+    )
+    @pytest.mark.parametrize(
+        'xp', (np, cp)
+     )
+    def test_abs2sum_array_batched_masked(self, handle, xp, input_form):
+        # change sv from |0000> to 1/\sqrt{2} (|0001> + |1000>)
+        sv = self.get_sv()
+        sv[..., 0] = 0
+        sv[..., 1] = 1./np.sqrt(2)
+        sv[..., 8] = 1./np.sqrt(2)
+
+        data_type = dtype_to_data_type[self.dtype]
+        bit_ordering = list(range(self.n_qubits - 1))  # exclude the last qubit
+        bit_ordering, bit_ordering_len = self._return_data(
+            bit_ordering, 'bit_ordering', *input_form['bit_ordering'])
+
+        # mask = 0b1
+        mask_bit_strings = np.ones(self.n_svs)
+        mask_bit_strings, _ = self._return_data(
+            mask_bit_strings, 'mask_bit_strings',
+            *input_form['mask_bit_strings'])
+        mask_bit_ordering = [self.n_qubits - 1]
+        mask_bit_ordering, mask_len = self._return_data(
+            mask_bit_ordering, 'mask_bit_ordering', *input_form['bit_ordering'])
+
+        # test abs2sum on both host and device
+        abs2sum = xp.zeros((self.n_svs, 2**bit_ordering_len,),
+                           dtype=xp.float64)
+        abs2sum_ptr = abs2sum.data.ptr if xp is cp else abs2sum.ctypes.data
+        cusv.abs2sum_array_batched(
+            handle, sv.data.ptr, data_type, self.n_qubits,
+            self.n_svs, self.sv_stride,
+            abs2sum_ptr, 2**bit_ordering_len,
+            bit_ordering, bit_ordering_len,
+            mask_bit_strings, mask_bit_ordering, mask_len)
+
+        # we mask out half of the values
+        assert xp.allclose(abs2sum.sum(), self.n_svs * 0.5)
+        assert xp.allclose(abs2sum[..., 0], 0.5)
+
+
 class TestCollapse(TestSV):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'basis_bits': (numpy.int32, 'int'),},
-            {'basis_bits': (numpy.int32, 'seq'),},
+            {'basis_bits': (np.int32, 'int'),},
+            {'basis_bits': (np.int32, 'seq'),},
         )
     )
     @pytest.mark.parametrize(
@@ -299,21 +443,21 @@ def test_collapse_on_z_basis(self, handle, parity, input_form):
             parity, basis_bits, basis_bits_len, 1)
 
         if parity == 0:
-            assert cupy.allclose(sv.sum(), 1)
+            assert cp.allclose(sv.sum(), 1)
         elif parity == 1:
-            assert cupy.allclose(sv.sum(), 0)
+            assert cp.allclose(sv.sum(), 0)
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'bit_ordering': (numpy.int32, 'int'), 'bitstring': (numpy.int32, 'int')},
-            {'bit_ordering': (numpy.int32, 'seq'), 'bitstring': (numpy.int32, 'seq')},
+            {'bit_ordering': (np.int32, 'int'), 'bitstring': (np.int32, 'int')},
+            {'bit_ordering': (np.int32, 'seq'), 'bitstring': (np.int32, 'seq')},
         )
     )
     def test_collapse_by_bitstring(self, handle, input_form):
         # change sv to 1/\sqrt{2} (|000> + |111>)
         sv = self.get_sv()
-        sv[0] = numpy.sqrt(0.5)
-        sv[-1] = numpy.sqrt(0.5)
+        sv[0] = np.sqrt(0.5)
+        sv[-1] = np.sqrt(0.5)
 
         # collapse to |111>
         bitstring = [1] * self.n_qubits
@@ -331,14 +475,64 @@ def test_collapse_by_bitstring(self, handle, input_form):
             handle, sv.data.ptr, data_type, self.n_qubits,
             bitstring, bit_ordering, bitstring_len,
             norm)
-        assert cupy.allclose(sv.sum(), 1)
-        assert cupy.allclose(sv[-1], 1)
+        assert cp.allclose(sv.sum(), 1)
+        assert cp.allclose(sv[-1], 1)
+
+
+class TestBatchedCollapse(TestBatchedSV):
+
+    @pytest.mark.parametrize(
+        'input_form', (
+            {'bit_ordering': (np.int32, 'int_h'), 'bitstrings': (np.int64, 'int_d'), 'norms': (np.double, 'int_d')},
+            {'bit_ordering': (np.int32, 'int_h'), 'bitstrings': (np.int64, 'int_h'), 'norms': (np.double, 'int_h')},
+            {'bit_ordering': (np.int32, 'seq'), 'bitstrings': (np.int64, 'seq'), 'norms': (np.double, 'seq')},
+        )
+    )
+    def test_collapse_by_bitstring_batched(self, handle, input_form):
+        # change sv to 1/\sqrt{2} (|00...0> + |11...1>)
+        sv = self.get_sv()
+        sv[:, 0] = np.sqrt(0.5)
+        sv[:, 2**self.n_qubits-1] = np.sqrt(0.5)  # Note the padding at the end
+
+        bit_ordering = list(range(self.n_qubits))
+        bit_ordering, _ = self._return_data(
+            bit_ordering, 'bit_ordering', *input_form['bit_ordering'])
+        bitstrings_len = self.n_qubits
+        data_type = dtype_to_data_type[self.dtype]
+
+        # collapse to |11...1>
+        bitstrings = [2**self.n_qubits-1] * self.n_svs
+        bitstrings, _ = self._return_data(
+            bitstrings, 'bitstrings', *input_form['bitstrings'])
+
+        # the sv after collapse is normalized as sv -> sv / \sqrt{norm}
+        norms = [0.5] * self.n_svs
+        norms, _ = self._return_data(
+            norms, 'norms', *input_form['norms'])
+
+        workspace_size = cusv.collapse_by_bitstring_batched_get_workspace_size(
+            handle, self.n_svs, bitstrings, norms)
+        if workspace_size > 0:
+            workspace = cp.cuda.alloc(workspace_size)
+            workspace_ptr = workspace.ptr
+        else:
+            workspace_ptr = 0
+
+        cusv.collapse_by_bitstring_batched(
+            handle, sv.data.ptr, data_type, self.n_qubits,
+            self.n_svs, self.sv_stride,
+            bitstrings, bit_ordering, bitstrings_len,
+            norms,
+            workspace_ptr, workspace_size)
+        cp.cuda.Device().synchronize()
+        assert cp.allclose(sv[:, 0:2**self.n_qubits].sum(), self.n_svs)
+        assert cp.allclose(sv[:, 2**self.n_qubits-1], cp.ones(self.n_svs, dtype=self.dtype))
 
 
 @pytest.mark.parametrize(
     'rand',
     # the choices here ensure we get either parity
-    (0, numpy.nextafter(1, 0))
+    (0, np.nextafter(1, 0))
 )
 @pytest.mark.parametrize(
     'collapse',
@@ -348,16 +542,16 @@ class TestMeasure(TestSV):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'basis_bits': (numpy.int32, 'int'),},
-            {'basis_bits': (numpy.int32, 'seq'),},
+            {'basis_bits': (np.int32, 'int'),},
+            {'basis_bits': (np.int32, 'seq'),},
         )
     )
     def test_measure_on_z_basis(self, handle, rand, collapse, input_form):
         # change the sv to 1/\sqrt{2} (|000> + |010>) to allow 50-50 chance
         # of getting either parity
         sv = self.get_sv()
-        sv[0] = numpy.sqrt(0.5)
-        sv[2] = numpy.sqrt(0.5)
+        sv[0] = np.sqrt(0.5)
+        sv[2] = np.sqrt(0.5)
 
         basis_bits = list(range(self.n_qubits))
         basis_bits, basis_bits_len = self._return_data(
@@ -372,10 +566,10 @@ def test_measure_on_z_basis(self, handle, rand, collapse, input_form):
         if collapse == cusv.Collapse.NORMALIZE_AND_ZERO:
             if parity == 0:
                 # collapse to |000>
-                assert cupy.allclose(sv[0], 1)
+                assert cp.allclose(sv[0], 1)
             elif parity == 1:
                 # collapse to |111>
-                assert cupy.allclose(sv[2], 1)
+                assert cp.allclose(sv[2], 1)
             # sv is collapsed
             assert not (sv == orig_sv).all()
         else:
@@ -384,19 +578,19 @@ def test_measure_on_z_basis(self, handle, rand, collapse, input_form):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'bit_ordering': (numpy.int32, 'int'),},
-            {'bit_ordering': (numpy.int32, 'seq'),},
+            {'bit_ordering': (np.int32, 'int'),},
+            {'bit_ordering': (np.int32, 'seq'),},
         )
     )
     def test_batch_measure(self, handle, rand, collapse, input_form):
         # change sv to 1/\sqrt{2} (|000> + |111>)
         sv = self.get_sv()
-        sv[0] = numpy.sqrt(0.5)
-        sv[-1] = numpy.sqrt(0.5)
+        sv[0] = np.sqrt(0.5)
+        sv[-1] = np.sqrt(0.5)
         orig_sv = sv.copy()
 
         data_type = dtype_to_data_type[self.dtype]
-        bitstring = numpy.empty(self.n_qubits, dtype=numpy.int32)
+        bitstring = np.empty(self.n_qubits, dtype=np.int32)
         bit_ordering = list(range(self.n_qubits))
         bit_ordering, _ = self._return_data(
             bit_ordering, 'bit_ordering', *input_form['bit_ordering'])
@@ -406,32 +600,104 @@ def test_batch_measure(self, handle, rand, collapse, input_form):
             bitstring.ctypes.data, bit_ordering, bitstring.size,
             rand, collapse)
 
-        if collapse == cusv.Collapse.NORMALIZE_AND_ZERO:
-            if bitstring.sum() == 0:
+        if bitstring.sum() == 0:
+            assert rand == 0
+            if collapse == cusv.Collapse.NORMALIZE_AND_ZERO:
                 # collapse to |000>
-                assert cupy.allclose(sv[0], 1)
-            elif bitstring.sum() == 3:
+                assert cp.allclose(sv[0], 1)
+                # sv is collapsed
+                assert (sv != orig_sv).any()
+            else:
+                # sv is intact
+                assert (sv == orig_sv).all()
+        elif bitstring.sum() == self.n_qubits:
+            assert rand == np.nextafter(1, 0)
+            if collapse == cusv.Collapse.NORMALIZE_AND_ZERO:
                 # collapse to |111>
-                assert cupy.allclose(sv[-1], 1)
+                assert cp.allclose(sv[-1], 1)
+                # sv is collapsed
+                assert (sv != orig_sv).any()
             else:
-                assert False, f"unexpected bitstring: {bitstring}"
-            # sv is collapsed
-            assert not (sv == orig_sv).all()
+                # sv is intact
+                assert (sv == orig_sv).all()
         else:
-            assert bitstring.sum() in (0, 3)
-            # sv is intact
-            assert (sv == orig_sv).all()
+            assert False, f"unexpected bitstrings: {bitstrings}"
+
+
+class TestMeasureBatched(TestBatchedSV):
+
+    @pytest.mark.parametrize(
+        'rand',
+        # the choices here ensure we get either parity
+        (0, np.nextafter(1, 0))
+    )
+    @pytest.mark.parametrize(
+        'input_form', (
+            {'bitstrings': (np.int64, 'int_h'), 'bit_ordering': (np.int32, 'int_h'), 'rand_nums': (np.float64, 'int_h')},
+            {'bitstrings': (np.int64, 'int_d'), 'bit_ordering': (np.int32, 'int_h'), 'rand_nums': (np.float64, 'int_d')},
+            {'bitstrings': (np.int64, 'int_d'), 'bit_ordering': (np.int32, 'seq'), 'rand_nums': (np.float64, 'seq')},
+        )
+    )
+    @pytest.mark.parametrize('collapse', cusv.Collapse)
+    @pytest.mark.parametrize('xp', (np, cp))
+    def test_measure_batched(self, handle, rand, input_form, collapse, xp):
+        # change sv to 1/\sqrt{2} (|00...0> + |11...1>)
+        sv = self.get_sv()
+        sv[:, 0] = np.sqrt(0.5)
+        sv[:, 2**self.n_qubits-1] = np.sqrt(0.5)  # Note the padding at the end
+        orig_sv = sv.copy()
+
+        data_type = dtype_to_data_type[self.dtype]
+        bitstrings = np.empty(self.n_svs, dtype=np.int32)
+        bitstrings, _ = self._return_data(
+            bitstrings, 'bitstrings', *input_form['bitstrings'])
+        bit_ordering = list(range(self.n_qubits))
+        bit_ordering, bit_ordering_len = self._return_data(
+            bit_ordering, 'bit_ordering', *input_form['bit_ordering'])
+        rand_nums = [rand] * self.n_svs
+        rand_nums, _ = self._return_data(
+            rand_nums, 'rand_nums', *input_form['rand_nums'])
+
+        cusv.measure_batched(
+            handle, sv.data.ptr, data_type, self.n_qubits,
+            self.n_svs, self.sv_stride,
+            bitstrings, bit_ordering, bit_ordering_len,
+            rand_nums, collapse)
+
+        bitstrings = self.bitstrings
+        if bitstrings.sum() == 0:
+            assert rand == 0
+            if collapse == cusv.Collapse.NORMALIZE_AND_ZERO:
+                # collapse to |00...0>
+                assert cp.allclose(sv[:, 0], 1)
+                # sv is collapsed
+                assert (sv != orig_sv).any()
+            else:
+                # sv is intact
+                assert (sv == orig_sv).all()
+        elif bitstrings.sum() == (2**self.n_qubits-1)*self.n_svs:
+            assert rand == np.nextafter(1, 0)
+            if collapse == cusv.Collapse.NORMALIZE_AND_ZERO:
+                # collapse to |11...1>
+                assert cp.allclose(sv[:, 2**self.n_qubits-1], 1)
+                # sv is collapsed
+                assert (sv != orig_sv).any()
+            else:
+                # sv is intact
+                assert (sv == orig_sv).all()
+        else:
+            assert False, f"unexpected bitstrings: {bitstrings}"
 
 
 class TestApply(TestSV):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'targets': (numpy.int32, 'int'), 'controls': (numpy.int32, 'int'),
+            {'targets': (np.int32, 'int'), 'controls': (np.int32, 'int'),
              # sizeof(enum) == sizeof(int)
-             'paulis': (numpy.int32, 'int'),},
-            {'targets': (numpy.int32, 'seq'), 'controls': (numpy.int32, 'seq'),
-             'paulis': (numpy.int32, 'seq'),},
+             'paulis': (np.int32, 'int'),},
+            {'targets': (np.int32, 'seq'), 'controls': (np.int32, 'seq'),
+             'paulis': (np.int32, 'seq'),},
         )
     )
     def test_apply_pauli_rotation(self, handle, input_form):
@@ -454,25 +720,25 @@ def test_apply_pauli_rotation(self, handle, input_form):
 
         cusv.apply_pauli_rotation(
             handle, sv.data.ptr, data_type, self.n_qubits,
-            0.5*numpy.pi, paulis,
+            0.5*np.pi, paulis,
             targets, targets_len,
             controls, control_values, controls_len)
         sv *= -1j
 
         # result is |111>
-        assert cupy.allclose(sv[-1], 1)
+        assert cp.allclose(sv[-1], 1)
 
     @pytest.mark.parametrize(
         'mempool', (None, 'py-callable', 'cffi', 'cffi_struct')
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'targets': (numpy.int32, 'int'), 'controls': (numpy.int32, 'int')},
-            {'targets': (numpy.int32, 'seq'), 'controls': (numpy.int32, 'seq')},
+            {'targets': (np.int32, 'int'), 'controls': (np.int32, 'int')},
+            {'targets': (np.int32, 'seq'), 'controls': (np.int32, 'seq')},
         )
     )
     @pytest.mark.parametrize(
-        'xp', (numpy, cupy)
+        'xp', (np, cp)
      )
     def test_apply_matrix(self, handle, xp, input_form, mempool):
         if (isinstance(mempool, str) and mempool.startswith('cffi')
@@ -492,7 +758,7 @@ def test_apply_matrix(self, handle, xp, input_form, mempool):
         # matrix can live on host or device
         matrix = xp.zeros((2**self.n_qubits, 2**self.n_qubits), dtype=sv.dtype)
         matrix[-1][0] = 1
-        matrix_ptr = matrix.ctypes.data if xp is numpy else matrix.data.ptr
+        matrix_ptr = matrix.ctypes.data if xp is np else matrix.data.ptr
 
         if mempool is None:
             workspace_size = cusv.apply_matrix_get_workspace_size(
@@ -500,7 +766,7 @@ def test_apply_matrix(self, handle, xp, input_form, mempool):
                 matrix_ptr, data_type, cusv.MatrixLayout.ROW, 0,
                 targets_len, controls_len, compute_type)
             if workspace_size:
-                workspace = cupy.cuda.alloc(workspace_size)
+                workspace = cp.cuda.alloc(workspace_size)
                 workspace_ptr = workspace.ptr
             else:
                 workspace_ptr = 0
@@ -521,20 +787,19 @@ def test_apply_matrix(self, handle, xp, input_form, mempool):
 
         assert sv[-1] == 1  # output state is |111>
 
-
     @pytest.mark.parametrize(
         'mempool', (None, 'py-callable', 'cffi', 'cffi_struct')
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'permutation': (numpy.int64, 'int'), 'basis_bits': (numpy.int32, 'int'),
-             'mask_bitstring': (numpy.int32, 'int'), 'mask_ordering': (numpy.int32, 'int')},
-            {'permutation': (numpy.int64, 'seq'), 'basis_bits': (numpy.int32, 'seq'),
-             'mask_bitstring': (numpy.int32, 'seq'), 'mask_ordering': (numpy.int32, 'seq')},
+            {'permutation': (np.int64, 'int'), 'basis_bits': (np.int32, 'int'),
+             'mask_bitstring': (np.int32, 'int'), 'mask_ordering': (np.int32, 'int')},
+            {'permutation': (np.int64, 'seq'), 'basis_bits': (np.int32, 'seq'),
+             'mask_bitstring': (np.int32, 'seq'), 'mask_ordering': (np.int32, 'seq')},
         )
     )
     @pytest.mark.parametrize(
-        'xp', (numpy, cupy)
+        'xp', (np, cp)
      )
     def test_apply_generalized_permutation_matrix(
             self, handle, xp, input_form, mempool):
@@ -548,14 +813,14 @@ def test_apply_generalized_permutation_matrix(
         compute_type = dtype_to_compute_type[self.dtype]
 
         # TODO(leofang): test permutation on either host or device
-        permutation = list(numpy.random.permutation(2**self.n_qubits))
+        permutation = list(np.random.permutation(2**self.n_qubits))
         permutation_data = permutation
         permutation, permutation_len = self._return_data(
             permutation, 'permutation', *input_form['permutation'])
 
         # diagonal can live on host or device
         diagonal = 10 * xp.ones((2**self.n_qubits, ), dtype=sv.dtype)
-        diagonal_ptr = diagonal.ctypes.data if xp is numpy else diagonal.data.ptr
+        diagonal_ptr = diagonal.ctypes.data if xp is np else diagonal.data.ptr
 
         basis_bits = list(range(self.n_qubits))
         basis_bits, basis_bits_len = self._return_data(
@@ -573,7 +838,7 @@ def test_apply_generalized_permutation_matrix(
                 basis_bits, basis_bits_len, mask_len)
 
             if workspace_size:
-                workspace = cupy.cuda.alloc(workspace_size)
+                workspace = cp.cuda.alloc(workspace_size)
                 workspace_ptr = workspace.ptr
             else:
                 workspace_ptr = 0
@@ -592,7 +857,85 @@ def test_apply_generalized_permutation_matrix(
             mask_bitstring, mask_ordering, mask_len,
             workspace_ptr, workspace_size)
 
-        assert cupy.allclose(sv, diagonal[xp.asarray(permutation_data)])
+        assert cp.allclose(sv, diagonal[xp.asarray(permutation_data)])
+
+
+class TestBatchedApply(TestBatchedSV):
+
+    @pytest.mark.parametrize(
+        'mempool', (None, 'py-callable', 'cffi', 'cffi_struct')
+    )
+    @pytest.mark.parametrize(
+        'input_form', (
+            {'matrix_indices': (np.int32, 'int_h'), 'targets': (np.int32, 'int_h'), 'controls': (np.int32, 'int_h')},
+            {'matrix_indices': (np.int32, 'int_d'), 'targets': (np.int32, 'int_h'), 'controls': (np.int32, 'int_h')},
+            {'matrix_indices': (np.int32, 'seq'), 'targets': (np.int32, 'seq'), 'controls': (np.int32, 'seq')},
+        )
+    )
+    @pytest.mark.parametrize('xp', (np, cp))
+    @pytest.mark.parametrize('map_type', cusv.MatrixMapType)
+    def test_apply_matrix_batched(
+            self, handle, map_type, xp, input_form, mempool):
+        if (isinstance(mempool, str) and mempool.startswith('cffi')
+                and not _can_use_cffi()):
+            pytest.skip("cannot run cffi tests")
+
+        sv = self.get_sv()
+        data_type = dtype_to_data_type[self.dtype]
+        compute_type = dtype_to_compute_type[self.dtype]
+        targets = list(range(self.n_qubits))
+        targets, targets_len = self._return_data(
+            targets, 'targets', *input_form['targets'])
+        controls = []
+        controls, controls_len = self._return_data(
+            controls, 'controls', *input_form['controls'])
+
+        if map_type == cusv.MatrixMapType.BROADCAST:
+            n_matrices = 1
+        elif map_type == cusv.MatrixMapType.MATRIX_INDEXED:
+            n_matrices = self.n_svs
+
+        # matrices and their indices can live on host or device
+        matrices = xp.zeros(
+            (n_matrices, 2**self.n_qubits, 2**self.n_qubits),
+            dtype=sv.dtype)
+        matrices[..., -1, 0] = 1
+        matrices_ptr = matrices.ctypes.data if xp is np else matrices.data.ptr
+        matrix_indices = list(range(n_matrices))
+        if len(matrix_indices) > 1:
+            np.random.shuffle(matrix_indices)
+        matrix_indices, n_matrices = self._return_data(
+            matrix_indices, 'matrix_indices', *input_form['matrix_indices'])
+
+        if mempool is None:
+            workspace_size = cusv.apply_matrix_batched_get_workspace_size(
+                handle, data_type, self.n_qubits, self.n_svs, self.sv_stride,
+                map_type, matrix_indices, matrices_ptr, data_type,
+                cusv.MatrixLayout.ROW, 0, n_matrices,
+                targets_len, controls_len, compute_type)
+            if workspace_size:
+                workspace = cp.cuda.alloc(workspace_size)
+                workspace_ptr = workspace.ptr
+            else:
+                workspace_ptr = 0
+        else:
+            mr = MemoryResourceFactory(mempool)
+            handler = mr.get_dev_mem_handler()
+            cusv.set_device_mem_handler(handle, handler)
+
+            workspace_ptr = 0
+            workspace_size = 0
+
+        cusv.apply_matrix_batched(
+            handle, sv.data.ptr, data_type, self.n_qubits,
+            self.n_svs, self.sv_stride, map_type, matrix_indices,
+            matrices_ptr, data_type,
+            cusv.MatrixLayout.ROW, 0, n_matrices,
+            targets, targets_len,
+            controls, 0, controls_len,
+            compute_type, workspace_ptr, workspace_size)
+
+        assert (sv[..., 2**self.n_qubits-1] == 1).all()  # output state is |11...1>
 
 
 class TestExpect(TestSV):
@@ -602,15 +945,15 @@ class TestExpect(TestSV):
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'basis_bits': (numpy.int32, 'int'),},
-            {'basis_bits': (numpy.int32, 'seq'),},
+            {'basis_bits': (np.int32, 'int'),},
+            {'basis_bits': (np.int32, 'seq'),},
         )
     )
     @pytest.mark.parametrize(
-        'expect_dtype', (numpy.float64, numpy.complex128)
+        'expect_dtype', (np.float64, np.complex128)
     )
     @pytest.mark.parametrize(
-        'xp', (numpy, cupy)
+        'xp', (np, cp)
     )
     def test_compute_expectation(self, handle, xp, expect_dtype, input_form, mempool):
         if (isinstance(mempool, str) and mempool.startswith('cffi')
@@ -619,7 +962,7 @@ def test_compute_expectation(self, handle, xp, expect_dtype, input_form, mempool
 
         # create a uniform sv
         sv = self.get_sv()
-        sv[:] = numpy.sqrt(1/(2**self.n_qubits))
+        sv[:] = np.sqrt(1/(2**self.n_qubits))
 
         data_type = dtype_to_data_type[self.dtype]
         compute_type = dtype_to_compute_type[self.dtype]
@@ -629,7 +972,7 @@ def test_compute_expectation(self, handle, xp, expect_dtype, input_form, mempool
 
         # matrix can live on host or device
         matrix = xp.ones((2**self.n_qubits, 2**self.n_qubits), dtype=sv.dtype)
-        matrix_ptr = matrix.ctypes.data if xp is numpy else matrix.data.ptr
+        matrix_ptr = matrix.ctypes.data if xp is np else matrix.data.ptr
 
         if mempool is None:
             workspace_size = cusv.compute_expectation_get_workspace_size(
@@ -637,7 +980,7 @@ def test_compute_expectation(self, handle, xp, expect_dtype, input_form, mempool
                 matrix_ptr, data_type, cusv.MatrixLayout.ROW,
                 basis_bits_len, compute_type)
             if workspace_size:
-                workspace = cupy.cuda.alloc(workspace_size)
+                workspace = cp.cuda.alloc(workspace_size)
                 workspace_ptr = workspace.ptr
             else:
                 workspace_ptr = 0
@@ -649,10 +992,10 @@ def test_compute_expectation(self, handle, xp, expect_dtype, input_form, mempool
             workspace_ptr = 0
             workspace_size = 0
 
-        expect = numpy.empty((1,), dtype=expect_dtype)
+        expect = np.empty((1,), dtype=expect_dtype)
         # TODO(leofang): check if this is relaxed in beta 2
         expect_data_type = (
-            cudaDataType.CUDA_R_64F if expect_dtype == numpy.float64
+            cudaDataType.CUDA_R_64F if expect_dtype == np.float64
             else cudaDataType.CUDA_C_64F)
 
         cusv.compute_expectation(
@@ -668,7 +1011,7 @@ def test_compute_expectation(self, handle, xp, expect_dtype, input_form, mempool
     def test_compute_expectations_on_pauli_basis(self, handle):
         # create a uniform sv
         sv = self.get_sv()
-        sv[:] = numpy.sqrt(1/(2**self.n_qubits))
+        sv[:] = np.sqrt(1/(2**self.n_qubits))
         data_type = dtype_to_data_type[self.dtype]
         compute_type = dtype_to_compute_type[self.dtype]
 
@@ -679,16 +1022,16 @@ def test_compute_expectations_on_pauli_basis(self, handle):
 
         basis_bits = [[*range(self.n_qubits)] for i in range(len(paulis))]
         n_basis_bits = [len(basis_bits[i]) for i in range(len(paulis))]
-        expect = numpy.empty((len(paulis),), dtype=numpy.float64)
+        expect = np.empty((len(paulis),), dtype=np.float64)
 
         cusv.compute_expectations_on_pauli_basis(
             handle, sv.data.ptr, data_type, self.n_qubits,
             expect.ctypes.data, paulis, len(paulis),
             basis_bits, n_basis_bits)
 
-        result = numpy.zeros_like(expect)
+        result = np.zeros_like(expect)
         result[0] = 1  # for XX...X
-        assert numpy.allclose(expect, result)
+        assert np.allclose(expect, result)
 
 
 class TestSampler(TestSV):
@@ -698,8 +1041,8 @@ class TestSampler(TestSV):
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'bit_ordering': (numpy.int32, 'int'),},
-            {'bit_ordering': (numpy.int32, 'seq'),},
+            {'bit_ordering': (np.int32, 'int'),},
+            {'bit_ordering': (np.int32, 'seq'),},
         )
     )
     def test_sampling(self, handle, input_form, mempool):
@@ -709,14 +1052,14 @@ def test_sampling(self, handle, input_form, mempool):
 
         # create a uniform sv
         sv = self.get_sv()
-        sv[:] = numpy.sqrt(1/(2**self.n_qubits))
+        sv[:] = np.sqrt(1/(2**self.n_qubits))
 
         data_type = dtype_to_data_type[self.dtype]
         compute_type = dtype_to_compute_type[self.dtype]
         shots = 4096
 
-        bitstrings = numpy.empty((shots,), dtype=numpy.int64)
-        rand_nums = numpy.random.random((shots,)).astype(numpy.float64)
+        bitstrings = np.empty((shots,), dtype=np.int64)
+        rand_nums = np.random.random((shots,)).astype(np.float64)
         # measure all qubits
         bit_ordering = list(range(self.n_qubits))
         bit_ordering, _ = self._return_data(
@@ -726,7 +1069,7 @@ def test_sampling(self, handle, input_form, mempool):
             handle, sv.data.ptr, data_type, self.n_qubits, shots)
         if mempool is None:
             if workspace_size:
-                workspace = cupy.cuda.alloc(workspace_size)
+                workspace = cp.cuda.alloc(workspace_size)
                 workspace_ptr = workspace.ptr
             else:
                 workspace_ptr = 0
@@ -756,13 +1099,13 @@ def test_sampling(self, handle, input_form, mempool):
         finally:
             cusv.sampler_destroy(sampler)
 
-        keys, counts = numpy.unique(bitstrings, return_counts=True)
+        keys, counts = np.unique(bitstrings, return_counts=True)
         # keys are the returned bitstrings 000, 001, ..., 111
         # the sv has all components, and unique() returns a sorted array,
         # so the following should hold:
-        assert (keys == numpy.arange(2**self.n_qubits)).all()
+        assert (keys == np.arange(2**self.n_qubits)).all()
 
-        assert numpy.allclose(norm, 1)
+        assert np.allclose(norm, 1)
 
         # TODO: test counts, which should follow a uniform distribution
 
@@ -773,8 +1116,8 @@ def test_sampling(self, handle, input_form, mempool):
 # TODO(leofang): test mask_bitstring & mask_ordering
 @pytest.mark.parametrize(
     'input_form', (
-        {'bit_ordering': (numpy.int32, 'int'), 'mask_bitstring': (numpy.int32, 'int'), 'mask_ordering': (numpy.int32, 'int')},
-        {'bit_ordering': (numpy.int32, 'seq'), 'mask_bitstring': (numpy.int32, 'seq'), 'mask_ordering': (numpy.int32, 'seq')},
+        {'bit_ordering': (np.int32, 'int'), 'mask_bitstring': (np.int32, 'int'), 'mask_ordering': (np.int32, 'int')},
+        {'bit_ordering': (np.int32, 'seq'), 'mask_bitstring': (np.int32, 'seq'), 'mask_ordering': (np.int32, 'seq')},
     )
 )
 @pytest.mark.parametrize(
@@ -789,8 +1132,8 @@ def test_accessor_get(self, handle, readonly, input_form, mempool):
 
         # create a monotonically increasing sv
         sv = self.get_sv()
-        data = cupy.arange(2**self.n_qubits, dtype=sv.dtype)
-        data /= cupy.sqrt(data**2)
+        data = cp.arange(2**self.n_qubits, dtype=sv.dtype)
+        data /= cp.sqrt(data**2)
         sv[:] = data
 
         data_type = dtype_to_data_type[self.dtype]
@@ -818,7 +1161,7 @@ def test_accessor_get(self, handle, readonly, input_form, mempool):
         try:
             if mempool is None:
                 if workspace_size:
-                    workspace = cupy.cuda.alloc(workspace_size)
+                    workspace = cp.cuda.alloc(workspace_size)
                     workspace_ptr = workspace.ptr
                 else:
                     workspace_ptr = 0
@@ -834,7 +1177,7 @@ def test_accessor_get(self, handle, readonly, input_form, mempool):
                 handle, accessor, workspace_ptr, workspace_size)
 
             buf_len = 2**2
-            buf = cupy.empty(buf_len, dtype=sv.dtype)
+            buf = cp.empty(buf_len, dtype=sv.dtype)
 
             # copy the last buf_len elements
             cusv.accessor_get(
@@ -851,8 +1194,8 @@ def test_accessor_set(self, handle, readonly, input_form, mempool):
 
         # create a monotonically increasing sv
         sv = self.get_sv()
-        data = cupy.arange(2**self.n_qubits, dtype=sv.dtype)
-        data /= cupy.sqrt(data**2)
+        data = cp.arange(2**self.n_qubits, dtype=sv.dtype)
+        data /= cp.sqrt(data**2)
         sv[:] = data
 
         data_type = dtype_to_data_type[self.dtype]
@@ -880,7 +1223,7 @@ def test_accessor_set(self, handle, readonly, input_form, mempool):
         try:
             if mempool is None:
                 if workspace_size:
-                    workspace = cupy.cuda.alloc(workspace_size)
+                    workspace = cp.cuda.alloc(workspace_size)
                     workspace_ptr = workspace.ptr
                 else:
                     workspace_ptr = 0
@@ -896,7 +1239,7 @@ def test_accessor_set(self, handle, readonly, input_form, mempool):
                 handle, accessor, workspace_ptr, workspace_size)
 
             buf_len = 2**2
-            buf = cupy.zeros(buf_len, dtype=sv.dtype)
+            buf = cp.zeros(buf_len, dtype=sv.dtype)
 
             if readonly:
                 # copy the last buf_len elements would fail
@@ -927,15 +1270,15 @@ class TestTestMatrixType:
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'targets': (numpy.int32, 'int'), },
-            {'targets': (numpy.int32, 'seq'), },
+            {'targets': (np.int32, 'int'), },
+            {'targets': (np.int32, 'seq'), },
         )
     )
     @pytest.mark.parametrize(
-        'dtype', (numpy.complex64, numpy.complex128)
+        'dtype', (np.complex64, np.complex128)
     )
     @pytest.mark.parametrize(
-        'xp', (numpy, cupy)
+        'xp', (np, cp)
      )
     def test_apply_matrix_type(
             self, handle, xp, dtype, input_form, matrix_type, mempool):
@@ -951,7 +1294,7 @@ def test_apply_matrix_type(
         # choose a trivial matrix
         data = xp.ones(2**n_targets, dtype=dtype)
         matrix = xp.diag(data)
-        matrix_ptr = matrix.ctypes.data if xp is numpy else matrix.data.ptr
+        matrix_ptr = matrix.ctypes.data if xp is np else matrix.data.ptr
 
         if mempool is None:
             workspace_size = cusv.test_matrix_type_get_workspace_size(
@@ -959,7 +1302,7 @@ def test_apply_matrix_type(
                 matrix_ptr, data_type, cusv.MatrixLayout.ROW, n_targets,
                 0, compute_type)
             if workspace_size:
-                workspace = cupy.cuda.alloc(workspace_size)
+                workspace = cp.cuda.alloc(workspace_size)
                 workspace_ptr = workspace.ptr
             else:
                 workspace_ptr = 0
@@ -975,26 +1318,26 @@ def test_apply_matrix_type(
             handle, matrix_type,
             matrix_ptr, data_type, cusv.MatrixLayout.ROW, n_targets,
             0, compute_type, workspace_ptr, workspace_size)
-        assert numpy.isclose(residual, 0)
+        assert np.isclose(residual, 0)
 
 
 @pytest.mark.parametrize(
     'rand',
     # the choices here ensure we get either parity
-    (0, numpy.nextafter(1, 0))
+    (0, np.nextafter(1, 0))
 )
 @pytest.mark.parametrize(
     'collapse',
     (cusv.Collapse.NORMALIZE_AND_ZERO, cusv.Collapse.NONE)
 )
 @pytest.mark.skipif(
-    cupy.cuda.runtime.getDeviceCount() < 2, reason='not enough GPUs')
+    cp.cuda.runtime.getDeviceCount() < 2, reason='not enough GPUs')
 class TestBatchMeasureWithSubSV(TestMultiGpuSV):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'bit_ordering': (numpy.int32, 'int'),},
-            {'bit_ordering': (numpy.int32, 'seq'),},
+            {'bit_ordering': (np.int32, 'int'),},
+            {'bit_ordering': (np.int32, 'seq'),},
         )
     )
     @pytest.mark.parametrize(
@@ -1011,28 +1354,28 @@ def test_batch_measure_with_offset(
 
         # change sv to 1/\sqrt{2} (|0000> + |1111>), and compute abs2sum;
         # calling abs2sum_array is also OK, but we focus on testing the target API
-        cumulative_array = numpy.zeros(self.n_devices+1, dtype=numpy.float64)
+        cumulative_array = np.zeros(self.n_devices+1, dtype=np.float64)
         for i_sv in range(self.n_devices):
-            with cupy.cuda.Device(i_sv):
+            with cp.cuda.Device(i_sv):
                 if i_sv == 0:
                     # |0 000> is on GPU 0
-                    sub_sv[i_sv][0] = numpy.sqrt(0.5)
+                    sub_sv[i_sv][0] = np.sqrt(0.5)
                 elif i_sv == 1:
                     # |1 111> is on GPU 1
-                    sub_sv[i_sv][-1] = numpy.sqrt(0.5)
-                abs2sum = cupy.asnumpy(cupy.sum(cupy.abs(sub_sv[i_sv])**2))
+                    sub_sv[i_sv][-1] = np.sqrt(0.5)
+                abs2sum = cp.asnumpy(cp.sum(cp.abs(sub_sv[i_sv])**2))
                 cumulative_array[i_sv+1] = cumulative_array[i_sv] + abs2sum
 
         orig_sub_sv = copy.deepcopy(sub_sv)
 
-        bitstring = numpy.empty(self.n_local_bits, dtype=numpy.int32)
+        bitstring = np.empty(self.n_local_bits, dtype=np.int32)
         for i_sv in range(self.n_devices):
             if (cumulative_array[i_sv] <= rand
                     and rand < cumulative_array[i_sv+1]):
                 global_bits = i_sv
                 norm = cumulative_array[-1]
                 offset = cumulative_array[i_sv]
-                with cupy.cuda.Device(i_sv) as dev:
+                with cp.cuda.Device(i_sv) as dev:
                     cusv.batch_measure_with_offset(
                         handles[i_sv], sub_sv[i_sv].data.ptr, data_type,
                         self.n_local_bits, bitstring.ctypes.data,
@@ -1056,25 +1399,25 @@ def test_batch_measure_with_offset(
             # the measured sub sv is collapsed (those not measured are intact!)
             if global_bits == 0:
                 # collapse to |0 000>
-                with cupy.cuda.Device(0):
-                    assert cupy.allclose(sub_sv[0][0], 1)
+                with cp.cuda.Device(0):
+                    assert cp.allclose(sub_sv[0][0], 1)
                     assert not (sub_sv[0] == orig_sub_sv[0]).all()
-                with cupy.cuda.Device(1):
+                with cp.cuda.Device(1):
                     assert (sub_sv[1] == orig_sub_sv[1]).all()
             elif global_bits == 1:
                 # collapse to |1 111>
-                with cupy.cuda.Device(0):
+                with cp.cuda.Device(0):
                     assert (sub_sv[0] == orig_sub_sv[0]).all()
-                with cupy.cuda.Device(1):
-                    assert cupy.allclose(sub_sv[1][-1], 1)
+                with cp.cuda.Device(1):
+                    assert cp.allclose(sub_sv[1][-1], 1)
                     assert not (sub_sv[1] == orig_sub_sv[1]).all()
             else:
                 assert False, f"unexpected bitstring: {bitstring}"
         else:
             # sv is intact
-            with cupy.cuda.Device(0):
+            with cp.cuda.Device(0):
                 assert (sub_sv[0] == orig_sub_sv[0]).all()
-            with cupy.cuda.Device(1):
+            with cp.cuda.Device(1):
                 assert (sub_sv[1] == orig_sub_sv[1]).all()
 
 
@@ -1082,18 +1425,18 @@ class TestSwap:
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'swapped_bits': (numpy.int32, 'int'),
-             'mask_bitstring': (numpy.int32, 'int'), 'mask_ordering': (numpy.int32, 'int')},
-            {'swapped_bits': (numpy.int32, 'seq'),
-             'mask_bitstring': (numpy.int32, 'seq'), 'mask_ordering': (numpy.int32, 'seq')},
+            {'swapped_bits': (np.int32, 'int'),
+             'mask_bitstring': (np.int32, 'int'), 'mask_ordering': (np.int32, 'int')},
+            {'swapped_bits': (np.int32, 'seq'),
+             'mask_bitstring': (np.int32, 'seq'), 'mask_ordering': (np.int32, 'seq')},
         )
     )
     @pytest.mark.parametrize(
-        'dtype', (numpy.complex64, numpy.complex128)
+        'dtype', (np.complex64, np.complex128)
     )
     def test_swap_index_bits(self, handle, dtype, input_form):
         n_qubits = 4
-        sv = cupy.zeros(2**n_qubits, dtype=dtype)
+        sv = cp.zeros(2**n_qubits, dtype=dtype)
         data_type = dtype_to_data_type[dtype]
 
         # set sv to |0110>
@@ -1103,7 +1446,7 @@ def test_swap_index_bits(self, handle, dtype, input_form):
         swapped_bits = [(0, 2), (1, 3)]
         n_swapped_bits = len(swapped_bits)
         if input_form['swapped_bits'][1] == 'int':
-            swapped_bits_data = numpy.asarray(
+            swapped_bits_data = np.asarray(
                 swapped_bits, dtype=input_form['swapped_bits'][0])
             swapped_bits = swapped_bits_data.ctypes.data
 
@@ -1127,15 +1470,15 @@ def test_swap_index_bits(self, handle, dtype, input_form):
     'topology', [t for t in cusv.DeviceNetworkType]
 )
 @pytest.mark.skipif(
-    cupy.cuda.runtime.getDeviceCount() < 2, reason='not enough GPUs')
+    cp.cuda.runtime.getDeviceCount() < 2, reason='not enough GPUs')
 class TestMultiGPUSwap(TestMultiGpuSV):
 
     @pytest.mark.parametrize(
         'input_form', (
-            {'handles': (numpy.intp, 'int'), 'sub_svs': (numpy.intp, 'int'),
-             'swapped_bits': (numpy.int32, 'int'), 'mask': (numpy.int32, 'int')},
-            {'handles': (numpy.intp, 'seq'), 'sub_svs': (numpy.intp, 'seq'),
-             'swapped_bits': (numpy.int32, 'seq'), 'mask': (numpy.int32, 'seq')},
+            {'handles': (np.intp, 'int'), 'sub_svs': (np.intp, 'int'),
+             'swapped_bits': (np.int32, 'int'), 'mask': (np.int32, 'int')},
+            {'handles': (np.intp, 'seq'), 'sub_svs': (np.intp, 'seq'),
+             'swapped_bits': (np.int32, 'seq'), 'mask': (np.int32, 'seq')},
         )
     )
     @pytest.mark.parametrize(
@@ -1152,19 +1495,19 @@ def test_multi_device_swap_index_bits(
         data_type = dtype_to_data_type[self.dtype]
 
         # set sv to |0110> (up to normalization)
-        with cupy.cuda.Device(0):
+        with cp.cuda.Device(0):
             sub_sv[0][0] = 0
             sub_sv[0][-2] = 1
 
         if input_form['handles'][1] == 'int':
-            handles_data = numpy.asarray(
+            handles_data = np.asarray(
                 handles, dtype=input_form['handles'][0])
             handles = handles_data.ctypes.data
         sub_sv_data = sub_sv
         sub_sv_ptr_data = [arr.data.ptr for arr in sub_sv]
         sub_sv = sub_sv_ptr_data
         if input_form['sub_svs'][1] == 'int':
-            sub_sv_ptr_data = numpy.asarray(
+            sub_sv_ptr_data = np.asarray(
                 sub_sv_ptr_data, dtype=input_form['sub_svs'][0])
             sub_sv = sub_sv_ptr_data.ctypes.data
         else:
@@ -1173,7 +1516,7 @@ def test_multi_device_swap_index_bits(
         swapped_bits = [(3, 1)]
         n_swapped_bits = len(swapped_bits)
         if input_form['swapped_bits'][1] == 'int':
-            swapped_bits_data = numpy.asarray(
+            swapped_bits_data = np.asarray(
                 swapped_bits, dtype=input_form['swapped_bits'][0])
             swapped_bits = swapped_bits_data.ctypes.data
 
@@ -1182,10 +1525,10 @@ def test_multi_device_swap_index_bits(
         mask_ordering = []
         mask_len = 0
         if input_form['mask'][1] == 'int':
-            mask_bitstring_data = numpy.asarray(
+            mask_bitstring_data = np.asarray(
                 mask_bitstring, dtype=input_form['mask'][0])
             mask_bitstring = mask_bitstring_data.ctypes.data
-            mask_ordering_data = numpy.asarray(
+            mask_ordering_data = np.asarray(
                 mask_ordering, dtype=input_form['mask'][0])
             mask_ordering = mask_ordering_data.ctypes.data
 
@@ -1198,9 +1541,9 @@ def test_multi_device_swap_index_bits(
 
         # now we should get |1100>
         sub_sv = sub_sv_data
-        with cupy.cuda.Device(0):
+        with cp.cuda.Device(0):
             assert sub_sv[0][-2] == 0
-        with cupy.cuda.Device(1):
+        with cp.cuda.Device(1):
             assert sub_sv[1][4] == 1
 
 
@@ -1270,7 +1613,7 @@ def test_parameters(self):
         assert parameters.ptr == new_parameters.ptr
         assert parameters == new_parameters
 
-        new_parameters_arr = numpy.empty(
+        new_parameters_arr = np.empty(
             (1,), dtype=cusv.sv_swap_parameters_dtype)
         new_parameters_arr['segment_mask_ordering'][:] = 1
         new_parameters = cusv.SVSwapParameters.from_data(new_parameters_arr)
@@ -1279,12 +1622,12 @@ def test_parameters(self):
         assert parameters != new_parameters
 
         # negative tests
-        parameters_arr = numpy.empty(
+        parameters_arr = np.empty(
             (2,), dtype=cusv.sv_swap_parameters_dtype)
         with pytest.raises(ValueError) as e:  # wrong size
             parameters = cusv.SVSwapParameters.from_data(parameters_arr)
-        parameters_arr = numpy.empty(
-            (1,), dtype=numpy.float32)
+        parameters_arr = np.empty(
+            (1,), dtype=np.float32)
         with pytest.raises(ValueError) as e:  # wrong dtype
             parameters = cusv.SVSwapParameters.from_data(parameters_arr)
         parameters_arr = "ABC"
@@ -1294,19 +1637,19 @@ def test_parameters(self):
 
 class TestWorker:
 
-    event = cupy.cuda.Event()
-    stream = cupy.cuda.Stream()
-    sv = cupy.zeros((2**4,), dtype=cupy.complex64)
+    event = cp.cuda.Event()
+    stream = cp.cuda.Stream()
+    sv = cp.zeros((2**4,), dtype=cp.complex64)
 
     @pytest.mark.parametrize(
         "worker_args", ((sv.data.ptr, 0, event.ptr, cudaDataType.CUDA_C_32F, stream.ptr),)
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'sv': (numpy.intp, 'int'), 'indices': (numpy.int32, 'int'),
-             'event': (numpy.intp, 'int')},
-            {'sv': (numpy.intp, 'seq'), 'indices': (numpy.int32, 'seq'),
-             'event': (numpy.intp, 'seq')},
+            {'sv': (np.intp, 'int'), 'indices': (np.int32, 'int'),
+             'event': (np.intp, 'int')},
+            {'sv': (np.intp, 'seq'), 'indices': (np.int32, 'seq'),
+             'event': (np.intp, 'seq')},
         )
     )
     @pytest.mark.parametrize(
@@ -1318,30 +1661,30 @@ def test_worker(self, handle, worker_args, input_form, param_form):
             0,  # set the communicator to null, assuming single process
             *worker_args)
 
-        extra_space = cupy.cuda.alloc(extra_size)
+        extra_space = cp.cuda.alloc(extra_size)
         cusv.sv_swap_worker_set_extra_workspace(
             handle, worker, extra_space.ptr, extra_size)
 
-        transfer_space = cupy.cuda.alloc(min_size)
+        transfer_space = cp.cuda.alloc(min_size)
         cusv.sv_swap_worker_set_transfer_workspace(
             handle, worker, transfer_space.ptr, min_size)
 
         sv = [self.sv.data.ptr]
         if input_form['sv'][1] == 'int':
-            sv_data = numpy.asarray(
+            sv_data = np.asarray(
                 sv, dtype=input_form['sv'][0])
             sv = sv_data.ctypes.data
 
         indices = [1]
         if input_form['indices'][1] == 'int':
-            indices_data = numpy.asarray(
+            indices_data = np.asarray(
                 indices, dtype=input_form['indices'][0])
             indices = indices_data.ctypes.data
 
-        dummy = cupy.cuda.Event()
+        dummy = cp.cuda.Event()
         event = [dummy.ptr]
         if input_form['event'][1] == 'int':
-            event_data = numpy.asarray(
+            event_data = np.asarray(
                 event, dtype=input_form['event'][0])
             event = event_data.ctypes.data
 
@@ -1380,8 +1723,8 @@ class TestScheduler:
     )
     @pytest.mark.parametrize(
         'input_form', (
-            {'swapped_bits': (numpy.int32, 'int'), 'mask': (numpy.int32, 'int')},
-            {'swapped_bits': (numpy.int32, 'seq'), 'mask': (numpy.int32, 'seq')},
+            {'swapped_bits': (np.int32, 'int'), 'mask': (np.int32, 'int')},
+            {'swapped_bits': (np.int32, 'seq'), 'mask': (np.int32, 'seq')},
         )
     )
     @pytest.mark.parametrize(
@@ -1394,7 +1737,7 @@ def test_scheduler(self, handle, scheduler_args, input_form, param_form):
         swapped_bits = [(0, 1)]
         n_swapped_bits = len(swapped_bits)
         if input_form['swapped_bits'][1] == 'int':
-            swapped_bits_data = numpy.asarray(
+            swapped_bits_data = np.asarray(
                 swapped_bits, dtype=input_form['swapped_bits'][0])
             swapped_bits = swapped_bits_data.ctypes.data
 
@@ -1403,10 +1746,10 @@ def test_scheduler(self, handle, scheduler_args, input_form, param_form):
         mask_ordering = []
         mask_len = 0
         if input_form['mask'][1] == 'int':
-            mask_bitstring_data = numpy.asarray(
+            mask_bitstring_data = np.asarray(
                 mask_bitstring, dtype=input_form['mask'][0])
             mask_bitstring = mask_bitstring_data.ctypes.data
-            mask_ordering_data = numpy.asarray(
+            mask_ordering_data = np.asarray(
                 mask_ordering, dtype=input_form['mask'][0])
             mask_ordering = mask_ordering_data.ctypes.data
 
@@ -1419,9 +1762,9 @@ def test_scheduler(self, handle, scheduler_args, input_form, param_form):
         elif param_form == "class":
             params_in = cusv.SVSwapParameters()
         elif param_form == "ndarray":
-            params_in = numpy.empty((1,), dtype=cusv.sv_swap_parameters_dtype)
+            params_in = np.empty((1,), dtype=cusv.sv_swap_parameters_dtype)
         elif param_form == "int":
-            params = numpy.empty((1,), dtype=cusv.sv_swap_parameters_dtype)
+            params = np.empty((1,), dtype=cusv.sv_swap_parameters_dtype)
             params_in = params.ctypes.data
         else:
             assert False
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/__init__.py b/python/tests/cuquantum_tests/cutensornet_tests/__init__.py
index 3ff1538..8f8d432 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/__init__.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/__init__.py
@@ -5,6 +5,8 @@
 import cupy as cp
 try:
     import torch
+    if not torch.cuda.is_available():
+        raise ImportError
     torch.backends.cuda.matmul.allow_tf32 = False
     torch.backends.cudnn.allow_tf32 = False
 except ImportError:
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/approxTN_utils.py b/python/tests/cuquantum_tests/cutensornet_tests/approxTN_utils.py
index fde2d03..605c4a1 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/approxTN_utils.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/approxTN_utils.py
@@ -46,6 +46,8 @@ def parse_split_expression(split_expression):
 
 
 def get_new_modes(used_modes, num):
+    # Note: cannot use _internal.circuit_converter_utils._get_symbol() here, as this
+    # module needs to be standalone. We don't need that many symbols here, anyway.
     base_modes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
     new_modes = ""
     for mode in base_modes:
@@ -174,7 +176,7 @@ def split_contract_decompose(subscripts):
 def torch_support_wrapper(func):
     def new_func(T, *args, **kwargs):
         backend = infer_backend(T)
-        if backend not in (cp, np): # torch
+        if backend not in (cp, np):  # torch
             if T.device.type == 'cpu':
                 out = func(T.numpy(), *args, **kwargs)
             else:
@@ -216,7 +218,8 @@ def matrix_svd(
     rel_cutoff=0,
     partition=None,
     normalization=None,
-    return_info=True
+    return_info=True,
+    **kwargs,
 ):
     info = dict()
     backend = infer_backend(T)
@@ -507,13 +510,46 @@ def verify_split_SVD(
     modes_in, left_modes, right_modes, shared_mode = parse_split_expression(split_expression)
     shared_mode_idx = left_modes.index(shared_mode)
     shared_extent = array_u.shape[shared_mode_idx]
-    if is_exact_split(**split_options) and T is not None:
+    try:
+        max_mid_extent = min(array_u.size, array_v.size) // shared_extent
+    except:
+        # for torch
+        max_mid_extent = min(array_u.numel(), array_v.numel()) // shared_extent 
+    max_extent = split_options.pop('max_extent', max_mid_extent)
+    if is_exact_split(**split_options) and max_extent == max_mid_extent and T is not None:
         reference = T
     else:
         reference = reverse_einsum(split_expression, array_u_ref, array_s_ref, array_v_ref)
     out = reverse_einsum(split_expression, array_u, array_s, array_v)
+    if hasattr(out.dtype, "name"):
+        dtype_name = out.dtype.name
+    else:
+        dtype_name = str(out.dtype).split('.')[-1]
     backend = infer_backend(out)
     rtol = get_tolerance("svd", out.dtype) # Note: tolerance for gate and svd is equal
+    if info is not None:
+        algorithm = info['algorithm']
+    else:
+        algorithm = 'gesvd'
+    if algorithm == 'gesvdj':
+        if dtype_name in ['float64', 'complex128']:
+            rtol = 1e-8
+        if 'gesvdj_residual' not in info:
+            logging.warning("gesvdj_residual not recorded in info; verification may fail due to unknown runtime status")
+        else:
+            rtol = max(rtol, info['gesvdj_residual'])
+    elif algorithm == 'gesvdp':
+        if dtype_name in ['float64', 'complex128']:
+            rtol = 1e-8
+        if 'gesvdp_err_sigma' not in info:
+            logging.warning("gesvdp_err_sigma not recorded in info; verification may fail due to unknown runtime status")
+        elif info['gesvdp_err_sigma'] > 1e-4:
+            logging.warning(f"Large err sigma found for gesvdp: {info['gesvdp_err_sigma']}, skipping verification")
+            return True
+    elif algorithm == 'gesvdr':
+        if dtype_name in ['float64', 'complex128']:
+            rtol = 1e-4
+        
     is_equal = verify_close(reference, out, rtol, True, scale_factor=shared_extent, error_message="Contracted output is not close to the expected outcome")
 
     partition = split_options.get("partition", None)
@@ -549,7 +585,9 @@ def verify_split_SVD(
     if info is not None and info_ref is not None:
         for attr in ["full_extent", "reduced_extent"]:
             info_equal = info_equal and info[attr] == info_ref[attr]
-        info_equal = info_equal and (abs(info["discarded_weight"]-info_ref["discarded_weight"]) < rtol)
+        # For gesvdr, discarded weight is only computed when fix extent truncation is not enabled
+        if info['algorithm'] != 'gesvdr' or max_extent == max_mid_extent:
+            info_equal = info_equal and (abs(info["discarded_weight"]-info_ref["discarded_weight"]) < rtol)
     if not info_equal:
         info_details = "".join([f"{key}:({info.get(key)}, {info_ref.get(key)}); " for key in info.keys()])
         logging.error(f"SVD Info not matching the reference: {info_details}")
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/circuit_utils.py b/python/tests/cuquantum_tests/cutensornet_tests/circuit_utils.py
index b6a3f03..69f1fa1 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/circuit_utils.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/circuit_utils.py
@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+from collections import Counter
 import itertools
 from types import MappingProxyType
 
@@ -11,22 +12,29 @@
     cirq = None
 import cupy as cp
 import numpy as np
+import pytest
 try:
     import torch
+    if not torch.cuda.is_available():
+        raise ImportError
 except ImportError:
     torch = None
 try:
     import qiskit
 except ImportError:
     qiskit = None
-
+    
 from cuquantum import contract, CircuitToEinsum
+from cuquantum import cutensornet as cutn
+from cuquantum.cutensornet._internal import circuit_parser_utils_cirq, circuit_parser_utils_qiskit
 from cuquantum.cutensornet._internal.circuit_converter_utils import convert_mode_labels_to_expression
 from cuquantum.cutensornet._internal.circuit_converter_utils import EINSUM_SYMBOLS_BASE
 from cuquantum.cutensornet._internal.circuit_converter_utils import get_pauli_gates
 from cuquantum.cutensornet._internal.circuit_converter_utils import parse_gates_to_mode_labels_operands
 from cuquantum.cutensornet._internal.utils import infer_object_package
-from .test_utils import atol_mapper, rtol_mapper
+
+from .test_utils import atol_mapper, get_stream_for_backend, rtol_mapper
+from .test_cutensornet import manage_resource
 
 
 # note: this implementation would cause pytorch tests being silently skipped
@@ -60,16 +68,17 @@ def bitstring_generator(n_qubits, nsample=1):
 def where_fixed_generator(qubits, nfix_max, nsite_max=None):
     indices = np.arange(len(qubits))
     for nfix in range(nfix_max):
-        np.random.shuffle(indices)
-        fixed_sites = [qubits[indices[ix]] for ix in range(nfix)]
-        bitstring = ''.join(np.random.choice(('0', '1'), nfix))
-        fixed = dict(zip(fixed_sites, bitstring))
-        if nsite_max is None:
-            yield fixed
-        else:
-            for nsite in range(1, nsite_max):
-                where = [qubits[indices[ix]] for ix in range(nfix, nfix+nsite)]
-                yield where, fixed
+        for _ in range(2):
+            np.random.shuffle(indices)
+            fixed_sites = [qubits[indices[ix]] for ix in range(nfix)]
+            bitstring = ''.join(np.random.choice(('0', '1'), nfix))
+            fixed = dict(zip(fixed_sites, bitstring))
+            if nsite_max is None:
+                yield fixed
+            else:
+                for nsite in range(1, nsite_max+1):
+                    where = [qubits[indices[ix]] for ix in range(nfix, nfix+nsite)]
+                    yield where, fixed
 
 
 def random_pauli_string_generator(n_qubits, num_strings=4):
@@ -117,6 +126,19 @@ def get_cirq_random_circuit(n_qubits, n_moments, op_density=0.9, seed=3):
         for n_moments in N_MOMENTS_RANGE:
             cirq_circuits.append(get_cirq_random_circuit(n_qubits, n_moments))
 
+try:
+    from cuquantum_benchmarks.frontends.frontend_cirq import Cirq as cuqnt_cirq
+    from cuquantum_benchmarks.benchmarks import qpe, quantum_volume, qaoa
+    cirq_generators = [qpe.QPE, quantum_volume.QuantumVolume, qaoa.QAOA]
+    config = {'measure': True, 'unfold': True, 'p': 4}
+    for generator in cirq_generators:
+        for n_qubits in (5, 6):
+            seq = generator.generateGatesSequence(n_qubits, config)
+            circuit = cuqnt_cirq(n_qubits, config).generateCircuit(seq)
+            cirq_circuits.append(circuit)
+except:
+    pass
+
 
 #########################################################
 # functions to generate qiskit.QuantumCircuit for testing
@@ -167,14 +189,78 @@ def get_qiskit_nested_circuit():
     return circ
 
 
+def get_cc_unitary_gate(seed=None):
+    # random unitary two qubit gate
+    from qiskit.extensions import UnitaryGate
+    if seed is None:
+        seed = 1234
+    rng = np.random.default_rng(seed)
+    m = rng.standard_normal(size=(4, 4)) + 1j*rng.standard_normal(size=(4, 4))
+    q, r = np.linalg.qr(m)
+    d = np.diag(r)
+    q *= d/abs(d)
+    gate = UnitaryGate(q).control(2)
+    return gate
+
+
+def get_qiskit_multi_control_circuit():
+    qubits = qiskit.QuantumRegister(5)
+    circuit = qiskit.QuantumCircuit(qubits)
+    for q in qubits:
+        circuit.h(q)
+    qs = list(qubits)
+    # 3 layers of multi-controlled qubits
+    np.random.seed(0)
+    for i in range(2):
+        np.random.shuffle(qs)
+        ccu_gate = get_cc_unitary_gate(i)
+        circuit.append(ccu_gate, qs[:4])
+        for q in qubits:
+            if i % 2 == 1:
+                circuit.h(q)
+            else:
+                circuit.x(q)
+    circuit.global_phase = 0.5
+    circuit.p(0.1, qubits[0])
+    return circuit
+
+
 if qiskit:
-    qiskit_circuits.append(get_qiskit_composite_circuit())
+    circuit = get_qiskit_composite_circuit()
+    qiskit_circuits.append(circuit.copy())
+    circuit.global_phase = 0.5
+    qiskit_circuits.append(circuit)
     qiskit_circuits.append(get_qiskit_nested_circuit())
+    qiskit_circuits.append(get_qiskit_multi_control_circuit())
     for n_qubits in N_QUBITS_RANGE:
         qiskit_circuits.append(get_qiskit_qft_circuit(n_qubits))
         for depth in DEPTH_RANGE:
             qiskit_circuits.append(get_qiskit_random_circuit(n_qubits, depth))
 
+try:
+    from cuquantum_benchmarks.frontends.frontend_qiskit import Qiskit as cuqnt_qiskit
+    from cuquantum_benchmarks.benchmarks import qpe, quantum_volume, qaoa
+    qiskit_generators = [qpe.QPE, quantum_volume.QuantumVolume, qaoa.QAOA]
+    config = {'measure': True, 'unfold': True, 'p': 4}
+    for generator in qiskit_generators:
+        for n_qubits in (5, 6):
+            seq = generator.generateGatesSequence(n_qubits, config)
+            circuit = cuqnt_qiskit(n_qubits, config).generateCircuit(seq)
+            qiskit_circuits.append(circuit)
+except:
+    pass
+
+
+def compute_histogram_overlap(hist1, hist2, nshots):
+    # assuming hist1 & hist2 have the same sample size (=nshots)
+    overlap = 0
+    for val, count in hist1.items():
+        if val not in hist2:
+            continue
+        overlap += min(hist1[val], hist2[val])
+    overlap /= nshots
+    return overlap
+
 
 ###################################################################
 #
@@ -187,17 +273,21 @@ def get_qiskit_nested_circuit():
 ###################################################################
 
 class BaseTester:
-    def __init__(self, circuit, dtype, backend, nsample, nsite_max, nfix_max):
+    def __init__(self, circuit, dtype, backend, nsample, nsite_max, nfix_max, nshots=5000, seed=1024):
         self.circuit = circuit
         self.converter = CircuitToEinsum(circuit, dtype=dtype, backend=backend)
         self.backend = backend
-        self.qubits = self.converter.qubits
+        self.qubits = list(self.converter.qubits)
         self.n_qubits = self.converter.n_qubits
         self.dtype = dtype
         self.sv = None
         self.nsample = nsample
         self.nsite_max = max(1, min(nsite_max, self.n_qubits-1))
         self.nfix_max = max(min(nfix_max, self.n_qubits-nsite_max-1), 0)
+        self.nshots = nshots
+        self.seed = seed
+        self.state_purity = cutn.StatePurity.PURE
+        self.state_prepared = False
         
     def get_state_vector_from_simulator(self):
         if self.sv is None:
@@ -268,20 +358,173 @@ def get_expectation_from_sv(self, pauli_string):
 
     def _get_state_vector_from_simulator(self):
         raise NotImplementedError
+
+    def _get_sampling_from_simulator(self, qubits_to_sample=None, seed=None):
+        raise NotImplementedError
+    
+    def get_sampling_from_sv(self, qubits_to_sample=None, seed=None):
+        sv = self.get_state_vector_from_simulator()
+        p = abs(sv) ** 2
+        # convert p to double type in case probs does not add up to 1
+        if self.backend is np:
+            p = p.astype('float64')
+        elif self.backend is cp:
+            p = cp.asnumpy(p).astype('float64')
+        elif self.backend is torch:
+            if p.device.type == 'cpu':
+                p = p.numpy().astype('float64')
+            else:
+                p = p.cpu().numpy().astype('float64')
+        if qubits_to_sample is not None:
+            sorted_qubits_to_sample = [q for q in self.qubits if q in qubits_to_sample]
+            axis = [i for (i, q) in enumerate(self.qubits) if q not in qubits_to_sample]
+            if axis:
+                p = p.sum(tuple(axis))
+                # potential transpose to match the order of qubits_to_sample
+                transpose_order = [sorted_qubits_to_sample.index(q) for q in qubits_to_sample]
+                p = p.transpose(*transpose_order)
+        # normalize
+        p /= p.sum()
+        if seed is not None:
+            np.random.seed(seed)
+        samples = np.random.choice(np.arange(p.size), p=p.flat, size=self.nshots)
+        hist_sv = np.unique(samples, return_counts=True)
+        return dict(zip(*hist_sv))
+    
+    def maybe_prepare_state(self):
+        if not self.state_prepared:
+            if not hasattr(self, 'state'):
+                raise RuntimeError("state not initialized")
+            if self.backend is not cp:
+                raise RuntimeError("This func is only expected to be executed for cupy backend")
+            gates = self.converter.gates
+            immutable = 0
+            adjoint = 0
+            unitary = 1 # assuming all gates unitary
+            self.operands = []
+            for (operand, qubits) in gates:
+                n_state_modes = len(qubits)
+                state_modes = [self.qubits.index(q) for q in qubits]
+                # keep operand alive otherwise cupy will re-use the memory space
+                operand = operand.T.astype(operand.dtype, order=np.random.choice(['C', 'F']))
+                self.operands.append(operand)
+                tensor_mode_strides = [stride_in_bytes//operand.itemsize for stride_in_bytes in operand.strides]
+                update_tensor = np.random.choice([True, False], p=[0.1, 0.9])
+                if update_tensor:
+                    tmp = cp.empty_like(operand)
+                    tensor_id = cutn.state_apply_tensor(self.handle, self.state, n_state_modes, 
+                        state_modes, tmp.data.ptr, tensor_mode_strides, 
+                        immutable, adjoint, unitary)
+                    cutn.state_update_tensor(self.handle, self.state, tensor_id, operand.data.ptr, unitary)
+                else:
+                    cutn.state_apply_tensor(self.handle, self.state, n_state_modes, 
+                        state_modes, operand.data.ptr, tensor_mode_strides, 
+                        immutable, adjoint, unitary)
+            self.state_prepared = True
+
+    def _run_cutensornet_sampling_marginal(self, task, create_args, execute_args, stream):
+        self.maybe_prepare_state()
+        if task == 'marginal':
+            create_func = cutn.create_marginal
+            configure_func = cutn.marginal_configure
+            hyper_sample_attr = cutn.MarginalAttribute.OPT_NUM_HYPER_SAMPLES
+            num_hyper_samples_dtype = cutn.marginal_get_attribute_dtype(hyper_sample_attr)
+            prepare_func = cutn.marginal_prepare
+            execute_func = cutn.marginal_compute
+            destroy_func = cutn.destroy_marginal
+        elif task == 'sampler':
+            create_func = cutn.create_sampler
+            configure_func = cutn.sampler_configure
+            hyper_sample_attr = cutn.SamplerAttribute.OPT_NUM_HYPER_SAMPLES
+            num_hyper_samples_dtype = cutn.sampler_get_attribute_dtype(hyper_sample_attr)
+            prepare_func = cutn.sampler_prepare
+            execute_func = cutn.sampler_sample
+            destroy_func = cutn.destroy_sampler
+        else:
+            raise ValueError("only supports marginal and sampler")
+        
+        dev = cp.cuda.Device()
+        free_mem = dev.mem_info[0]
+        scratch_size = free_mem // 2 # maximal usage of 50% device memory
+
+        task_obj = create_func(self.handle, self.state, *create_args)
+        num_hyper_samples = np.asarray(8, dtype=num_hyper_samples_dtype)
+        configure_func(self.handle, task_obj, hyper_sample_attr, 
+            num_hyper_samples.ctypes.data, num_hyper_samples.dtype.itemsize)
+        prepare_func(self.handle, task_obj, scratch_size, self.workspace, stream.ptr) # similar args for marginal and sampler
+        workspace_size_d = cutn.workspace_get_memory_size(self.handle, 
+                        self.workspace, cutn.WorksizePref.RECOMMENDED, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH)
+
+        if workspace_size_d >= scratch_size:
+            destroy_func(task_obj)
+            return None
+
+        scratch_space = cp.cuda.alloc(workspace_size_d)
+        cutn.workspace_set_memory(self.handle, 
+            self.workspace, cutn.Memspace.DEVICE, 
+            cutn.WorkspaceKind.SCRATCH, scratch_space.ptr, workspace_size_d)
+        
+        execute_func(self.handle, task_obj, *execute_args, stream.ptr)
+        stream.synchronize()
+        destroy_func(task_obj)
+        return True
+    
+    def get_reduced_density_matrix_from_cutn(self, where, fixed=EMPTY_DICT):
+        n_marginal_modes = len(where)
+        marginal_modes = [self.qubits.index(q) for q in where]
+        if fixed:
+            n_projected_modes = len(fixed)
+            projected_modes = []
+            projected_mode_values = []
+            for q, bit in fixed.items():
+                projected_modes.append(self.qubits.index(q))
+                projected_mode_values.append(int(bit))
+        else:
+            n_projected_modes = projected_modes = projected_mode_values = 0
+        
+        rdm = cp.empty((2,2)*n_marginal_modes, dtype=self.dtype, order=np.random.choice(['C', 'F']))
+        rdm_strides = [s // rdm.itemsize for s in rdm.strides]
+        stream = cp.cuda.get_current_stream()
+
+        create_args = (n_marginal_modes, marginal_modes, n_projected_modes, projected_modes, rdm_strides)
+        execute_args = (projected_mode_values, self.workspace, rdm.data.ptr)
+        if self._run_cutensornet_sampling_marginal('marginal', create_args, execute_args, stream):
+            return rdm
+        else:
+            return None
+ 
+    def get_sampling_from_cutensornet(self, qubits_to_sample=None, seed=None):
+        if qubits_to_sample is None:
+            qubits_to_sample = self.qubits
+        n_modes_to_sample = len(qubits_to_sample)
+        modes_to_sample = [self.qubits.index(q) for q in qubits_to_sample]
+        samples = np.empty((self.nshots, n_modes_to_sample), dtype='int64', order='C') # equivalent to (n_modes, nshots) in F order
+        stream = cp.cuda.get_current_stream()
+
+        create_args = (n_modes_to_sample, modes_to_sample)
+        execute_args = (self.nshots, self.workspace, samples.ctypes.data)
+        if self._run_cutensornet_sampling_marginal('sampler', create_args, execute_args, stream):
+            sampling = {}
+            for bitstring, n_sampling in zip(*np.unique(samples, axis=0, return_counts=True)):
+                bitstring = np.array2string(bitstring, separator='')[1:-1]
+                sampling[int(bitstring, 2)] = n_sampling
+            return sampling
+        else:
+            return None
     
     def test_qubits(self):
-        assert len(self.qubits) == self.num_qubits
+        assert len(self.qubits) == self.n_qubits
     
     def test_gates(self):
         for (gate_operand, qubits) in self.converter.gates:
             assert gate_operand.ndim == len(qubits) * 2
-            assert infer_object_package(gate_operand) is self.backend
+            assert infer_object_package(gate_operand) == self.backend.__name__
     
     def test_state_vector(self):
         expression, operands = self.converter.state_vector()
         sv1 = contract(expression, *operands)
         sv2 = self.get_state_vector_from_simulator()
-        self.backend.allclose(
+        assert self.backend.allclose(
             sv1, sv2, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
     
     def test_amplitude(self):
@@ -289,7 +532,7 @@ def test_amplitude(self):
             expression, operands = self.converter.amplitude(bitstring)
             amp1 = contract(expression, *operands)
             amp2 = self.get_amplitude_from_simulator(bitstring)
-            self.backend.allclose(
+            assert self.backend.allclose(
                 amp1, amp2, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
     
     def test_batched_amplitudes(self):
@@ -297,72 +540,151 @@ def test_batched_amplitudes(self):
             expression, operands = self.converter.batched_amplitudes(fixed)
             batched_amps1 = contract(expression, *operands)
             batched_amps2 = self.get_batched_amplitudes_from_simulator(fixed)
-            self.backend.allclose(
+            assert self.backend.allclose(
                 batched_amps1, batched_amps2, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
     
     def test_reduced_density_matrix(self):
         for where, fixed in where_fixed_generator(self.qubits, self.nfix_max, nsite_max=self.nsite_max):
             expression1, operands1 = self.converter.reduced_density_matrix(where, fixed=fixed, lightcone=True)
             expression2, operands2 = self.converter.reduced_density_matrix(where, fixed=fixed, lightcone=False)
-            assert len(operands1) <= len(operands2)            
+            assert len(operands1) <= len(operands2) + 2 # potential phase handling for qiskit Circuit            
             rdm1 = contract(expression1, *operands1)
             rdm2 = contract(expression2, *operands2)
             rdm3 = self.get_reduced_density_matrix_from_simulator(where, fixed=fixed)
 
-            self.backend.allclose(
+            assert self.backend.allclose(
                 rdm1, rdm2, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
-            self.backend.allclose(
+            assert self.backend.allclose(
                 rdm1, rdm3, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
+            
+            if self.backend is cp:
+                rdm4 = self.get_reduced_density_matrix_from_cutn(where, fixed=fixed)
+                if rdm4 is not None:
+                    assert self.backend.allclose(
+                        rdm1, rdm4, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
     
     def test_expectation(self):
         for pauli_string in random_pauli_string_generator(self.n_qubits, 2):
             expression1, operands1 = self.converter.expectation(pauli_string, lightcone=True)
             expression2, operands2 = self.converter.expectation(pauli_string, lightcone=False)
-            assert len(operands1) <= len(operands2)
+            assert len(operands1) <= len(operands2) + 2 # potential phase handling for qiskit Circuit
             expec1 = contract(expression1, *operands1)
             expec2 = contract(expression2, *operands2)
             expec3 = self.get_expectation_from_sv(pauli_string)
 
-            self.backend.allclose(
+            assert self.backend.allclose(
                 expec1, expec2, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
-            self.backend.allclose(
+            assert self.backend.allclose(
                 expec1, expec3, atol=atol_mapper[self.dtype], rtol=rtol_mapper[self.dtype])
+    
+    def test_sampling(self):
+        full_qubits = list(self.qubits)
+        np.random.shuffle(full_qubits)
+        selected_qubits = full_qubits[:len(full_qubits)//2]
+
+        for qubits_to_sample in (None, selected_qubits):
+            seed = self.seed
+            nshots = self.nshots
+            max_try = 3
+            overlap_best = 0.
+
+            for counter in range(1, max_try+1):
+                # build a histogram for the reference impl
+                hist_ref = self._get_sampling_from_simulator(qubits_to_sample=qubits_to_sample, seed=seed)
+
+                # do the same for cutensornet sampling
+                hist_cutn = self.get_sampling_from_cutensornet(qubits_to_sample=qubits_to_sample, seed=seed)
+
+                # compute overlap of the histograms (cutn vs ref)
+                overlap = compute_histogram_overlap(hist_cutn, hist_ref, self.nshots)
+                if overlap > overlap_best:
+                    overlap_best = overlap
+                else:
+                    print("WARNING: overlap not improving as nshots increases!")
+
+                # do the same for sampling from the (exactly computed) SV
+                hist_sv = self.get_sampling_from_sv(qubits_to_sample=qubits_to_sample, seed=seed)
+
+                # compute overlap of the histograms (sv vs ref)
+                overlap_check = compute_histogram_overlap(hist_sv, hist_ref, self.nshots)
+                print(f"with nshots = {self.nshots}, {overlap_best = }, {overlap_check = }")
+
+                # to reduce test time we set 95% here, but 99% will also work
+                if np.round(overlap, decimals=2) < 0.95:
+                    self.nshots *= 10
+                    print(f"retry with nshots = {self.nshots} ...")
+                else:
+                    self.nshots = nshots  # restore
+                    break
+            else:
+                self.nshots = nshots  # restore
+                assert False, f"{overlap_best=} after {counter} retries..."
 
+    @manage_resource("handle")
+    @manage_resource("state")
+    @manage_resource("workspace")
     def run_tests(self):
         self.test_state_vector()
         self.test_amplitude()
         self.test_batched_amplitudes()
         self.test_reduced_density_matrix()
         self.test_expectation()
+        self.test_gates()
+        self.test_qubits()
+        if self.backend is cp:
+            # sampling only needed to be tested for cupy backend
+            self.test_sampling()
 
 
 class CirqTester(BaseTester):
     def _get_state_vector_from_simulator(self):
         qubits = self.qubits
         simulator = cirq.Simulator(dtype=self.dtype)
-        result = simulator.simulate(self.circuit, qubit_order=qubits)
+        circuit = circuit_parser_utils_cirq.remove_measurements(self.circuit)
+        result = simulator.simulate(circuit, qubit_order=qubits)
         statevector = result.state_vector().reshape((2,)*self.n_qubits)
         if self.backend is torch:
             statevector = torch.as_tensor(statevector, dtype=getattr(torch, self.dtype), device='cuda')
         else:
             statevector = self.backend.asarray(statevector, dtype=self.dtype)
         return statevector
+    
+    def _get_sampling_from_simulator(self, qubits_to_sample=None, seed=None):
+        if qubits_to_sample is None:
+            qubits_to_sample = list(self.qubits)
+        circuit = circuit_parser_utils_cirq.remove_measurements(self.circuit)
+        circuit.append(cirq.measure_each(qubits_to_sample))
+        circuit.append(cirq.measure(*qubits_to_sample, key='meas'))
+        result = cirq.sample(
+            circuit, repetitions=self.nshots, seed=seed, dtype=getattr(np, self.dtype))
+        result = result.histogram(key='meas')
+        sampling = {}
+        nsamples = 0
+        for bitstring, nsample in result.items():
+            sampling[int(bitstring)] = nsample
+            nsamples += nsample
+        assert nsamples == self.nshots
+        return sampling
 
 
 class QiskitTester(BaseTester):    
-    def _get_state_vector_from_simulator(self):
-        # requires qiskit >= 0.24.0
+    def _get_precision(self):
         precision = {'complex64': 'single',
                      'complex128': 'double'}[self.dtype]
+        return precision
+    
+    def _get_state_vector_from_simulator(self):
+        # requires qiskit >= 0.24.0
+        precision = self._get_precision()
+        circuit = circuit_parser_utils_qiskit.remove_measurements(self.circuit)
         try:
             # for qiskit >= 0.25.0
             simulator = qiskit.Aer.get_backend('aer_simulator_statevector', precision=precision)
-            circuit = qiskit.transpile(self.circuit, simulator)
+            circuit = qiskit.transpile(circuit, simulator)
             circuit.save_statevector()
             result = simulator.run(circuit).result()
         except:
             # for qiskit 0.24.*
-            circuit = self.circuit
             simulator = qiskit.Aer.get_backend('statevector_simulator', precision=precision)
             result = qiskit.execute(circuit, simulator).result()
         sv = np.asarray(result.get_statevector()).reshape((2,)*circuit.num_qubits)
@@ -374,3 +696,24 @@ def _get_state_vector_from_simulator(self):
         else:
             sv = self.backend.asarray(sv, dtype=self.dtype)
         return sv
+    
+    def _get_sampling_from_simulator(self, qubits_to_sample=None, seed=None):
+        if qubits_to_sample is None:
+            qubits_to_sample = list(self.qubits)
+        circuit = self.circuit.remove_final_measurements(inplace=False)
+        new_creg = circuit._create_creg(len(qubits_to_sample), "meas")
+        circuit.add_register(new_creg)
+        circuit.measure(qubits_to_sample, new_creg)
+        precision = self._get_precision()
+        backend = qiskit.Aer.get_backend('qasm_simulator', precision=precision)
+        result = backend.run(qiskit.transpile(circuit, backend), shots=self.nshots, seed=seed).result()
+        counts  = result.get_counts(circuit)
+        sampling = {}
+        nsamples = 0
+        for bitstring, nsample in counts.items():
+            # little endian from qiskit
+            value = int(bitstring[::-1], 2)
+            sampling[value] = nsample
+            nsamples += nsample
+        assert nsamples == self.nshots
+        return sampling
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/data.py b/python/tests/cuquantum_tests/cutensornet_tests/data.py
index 7cab507..2ecee3c 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/data.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/data.py
@@ -54,7 +54,7 @@
     ["a,b,c->abc", {}, {}, "float64"],
     ["acdf,jbje,gihb,hfac", {}, {}, "float64"],
     ["acdf,jbje,gihb,hfac,gfac,gifabc,hfac", {}, {}, "float64"],
-    ["chd,bde,agbc,hiad,bdi,cgh,agdb", {}, {}, "float64"],
+    ["chd,bde,agbc,hiad,bdi,cgh,agdb", {"blocking": "auto"}, {}, "float64"],
     ["eb,cb,fb->cef", {}, {}, "float64"],
     ["dd,fb,be,cdb->cef", {}, {}, "float64"],
     ["bca,cdb,dbf,afc->", {}, {}, "float64"],
@@ -62,8 +62,9 @@
     ["a,ac,ab,ad,cd,bd,bc->", {}, {}, "float64"],
 )
 
+
 # the expression here should be
-#   - a list [decomposition_expression, input_tensor_shapes as a list of tuple]
+#   - a sequence of [decomposition_expression, input_tensor_shapes as a list of tuple]
 tensor_decomp_expressions = (
     ('ab->ax,xb', [(8, 8)]),
     ('ab->ax,bx', [(8, 8)]),
@@ -79,19 +80,21 @@
     ('ab->xa,bx', [(8, 6)]),
     ('abcd->cxa,bdx', [(2, 3, 4, 5)]),
     ('abcd->cax,bdx', [(2, 3, 4, 5)]),
-    ('mnijk->jny,kmyi', [(2, 9, 3, 3, 4)])
+    ('mnijk->jny,kmyi', [(2, 9, 3, 3, 4)]),
 )
 
+
 # the expression here should be
-#   - a list [gate_decomposition_expression, input_tensor_shapes as a list of tuple]
+#   - a sequence of [gate_decomposition_expression, input_tensor_shapes as a list of tuple]
 gate_decomp_expressions = (
-    ('ijk,klm,jlpq->ipk,kqm', [(4, 2, 4), (4, 2, 4), (2, 2, 2, 2)]),
-    ('ijk,klm,jlpq->kpi,qmk', [(4, 2, 4), (4, 2, 4), (2, 2, 2, 2)]),
-    ('ijk,klm,jlpq->pki,mkq', [(4, 2, 4), (4, 2, 4), (2, 2, 2, 2)]),
+    ('ijk,klm,jlpq->ipk,kqm', [(2, 2, 2), (2, 2, 2), (2, 2, 2, 2)]),
+    ('ijk,klm,jlpq->kpi,qmk', [(2, 2, 2), (2, 2, 2), (2, 2, 2, 2)]),
+    ('ijk,klm,jlpq->pki,mkq', [(2, 2, 2), (2, 2, 2), (2, 2, 2, 2)]),
     ('sOD,DdNr,ROrsq->KR,qKdN', [(2, 4, 2), (2, 3, 4, 2), (5, 4, 2, 2, 2)]),
     ('beQ,cey,cbJj->Je,jQey', [(3, 5, 4), (2, 5, 7), (2, 3, 4, 4)])
 )
 
+
 # the expression here can be
 #   - a string as a standard contract and decompose expression
 #   - a list of [contract decompose expression, network options, optimize options, kwargs]
@@ -101,7 +104,7 @@
     'ijk,klm,jlpq->ipk,kqm',
     'abcd,cdef->axb,fex',
     'abcd,cdef->axf,bex',
-    'sOD,DdNr,ROrsq->KR,qKdN',
+    ['sOD,DdNr,ROrsq->KR,qKdN', {'blocking': 'auto'}, {}, {}],
     'beQ,cey,cbJj->Je,jQey',
     'ijlm,jqr,lqsn->imx,xrsn',
     ['ijk,klm,jlpq->ipk,kqm', {}, {}, {'return_info': False}],
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_cutensornet.py b/python/tests/cuquantum_tests/cutensornet_tests/test_cutensornet.py
index 8e39f8b..b2e4291 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_cutensornet.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_cutensornet.py
@@ -6,15 +6,21 @@
 import functools
 import os
 
-import cupy
+import cupy as cp
 from cupy import testing
-import numpy
+import numpy as np
 try:
     import mpi4py
     from mpi4py import MPI  # init!
 except ImportError:
     mpi4py = MPI = None
 import pytest
+try:
+    import torch
+    # unlike in other test modules, we don't check torch.cuda.is_available()
+    # here because we allow verifying against PyTorch CPU tensors
+except:
+    torch = None
 
 import cuquantum
 from cuquantum import ComputeType, cudaDataType
@@ -25,7 +31,7 @@
 
 from . import approxTN_utils
 from .data import gate_decomp_expressions, tensor_decomp_expressions
-from .test_utils import atol_mapper, rtol_mapper
+from .test_utils import atol_mapper, get_stream_for_backend, rtol_mapper
 from .. import (_can_use_cffi, dtype_to_compute_type, dtype_to_data_type,
                 MemHandlerTestBase, MemoryResourceFactory, LoggerTestBase)
 
@@ -43,18 +49,21 @@ def manage_resource(name):
     def decorator(impl):
         @functools.wraps(impl)
         def test_func(self, *args, **kwargs):
+            # "self" refers to the test case
             try:
                 if name == 'handle':
                     h = cutn.create()
                 elif name == 'dscr':
-                    tn, dtype, input_form, output_form = self.tn, self.dtype, self.input_form, self.output_form
+                    tn, dtype, input_form = self.tn, self.dtype, self.input_form
                     einsum, shapes = tn  # unpack
-                    tn = TensorNetworkFactory(einsum, shapes, dtype)
+                    tn = TensorNetworkFactory(einsum, shapes, dtype, order=self.order)
                     i_n_inputs, i_n_modes, i_extents, i_strides, i_modes = \
                         tn.get_input_metadata(**input_form)
                     o_n_modes, o_extents, o_strides, o_modes = \
-                        tn.get_output_metadata(**output_form)
-                    i_qualifiers = numpy.zeros(i_n_inputs, dtype=cutn.tensor_qualifiers_dtype)
+                        tn.get_output_metadata(**input_form)
+                    i_qualifiers = np.zeros(i_n_inputs, dtype=cutn.tensor_qualifiers_dtype)
+                    if self.qual is not None:
+                        i_qualifiers['requires_gradient'][:] = True
                     h = cutn.create_network_descriptor(
                         self.handle,
                         i_n_inputs, i_n_modes, i_extents, i_strides, i_modes, i_qualifiers, 
@@ -94,6 +103,9 @@ def test_func(self, *args, **kwargs):
                     # we use this version to avoid creating a sequence; another API
                     # is tested elsewhere
                     h = cutn.create_slice_group_from_id_range(self.handle, 0, 1, 1)
+                elif name == 'state':
+                    dtype = dtype_to_data_type[getattr(np, self.dtype)]
+                    h = cutn.create_state(self.handle, self.state_purity, self.n_qubits, (2,)*self.n_qubits, dtype)
                 else:
                     assert False, f'name "{name}" not recognized'
                 setattr(self, name, h)
@@ -133,6 +145,8 @@ def test_func(self, *args, **kwargs):
                 elif name == 'slice_group':
                     h = cutn.destroy_slice_group(self.slice_group)
                     del self.slice_group
+                elif name == 'state':
+                    h = cutn.destroy_state(self.state)
         return test_func
     return decorator
 
@@ -168,7 +182,7 @@ class TensorNetworkFactory:
     # This factory CANNOT be reused; once a TN descriptor uses it, it must
     # be discarded.
 
-    def __init__(self, einsum, shapes, dtype):
+    def __init__(self, einsum, shapes, dtype, *, order='C'):
         self.einsum = einsum
         inputs, output = einsum.split('->') if "->" in einsum else (einsum, None)
         i_shapes, o_shape = shapes[:-1], shapes[-1]
@@ -177,30 +191,34 @@ def __init__(self, einsum, shapes, dtype):
         assert len(output) == len(o_shape)
 
         # xp strides in bytes, cutn strides in counts
-        itemsize = cupy.dtype(dtype).itemsize
+        itemsize = cp.dtype(dtype).itemsize
 
         self.input_tensors = [
-            testing.shaped_random(s, cupy, dtype) for s in i_shapes]
+            testing.shaped_random(s, cp, dtype, seed=i, order=order)
+            for i, s in enumerate(i_shapes)]
         self.input_n_modes = [len(i) for i in inputs]
         self.input_extents = i_shapes
-        self.input_strides = [[stride // itemsize for stride in arr.strides] for arr in self.input_tensors]
+        self.input_strides = [[stride // itemsize for stride in arr.strides]
+                              for arr in self.input_tensors]
         self.input_modes = [tuple([ord(m) for m in i]) for i in inputs]
 
-        self.output_tensor = cupy.empty(o_shape, dtype=dtype)
+        self.output_tensor = cp.empty(o_shape, dtype=dtype, order=order)
         self.output_n_modes = len(o_shape)
         self.output_extent = o_shape
         self.output_stride = [stride // itemsize for stride in self.output_tensor.strides]
         self.output_mode = tuple([ord(m) for m in output])
 
+        self.gradients = None
+
     def _get_data_type(self, category):
         if 'n_modes' in category:
-            return numpy.int32
+            return np.int32
         elif 'extent' in category:
-            return numpy.int64
+            return np.int64
         elif 'stride' in category:
-            return numpy.int64
+            return np.int64
         elif 'mode' in category:
-            return numpy.int32
+            return np.int32
         elif 'tensor' in category:
             return None  # unused
         else:
@@ -213,38 +231,38 @@ def _return_data(self, category, return_value):
             if len(data) == 0:
                 # empty, give it a NULL
                 return 0
-            elif category == 'input_tensors':
+            elif category in ('input_tensors', 'gradients'):
                 # special case for device arrays, return int as void**
-                data = numpy.asarray([d.data.ptr for d in data],
-                    dtype=numpy.intp)
+                data = np.asarray([d.data.ptr for d in data],
+                    dtype=np.intp)
                 setattr(self, f'{category}_ptrs', data)  # keep data alive
             # some data are not nested in nature, so we peek at the first
             # element to determine
             elif isinstance(data[0], abc.Sequence):
                 # return int as void**
-                data = [numpy.asarray(d, dtype=self._get_data_type(category))
+                data = [np.asarray(d, dtype=self._get_data_type(category))
                     for d in data]
                 setattr(self, category, data)  # keep data alive
-                data = numpy.asarray([d.ctypes.data for d in data],
-                    dtype=numpy.intp)
+                data = np.asarray([d.ctypes.data for d in data],
+                    dtype=np.intp)
                 setattr(self, f'{category}_ptrs', data)  # keep data alive
             else:
                 # return int as void*
-                data = numpy.asarray(data, dtype=self._get_data_type(category))
+                data = np.asarray(data, dtype=self._get_data_type(category))
                 setattr(self, category, data)  # keep data alive
             return data.ctypes.data
         elif return_value == 'seq':
             if len(data) == 0:
                 # empty, leave it as is
                 pass
-            elif category == 'input_tensors':
+            elif category in ('input_tensors', 'gradients'):
                 # special case for device arrays
                 data = [d.data.ptr for d in data]
                 setattr(self, f'{category}_ptrs', data)  # keep data alive
             # some data are not nested in nature, so we peek at the first
             # element to determine
             elif isinstance(data[0], abc.Sequence):
-                data = [numpy.asarray(d, dtype=self._get_data_type(category))
+                data = [np.asarray(d, dtype=self._get_data_type(category))
                     for d in data]
                 setattr(self, category, data)  # keep data alive
             else:
@@ -278,6 +296,14 @@ def get_input_tensors(self, **kwargs):
     def get_output_tensor(self):
         return self.output_tensor.data.ptr
 
+    def get_gradient_tensors(self, **kwargs):
+        if self.gradients is None:
+            # as of 23.06, the gradient tensors' strides follow those of the
+            # input tensors
+            self.gradients = [cp.empty_like(arr) for arr in self.input_tensors]
+        data = self._return_data('gradients', kwargs['data'])
+        return data
+
 
 @testing.parameterize(*testing.product({
     'tn': (
@@ -287,8 +313,9 @@ def get_output_tensor(self):
         ('ab,bc,cd->ad', [(2, 3), (3, 1), (1, 5), (2, 5)]),
     ),
     'dtype': (
-        numpy.float32, numpy.float64, numpy.complex64, numpy.complex128
+        np.float32, np.float64, np.complex64, np.complex128
     ),
+    # use the same format for both input/output tensors
     'input_form': (
         {'n_modes': 'int', 'extent': 'int', 'stride': 'int',
          'mode': 'int', 'data': 'int'},
@@ -297,10 +324,9 @@ def get_output_tensor(self):
         {'n_modes': 'seq', 'extent': 'nested_seq', 'stride': 'nested_seq',
          'mode': 'seq', 'data': 'seq'},
     ),
-    'output_form': (
-        {'extent': 'int', 'stride': 'int', 'mode': 'int'},
-        {'extent': 'seq', 'stride': 'seq', 'mode': 'seq'},
-    )
+    'order': ('C', 'F'),
+    # mainly for gradient tests
+    'qual': (None, True),
 }))
 class TestTensorNetworkBase:
 
@@ -330,9 +356,9 @@ def test_descriptor_create_destroy(self, API):
                 handle, tensor_dscr)
 
         assert num_modes == self.tn.output_n_modes
-        assert (modes == numpy.asarray(self.tn.output_mode, dtype=numpy.int32)).all()
-        assert (extents == numpy.asarray(self.tn.output_extent, dtype=numpy.int64)).all()
-        assert (strides == numpy.asarray(self.tn.output_stride, dtype=numpy.int64)).all()
+        assert (modes == np.asarray(self.tn.output_mode, dtype=np.int32)).all()
+        assert (extents == np.asarray(self.tn.output_extent, dtype=np.int64)).all()
+        assert (strides == np.asarray(self.tn.output_stride, dtype=np.int64)).all()
 
         if API == 'new':
             cutn.destroy_tensor_descriptor(tensor_dscr)
@@ -346,14 +372,14 @@ def _get_path(self, handle, info):
     def _set_path(self, handle, info, path):
         attr = cutn.ContractionOptimizerInfoAttribute.PATH
         dtype = cutn.contraction_optimizer_info_get_attribute_dtype(attr)
-        if not isinstance(path, numpy.ndarray):
-            path = numpy.ascontiguousarray(path, dtype=numpy.int32)
-        path_obj = numpy.asarray((path.shape[0], path.ctypes.data), dtype=dtype)
+        if not isinstance(path, np.ndarray):
+            path = np.ascontiguousarray(path, dtype=np.int32)
+        path_obj = np.asarray((path.shape[0], path.ctypes.data), dtype=dtype)
         self._set_scalar_attr(handle, info, attr, path_obj)
 
     def _get_scalar_attr(self, handle, info, attr):
         dtype = cutn.contraction_optimizer_info_get_attribute_dtype(attr)
-        data = numpy.empty((1,), dtype=dtype)
+        data = np.empty((1,), dtype=dtype)
         cutn.contraction_optimizer_info_get_attribute(
             handle, info, attr,
             data.ctypes.data, data.dtype.itemsize)
@@ -361,8 +387,8 @@ def _get_scalar_attr(self, handle, info, attr):
 
     def _set_scalar_attr(self, handle, info, attr, data):
         dtype = cutn.contraction_optimizer_info_get_attribute_dtype(attr)
-        if not isinstance(data, numpy.ndarray):
-            data = numpy.ascontiguousarray(data, dtype=dtype)
+        if not isinstance(data, np.ndarray):
+            data = np.ascontiguousarray(data, dtype=dtype)
         cutn.contraction_optimizer_info_set_attribute(
             handle, info, attr,
             data.ctypes.data, data.dtype.itemsize)
@@ -421,9 +447,9 @@ def test_optimizer_info_packing_unpacking(self, buffer_form):
         dtype = cutn.contraction_optimizer_info_get_attribute_dtype(attr)
 
         # compute a valid path for the problem
-        path, _ = numpy.einsum_path(
+        path, _ = np.einsum_path(
             tn.einsum,
-            *[arr for arr in map(lambda a: numpy.broadcast_to(0, a.shape),
+            *[arr for arr in map(lambda a: np.broadcast_to(0, a.shape),
                                  tn.input_tensors)])
 
         # set the path in info (a few other attributes would be computed too)
@@ -431,7 +457,7 @@ def test_optimizer_info_packing_unpacking(self, buffer_form):
         self._set_path(handle, info, path[1:])
         buf_size = cutn.contraction_optimizer_info_get_packed_size(
             handle, info)
-        buf_data = numpy.empty((buf_size,), dtype=numpy.int8)
+        buf_data = np.empty((buf_size,), dtype=np.int8)
         if buffer_form == "int":
             buf = buf_data.ctypes.data
         else:  # buffer_form == "buf"
@@ -481,15 +507,16 @@ def test_optimizer_config_get_set_attribute(self, attr):
                     cutn.ContractionOptimizerConfigAttribute.SLICER_MEMORY_MODEL,
                     cutn.ContractionOptimizerConfigAttribute.SLICER_DISABLE_SLICING,
                     cutn.ContractionOptimizerConfigAttribute.SIMPLIFICATION_DISABLE_DR,
-                    cutn.ContractionOptimizerConfigAttribute.COST_FUNCTION_OBJECTIVE):
-            factor = numpy.asarray([1], dtype=dtype)
+                    cutn.ContractionOptimizerConfigAttribute.COST_FUNCTION_OBJECTIVE,
+                    cutn.ContractionOptimizerConfigAttribute.SMART_OPTION):
+            factor = np.asarray([1], dtype=dtype)
         else:
-            factor = numpy.asarray([30], dtype=dtype)
+            factor = np.asarray([30], dtype=dtype)
         cutn.contraction_optimizer_config_set_attribute(
             handle, config, attr,
             factor.ctypes.data, factor.dtype.itemsize)
         # do a round-trip test as a sanity check
-        factor2 = numpy.zeros_like(factor)
+        factor2 = np.zeros_like(factor)
         cutn.contraction_optimizer_config_get_attribute(
             handle, config, attr,
             factor2.ctypes.data, factor2.dtype.itemsize)
@@ -513,12 +540,12 @@ def test_autotune_preference_get_set_attribute(self, attr):
         handle, pref = self.handle, self.autotune
         dtype = cutn.contraction_autotune_preference_get_attribute_dtype(attr)
         # Hack: assume this is a valid value for all attrs
-        factor = numpy.asarray([2], dtype=dtype)
+        factor = np.asarray([2], dtype=dtype)
         cutn.contraction_autotune_preference_set_attribute(
             handle, pref, attr,
             factor.ctypes.data, factor.dtype.itemsize)
         # do a round-trip test as a sanity check
-        factor2 = numpy.zeros_like(factor)
+        factor2 = np.zeros_like(factor)
         cutn.contraction_autotune_preference_get_attribute(
             handle, pref, attr,
             factor2.ctypes.data, factor2.dtype.itemsize)
@@ -535,10 +562,10 @@ def test_autotune_preference_get_set_attribute(self, attr):
     'autotune', (True, False)
 )
 @pytest.mark.parametrize(
-    'contract', (False, "legacy", "slice_group")
+    'contract', ("legacy", "slice_group", "gradient")
 )
 @pytest.mark.parametrize(
-    'stream', (cupy.cuda.Stream.null, cupy.cuda.Stream(non_blocking=True))
+    'stream', (cp.cuda.Stream.null, get_stream_for_backend(cp))
 )
 class TestContraction(TestTensorNetworkBase):
 
@@ -551,7 +578,7 @@ class TestContraction(TestTensorNetworkBase):
     @manage_resource('autotune')
     @manage_resource('workspace')
     @manage_resource('slice_group')
-    def test_contraction_workflow(
+    def test_contraction_gradient_workflow(
             self, mempool, workspace_pref, autotune, contract, stream):
         if (isinstance(mempool, str) and mempool.startswith('cffi')
                 and not _can_use_cffi()):
@@ -560,54 +587,87 @@ def test_contraction_workflow(
         # unpack
         handle, dscr, info, config, pref = self.handle, self.dscr, self.info, self.config, self.autotune
         workspace = self.workspace
-        tn, input_form, output_form = self.tn, self.input_form, self.output_form
+        tn, input_form = self.tn, self.input_form
+
+        # make sure inputs are ready
+        # TODO: use stream_wait_event to establish stream order is better
+        cp.cuda.Device().synchronize()
 
         if mempool:
             mr = MemoryResourceFactory(mempool)
             handler = mr.get_dev_mem_handler()
             cutn.set_device_mem_handler(handle, handler)
 
-        workspace_size = 32*1024**2  # large enough for our test cases
+        workspace_hint = 32*1024**2  # large enough for our test cases
         # we have to run this API in any case in order to create a path
         cutn.contraction_optimize(
-            handle, dscr, config, workspace_size, info)
+            handle, dscr, config, workspace_hint, info)
+
+        # for simplicity, compute grads for all tensors
+        if contract == "gradient":
+            if self.qual is None:
+                # set up the grad flag via TN attributes instead of input qualifiers
+                tensor_id_range = np.arange(len(tn.input_tensors), dtype=np.int32)
+                net_attr_dtype = cutn.network_get_attribute_dtype(
+                    cutn.NetworkAttribute.INPUT_TENSORS_REQUIRE_GRAD)
+                tensor_ids = np.zeros(1, dtype=net_attr_dtype)
+                tensor_ids['num_tensors'] = tensor_id_range.size
+                tensor_ids['data'] = tensor_id_range.ctypes.data
+                cutn.network_set_attribute(
+                    handle, dscr, cutn.NetworkAttribute.INPUT_TENSORS_REQUIRE_GRAD,
+                    tensor_ids.ctypes.data, tensor_ids.dtype.itemsize)
+                # round-trip
+                tensor_id_range_back = np.zeros_like(tensor_id_range)
+                tensor_ids['num_tensors'] = tensor_id_range_back.size
+                tensor_ids['data'] = tensor_id_range_back.ctypes.data
+                cutn.network_get_attribute(
+                    handle, dscr, cutn.NetworkAttribute.INPUT_TENSORS_REQUIRE_GRAD,
+                    tensor_ids.ctypes.data, tensor_ids.dtype.itemsize)
+                assert (tensor_id_range_back == tensor_id_range).all()
+
+            output_grads = cp.ones_like(tn.output_tensor)
 
         # manage workspace
+        placeholder = []
         if mempool is None:
-            cutn.workspace_compute_sizes(handle, dscr, info, workspace)
-            required_size_deprecated = cutn.workspace_get_memory_size(
-                handle, workspace,
-                getattr(cutn.WorksizePref, f"{workspace_pref.upper()}"),
-                cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
-                cutn.WorkspaceKind.SCRATCH)
             cutn.workspace_compute_contraction_sizes(handle, dscr, info, workspace)
-            required_size = cutn.workspace_get_memory_size(
-                handle, workspace,
-                getattr(cutn.WorksizePref, f"{workspace_pref.upper()}"),
-                cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
-                cutn.WorkspaceKind.SCRATCH)
-            assert required_size == required_size_deprecated
-            if workspace_size < required_size:
-                assert False, \
-                    f"wrong assumption on the workspace size " \
-                    f"(given: {workspace_size}, needed: {required_size})"
-            workspace_ptr = cupy.cuda.alloc(workspace_size)
-            cutn.workspace_set_memory(
-                handle, workspace,
-                cutn.Memspace.DEVICE,
-                cutn.WorkspaceKind.SCRATCH,
-                workspace_ptr.ptr, workspace_size)
-            # round-trip check
-            assert (workspace_ptr.ptr, workspace_size) == cutn.workspace_get_memory(
-                handle, workspace,
-                cutn.Memspace.DEVICE,
-                cutn.WorkspaceKind.SCRATCH)
+            for kind in cutn.WorkspaceKind:  # for both scratch & cache
+                required_size = cutn.workspace_get_memory_size(
+                    handle, workspace,
+                    getattr(cutn.WorksizePref, f"{workspace_pref.upper()}"),
+                    cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
+                    kind)
+                if contract != "gradient":
+                    cutn.workspace_compute_sizes(handle, dscr, info, workspace)
+                    required_size_deprecated = cutn.workspace_get_memory_size(
+                        handle, workspace,
+                        getattr(cutn.WorksizePref, f"{workspace_pref.upper()}"),
+                        cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
+                        kind)
+                    assert required_size == required_size_deprecated
+                if workspace_hint < required_size:
+                    assert False, \
+                        f"wrong assumption on the workspace size " \
+                        f"(given: {workspace_hint}, needed: {required_size})"
+                if required_size > 0:
+                    workspace_ptr = cp.cuda.alloc(required_size)
+                    cutn.workspace_set_memory(
+                        handle, workspace,
+                        cutn.Memspace.DEVICE,
+                        kind,
+                        workspace_ptr.ptr, required_size)
+                    placeholder.append(workspace_ptr)  # keep it alive
+                    # round-trip check
+                    assert ((workspace_ptr.ptr, required_size) ==
+                        cutn.workspace_get_memory(handle, workspace,
+                                                  cutn.Memspace.DEVICE, kind))
         else:
-            cutn.workspace_set_memory(
-                handle, workspace,
-                cutn.Memspace.DEVICE,
-                cutn.WorkspaceKind.SCRATCH,
-                0, -1)  # TODO: check custom workspace size?
+            for kind in cutn.WorkspaceKind:
+                cutn.workspace_set_memory(
+                    handle, workspace,
+                    cutn.Memspace.DEVICE,
+                    kind,
+                    0, -1)  # TODO: check custom workspace size?
 
         plan = None
         try:
@@ -628,7 +688,7 @@ def test_contraction_workflow(
                     tn.get_input_tensors(**input_form),
                     tn.get_output_tensor(),
                     workspace, 0, stream.ptr)
-            elif contract == "slice_group":
+            elif contract in ("slice_group", "gradient"):
                 accumulate = 0
                 cutn.contract_slices(
                     handle, plan,
@@ -636,11 +696,49 @@ def test_contraction_workflow(
                     tn.get_output_tensor(),
                     accumulate,
                     workspace, self.slice_group, stream.ptr)
+                if contract == "gradient":
+                    cutn.compute_gradients_backward(
+                        handle, plan,
+                        tn.get_input_tensors(**input_form),
+                        output_grads.data.ptr,
+                        tn.get_gradient_tensors(**input_form),
+                        accumulate, workspace, stream.ptr)
             stream.synchronize()
         finally:
             if plan is not None:
                 cutn.destroy_contraction_plan(plan)
 
+        if contract == "gradient" and torch:
+
+            if not torch.cuda.is_available():
+                # copy data back to CPU
+                dev = "cpu"
+                func = cp.asnumpy
+            else:
+                # zero-copy from CuPy to PyTorch!
+                dev = "cuda"
+                func = (lambda x: x)  # no op
+
+            inputs = [torch.as_tensor(func(t), device=dev)
+                      for t in tn.input_tensors]
+            output_grads = torch.as_tensor(func(output_grads), device=dev)
+            for t in inputs:
+                t.requires_grad_(True)
+                assert t.grad is None
+
+            # repeat the same calculation with PyTorch so that it fills up the
+            # gradients for us to do verification
+            out = torch.einsum(tn.einsum, *inputs)
+            out.backward(output_grads)
+
+            # compare gradients
+            for grad_cutn, in_torch in zip(tn.gradients, inputs):
+                grad_torch = in_torch.grad
+                if torch.is_complex(grad_torch):
+                    grad_torch = grad_torch.conj().resolve_conj()
+                # zero-copy if on GPU
+                assert cp.allclose(grad_cutn, cp.asarray(grad_torch))
+
 
 @pytest.mark.parametrize(
     'source', ('int', 'seq', 'range')
@@ -652,11 +750,11 @@ def test_slice_group(self, source):
         # we don't do a simple round-trip test here because there are two
         # flavors of constructors
         if source == "int":
-            ids = numpy.arange(10, dtype=numpy.int64)
+            ids = np.arange(10, dtype=np.int64)
             slice_group = cutn.create_slice_group_from_ids(
                 self.handle, ids.ctypes.data, ids.size)
         elif source == "seq":
-            ids = numpy.arange(10, dtype=numpy.int64)
+            ids = np.arange(10, dtype=np.int64)
             slice_group = cutn.create_slice_group_from_ids(
                 self.handle, ids, ids.size)
         elif source == "range":
@@ -716,7 +814,7 @@ def __init__(self, subscript, shapes, dtype, max_extent=None):
         self.tensor_names = [f"input_{i}" for i in range(len(shapes))] + ["left", "right"] # note s needs to be explictly managed in the tester function
     
         # xp strides in bytes, cutn strides in counts
-        dtype = cupy.dtype(dtype)
+        dtype = cp.dtype(dtype)
         real_dtype = dtype.char.lower()
         is_complex = dtype.char != real_dtype
         itemsize = dtype.itemsize
@@ -725,13 +823,13 @@ def _get_tensor(name, modes):
             if name.startswith('input'):
                 shape = [size_dict[mode] for mode in modes]
                 if is_complex:  # complex
-                    arr = (cupy.random.random(shape, dtype=real_dtype)
-                           + 1j*cupy.random.random(shape, dtype=real_dtype)).astype(dtype)
+                    arr = (cp.random.random(shape, dtype=real_dtype)
+                           + 1j*cp.random.random(shape, dtype=real_dtype)).astype(dtype)
                 else:
-                    arr = cupy.random.random(shape, dtype=dtype)
+                    arr = cp.random.random(shape, dtype=dtype)
             else:
                 shape = [self.mid_extent if mode == shared_mode_out else size_dict[mode] for mode in modes]
-                arr = cupy.empty(shape, dtype=dtype, order='F')
+                arr = cp.empty(shape, dtype=dtype, order='F')
             return arr
 
         for name, modes in zip(self.tensor_names, modes_in + [left_modes_out, right_modes_out]):
@@ -744,13 +842,13 @@ def _get_tensor(name, modes):
 
     def _get_data_type(self, category):
         if 'n_modes' in category:
-            return numpy.int32
+            return np.int32
         elif 'extent' in category:
-            return numpy.int64
+            return np.int64
         elif 'stride' in category:
-            return numpy.int64
+            return np.int64
         elif 'mode' in category:
-            return numpy.int32
+            return np.int32
         elif 'tensor' in category:
             return None  # unused
         else:
@@ -765,7 +863,7 @@ def _return_data(self, category, return_value):
                 return 0
             else:
                 # return int as void*
-                data = numpy.asarray(data, dtype=self._get_data_type(category))
+                data = np.asarray(data, dtype=self._get_data_type(category))
                 setattr(self, category, data)  # keep data alive
             return data.ctypes.data
         elif return_value == 'seq':
@@ -797,7 +895,7 @@ def get_operands(self, include_inputs=True, include_outputs=True):
 @testing.parameterize(*testing.product({
     'tn': tensor_decomp_expressions,
     'dtype': (
-        numpy.float32, numpy.float64, numpy.complex64, numpy.complex128
+        np.float32, np.float64, np.complex64, np.complex128
     ),
     'tensor_form': (
         {'extent': 'int', 'stride': 'int', 'mode': 'int'},
@@ -816,7 +914,7 @@ def test_tensor_qr(self):
         handle, tn, workspace = self.handle, self.tn, self.workspace
         
         tensor_in, tensor_q, tensor_r = self.tensor_decom
-        dtype = cupy.dtype(self.dtype)
+        dtype = cp.dtype(self.dtype)
 
         # prepare workspace
         cutn.workspace_compute_qr_sizes(
@@ -828,7 +926,7 @@ def test_tensor_qr(self):
             cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
             cutn.WorkspaceKind.SCRATCH)
         if required_size > 0:
-            workspace_ptr = cupy.cuda.alloc(required_size)
+            workspace_ptr = cp.cuda.alloc(required_size)
             cutn.workspace_set_memory(
                 handle, workspace, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH,
                 workspace_ptr.ptr, required_size)
@@ -837,7 +935,7 @@ def test_tensor_qr(self):
                 handle, workspace, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH)
 
         # perform QR
-        stream = cupy.cuda.get_current_stream().ptr  # TODO
+        stream = cp.cuda.get_current_stream().ptr  # TODO
         cutn.tensor_qr(
             handle, tensor_in, tn.get_tensor_ptr('input_0'),
             tensor_q, tn.get_tensor_ptr('left'),
@@ -852,7 +950,7 @@ def test_tensor_qr(self):
 @testing.parameterize(*testing.product({
     'tn': tensor_decomp_expressions,
     'dtype': (
-        numpy.float32, numpy.float64, numpy.complex64, numpy.complex128
+        np.float32, np.float64, np.complex64, np.complex128
     ),
     'tensor_form': (
         {'extent': 'int', 'stride': 'int', 'mode': 'int'},
@@ -860,11 +958,11 @@ def test_tensor_qr(self):
     ),
     'options': (
         {}, # standard exact svd
-        {'max_extent': 4, 'normalization':'L1', 'partition':'U'}, # fix extent truncation
-        {'abs_cutoff': 0.1, 'rel_cutoff': 0.1}, # value based truncation
-        {'abs_cutoff': 0.1, 'normalization':'L2', 'partition':'V'}, # absolute value based truncation
-        {'rel_cutoff': 0.1, 'normalization':'LInf', 'partition':'UV'}, # relative value based truncation
-        {'max_extent': 4, 'abs_cutoff': 0.1, 'rel_cutoff': 0.1, 'normalization':'L1', 'partition':'UV'}, # compound truncation
+        {'max_extent': 4, 'normalization':'L1', 'partition':'U', 'algorithm': 'gesvdr', 'gesvdr_niters': 40}, # fix extent truncation
+        {'abs_cutoff': 0.1, 'rel_cutoff': 0.1, 'algorithm': 'gesvdj', 'gesvdj_tol':1e-14, 'gesvdj_max_sweeps': 80}, # value based truncation
+        {'abs_cutoff': 0.1, 'normalization':'L2', 'partition':'V', 'algorithm': 'gesvdj'}, # absolute value based truncation
+        {'rel_cutoff': 0.1, 'normalization':'LInf', 'partition':'UV', 'algorithm': 'gesvdp'}, # relative value based truncation
+        {'max_extent': 4, 'abs_cutoff': 0.1, 'rel_cutoff': 0.1, 'normalization':'L1', 'partition':'UV', 'algorithm': 'gesvdp'}, # compound truncation
     ),
 }))
 class TestTensorSVD:
@@ -881,7 +979,7 @@ def test_tensor_svd(self):
         handle, tn, workspace = self.handle, self.tn, self.workspace
         tensor_in, tensor_u, tensor_v = self.tensor_decom
         svd_config, svd_info = self.svd_config, self.svd_info
-        dtype = cupy.dtype(self.dtype)
+        dtype = cp.dtype(self.dtype)
 
         # parse svdConfig
         svd_method = check_or_create_options(tensor.SVDMethod, self.options, "SVDMethod")
@@ -892,29 +990,37 @@ def test_tensor_svd(self):
             handle, tensor_in, tensor_u, tensor_v, svd_config, workspace)
         # for now host workspace is always 0, so just query device one
         # also, it doesn't matter which one (min/recommended/max) is queried
-        required_size = cutn.workspace_get_memory_size(
-            handle, workspace, cutn.WorksizePref.MIN,
-            cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
-            cutn.WorkspaceKind.SCRATCH)
-        if required_size > 0:
-            workspace_ptr = cupy.cuda.alloc(required_size)
-            cutn.workspace_set_memory(
-                handle, workspace, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH,
-                workspace_ptr.ptr, required_size)
-            # round-trip check
-            assert (workspace_ptr.ptr, required_size) == cutn.workspace_get_memory(
-                handle, workspace, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH)
+        workspaces = {}
+        allocators = {cutn.Memspace.DEVICE: cp.cuda.alloc,
+                      cutn.Memspace.HOST: lambda nbytes: np.empty(nbytes, dtype=np.int8)}
+        for mem_space, allocator in allocators.items():
+            required_size = cutn.workspace_get_memory_size(
+                handle, workspace, cutn.WorksizePref.MIN,
+                mem_space,  
+                cutn.WorkspaceKind.SCRATCH)
+            if required_size > 0:
+                workspaces[mem_space] = workspace_ptr = allocator(required_size) # keep alive
+                if mem_space == cutn.Memspace.DEVICE:
+                    workspace_ptr_address = workspace_ptr.ptr
+                else:
+                    workspace_ptr_address = workspace_ptr.ctypes.data
+                cutn.workspace_set_memory(
+                    handle, workspace, mem_space, cutn.WorkspaceKind.SCRATCH,
+                    workspace_ptr_address, required_size)
+                # round-trip check
+                assert (workspace_ptr_address, required_size) == cutn.workspace_get_memory(
+                    handle, workspace, mem_space, cutn.WorkspaceKind.SCRATCH)
         
         partition = self.options.get("partition", None)
         if partition is None:
-            s = cupy.empty(tn.mid_extent, dtype=dtype.char.lower())
+            s = cp.empty(tn.mid_extent, dtype=dtype.char.lower())
             s_ptr = s.data.ptr
         else:
             s = None
             s_ptr = 0
         
         # perform SVD
-        stream = cupy.cuda.get_current_stream().ptr  # TODO
+        stream = cp.cuda.get_current_stream().ptr  # TODO
         cutn.tensor_svd(
             handle, tensor_in, tn.get_tensor_ptr('input_0'),
             tensor_u, tn.get_tensor_ptr('left'),
@@ -936,10 +1042,10 @@ def test_tensor_svd(self):
         if tuple(extent_U_out) != u.shape:
             strides_U_out = [i * u.itemsize for i in strides_U_out]
             strides_V_out = [i * v.itemsize for i in strides_V_out]
-            tn.left_tensor = u = cupy.ndarray(extent_U_out, dtype=u.dtype, memptr=u.data, strides=strides_U_out)
+            tn.left_tensor = u = cp.ndarray(extent_U_out, dtype=u.dtype, memptr=u.data, strides=strides_U_out)
             if s is not None:
-                s = cupy.ndarray(reduced_extent, dtype=s.dtype, memptr=s.data, order='F')
-            tn.right_tensor = v = cupy.ndarray(extent_V_out, dtype=v.dtype, memptr=v.data, strides=strides_V_out)
+                s = cp.ndarray(reduced_extent, dtype=s.dtype, memptr=s.data, order='F')
+            tn.right_tensor = v = cp.ndarray(extent_V_out, dtype=v.dtype, memptr=v.data, strides=strides_V_out)
         
         u_ref, s_ref, v_ref, info_ref = approxTN_utils.tensor_decompose(
             tn.subscript, T, 
@@ -957,7 +1063,7 @@ def test_tensor_svd(self):
 @testing.parameterize(*testing.product({
     'tn': gate_decomp_expressions,
     'dtype': (
-        numpy.float32, numpy.float64, numpy.complex64, numpy.complex128
+        np.float32, np.float64, np.complex64, np.complex128
     ),
     'tensor_form': (
         {'extent': 'int', 'stride': 'int', 'mode': 'int'},
@@ -967,18 +1073,18 @@ def test_tensor_svd(self):
         "direct", "reduced"
     ),
     'options': (
-        {}, # exact svd
-        {'max_extent': 4, 'normalization':'L1', 'partition':'U'}, # fix extent truncation
-        {'abs_cutoff': 0.1, 'rel_cutoff': 0.1}, # value based truncation
-        {'abs_cutoff': 0.1, 'normalization':'L2', 'partition':'V'}, # absolute value based truncation
-        {'rel_cutoff': 0.1, 'normalization':'LInf', 'partition':'UV'}, # relative value based truncation
-        {'max_extent': 4, 'abs_cutoff': 0.1, 'rel_cutoff': 0.1, 'normalization':'L1', 'partition':'UV'}, # compound truncation
+        {}, # standard exact svd
+        {'max_extent': 4, 'normalization':'L1', 'partition':'U', 'algorithm': 'gesvdr', 'gesvdr_niters': 40}, # fix extent truncation
+        {'abs_cutoff': 0.1, 'rel_cutoff': 0.1, 'algorithm': 'gesvdj', 'gesvdj_tol':1e-14, 'gesvdj_max_sweeps': 80}, # value based truncation
+        {'abs_cutoff': 0.1, 'normalization':'L2', 'partition':'V', 'algorithm': 'gesvdj'}, # absolute value based truncation
+        {'rel_cutoff': 0.1, 'normalization':'LInf', 'partition':'UV', 'algorithm': 'gesvdp'}, # relative value based truncation
+        {'max_extent': 4, 'abs_cutoff': 0.1, 'rel_cutoff': 0.1, 'normalization':'L1', 'partition':'UV', 'algorithm': 'gesvdp'}, # compound truncation
     ),
 }))
 class TestTensorGate:
     
     GATE_ALGO_MAP = {"direct": cutn.GateSplitAlgo.DIRECT,
-                    "reduced": cutn.GateSplitAlgo.REDUCED}
+                     "reduced": cutn.GateSplitAlgo.REDUCED}
     
     # There is no easy way for us to test each API independently, so we instead
     # parametrize the steps and test the whole workflow
@@ -999,37 +1105,43 @@ def test_gate_split(self):
         svd_method = check_or_create_options(tensor.SVDMethod, self.options, "SVDMethod")
         parse_svd_config(handle, svd_config, svd_method, logger=None)
 
-        dtype = cupy.dtype(self.dtype)
+        dtype = cp.dtype(self.dtype)
         compute_type = dtype_to_compute_type[self.dtype]
         # prepare workspace
         cutn.workspace_compute_gate_split_sizes(handle, 
             tensor_in_a, tensor_in_b, tensor_in_g, tensor_u, tensor_v, 
             gate_algorithm, svd_config, compute_type, workspace)
-        # for now host workspace is always 0, so just query device one
-        # also, it doesn't matter which one (min/recommended/max) is queried
-        required_size = cutn.workspace_get_memory_size(
-            handle, workspace, cutn.WorksizePref.MIN,
-            cutn.Memspace.DEVICE,  # TODO: parametrize memspace?
-            cutn.WorkspaceKind.SCRATCH)
-        if required_size > 0:
-            workspace_ptr = cupy.cuda.alloc(required_size)
-            cutn.workspace_set_memory(
-                handle, workspace, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH,
-                workspace_ptr.ptr, required_size)
-            # round-trip check
-            assert (workspace_ptr.ptr, required_size) == cutn.workspace_get_memory(
-                handle, workspace, cutn.Memspace.DEVICE, cutn.WorkspaceKind.SCRATCH)
+        workspaces = {}
+        allocators = {cutn.Memspace.DEVICE: cp.cuda.alloc,
+                      cutn.Memspace.HOST: lambda nbytes: np.empty(nbytes, dtype=np.int8)}
+        for mem_space, allocator in allocators.items():
+            required_size = cutn.workspace_get_memory_size(
+                handle, workspace, cutn.WorksizePref.MIN,
+                mem_space,  
+                cutn.WorkspaceKind.SCRATCH)
+            if required_size > 0:
+                workspaces[mem_space] = workspace_ptr = allocator(required_size) # keep alive
+                if mem_space == cutn.Memspace.DEVICE:
+                    workspace_ptr_address = workspace_ptr.ptr
+                else:
+                    workspace_ptr_address = workspace_ptr.ctypes.data
+                cutn.workspace_set_memory(
+                    handle, workspace, mem_space, cutn.WorkspaceKind.SCRATCH,
+                    workspace_ptr_address, required_size)
+                # round-trip check
+                assert (workspace_ptr_address, required_size) == cutn.workspace_get_memory(
+                    handle, workspace, mem_space, cutn.WorkspaceKind.SCRATCH)
 
         partition = self.options.get("partition", None)
         if partition is None:
-            s = cupy.empty(tn.mid_extent, dtype=dtype.char.lower())
+            s = cp.empty(tn.mid_extent, dtype=dtype.char.lower())
             s_ptr = s.data.ptr
         else:
             s = None
             s_ptr = 0
         
         # perform gate split
-        stream = cupy.cuda.get_current_stream().ptr  # TODO
+        stream = cp.cuda.get_current_stream().ptr  # TODO
         cutn.gate_split(handle, tensor_in_a, tn.get_tensor_ptr('input_0'),
             tensor_in_b, tn.get_tensor_ptr('input_1'),
             tensor_in_g, tn.get_tensor_ptr('input_2'),
@@ -1052,10 +1164,10 @@ def test_gate_split(self):
         if tuple(extent_U_out) != u.shape:
             strides_U_out = [i * u.itemsize for i in strides_U_out]
             strides_V_out = [i * v.itemsize for i in strides_V_out]
-            tn.left_tensor = u = cupy.ndarray(extent_U_out, dtype=u.dtype, memptr=u.data, strides=strides_U_out)
+            tn.left_tensor = u = cp.ndarray(extent_U_out, dtype=u.dtype, memptr=u.data, strides=strides_U_out)
             if s is not None:
-                s = cupy.ndarray(reduced_extent, dtype=s.dtype, memptr=s.data, order='F')
-            tn.right_tensor = v = cupy.ndarray(extent_V_out, dtype=v.dtype, memptr=v.data, strides=strides_V_out)
+                s = cp.ndarray(reduced_extent, dtype=s.dtype, memptr=s.data, order='F')
+            tn.right_tensor = v = cp.ndarray(extent_V_out, dtype=v.dtype, memptr=v.data, strides=strides_V_out)
         
         u_ref, s_ref, v_ref, info_ref = approxTN_utils.gate_decompose(
             tn.subscript, 
@@ -1083,7 +1195,7 @@ def test_tensor_svd_config_create_destroy(self):
         pass
 
     @pytest.mark.parametrize(
-        'attr', [val for val in cutn.TensorSVDConfigAttribute]
+        'attr', [val for val in cutn.TensorSVDConfigAttribute if val != cutn.TensorSVDConfigAttribute.ALGO_PARAMS]
     )
     @manage_resource('handle')
     @manage_resource('svd_config')
@@ -1091,16 +1203,43 @@ def test_tensor_svd_config_get_set_attribute(self, attr):
         handle, svd_config = self.handle, self.svd_config
         dtype = cutn.tensor_svd_config_get_attribute_dtype(attr)
         # Hack: assume this is a valid value for all attrs
-        factor = numpy.asarray([0.8], dtype=dtype)
+        factor = np.asarray([0.8], dtype=dtype)
         cutn.tensor_svd_config_set_attribute(
             handle, svd_config, attr,
             factor.ctypes.data, factor.dtype.itemsize)
         # do a round-trip test as a sanity check
-        factor2 = numpy.zeros_like(factor)
+        factor2 = np.zeros_like(factor)
         cutn.tensor_svd_config_get_attribute(
             handle, svd_config, attr,
             factor2.ctypes.data, factor2.dtype.itemsize)
         assert factor == factor2
+    
+    @pytest.mark.parametrize(
+        'svd_algorithm', (cutn.TensorSVDAlgo.GESVDJ, cutn.TensorSVDAlgo.GESVDR)
+    )
+    @manage_resource('handle')
+    @manage_resource('svd_config')
+    def test_tensor_svd_config_get_set_params_attribute(self, svd_algorithm):
+        handle, svd_config = self.handle, self.svd_config
+        # set ALGO first
+        algo_dtype = cutn.tensor_svd_config_get_attribute_dtype(cutn.TensorSVDConfigAttribute.ALGO)
+        algo = np.asarray(svd_algorithm, dtype=algo_dtype)
+        cutn.tensor_svd_config_set_attribute(
+            handle, svd_config, cutn.TensorSVDConfigAttribute.ALGO,
+            algo.ctypes.data, algo.dtype.itemsize)
+        
+        algo_params_dtype = cutn.tensor_svd_algo_params_get_dtype(svd_algorithm)
+        # Hack: assume this is a valid value for all SVD parameters
+        factor = np.asarray([1.8], dtype=algo_params_dtype) # 0 may trigger default behavior, eg, gesvdr_niters set to 0 means default (10)
+        cutn.tensor_svd_config_set_attribute(
+            handle, svd_config, cutn.TensorSVDConfigAttribute.ALGO_PARAMS,
+            factor.ctypes.data, factor.dtype.itemsize)
+        # do a round-trip test as a sanity check
+        factor2 = np.zeros_like(factor)
+        cutn.tensor_svd_config_get_attribute(
+            handle, svd_config, cutn.TensorSVDConfigAttribute.ALGO_PARAMS,
+            factor2.ctypes.data, factor2.dtype.itemsize)
+        assert factor == factor2
 
 
 @pytest.mark.skipif(mpi4py is None, reason="need mpi4py")
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_experimental.py b/python/tests/cuquantum_tests/cutensornet_tests/test_experimental.py
index cac42dc..d0da2ec 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_experimental.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_experimental.py
@@ -130,22 +130,20 @@ def test_contract_qr_decompose(self, decompose_expr, xp, dtype, order, stream):
         self._run_contract_decompose(decompose_expr, xp, dtype, order, stream, algorithm)
 
     
-    @pytest.mark.parametrize(
-        "svd_method_seed", (None, 0, 1, 2)
-    )
-    def test_contract_svd_decompose(self, decompose_expr, xp, dtype, order, stream, svd_method_seed):
-        svd_method = gen_rand_svd_method(seed=svd_method_seed)
-        algorithm = ContractDecomposeAlgorithm(qr_method=False, svd_method=svd_method)
-        self._run_contract_decompose(decompose_expr, xp, dtype, order, stream, algorithm)
+    def test_contract_svd_decompose(self, decompose_expr, xp, dtype, order, stream):
+        rng = numpy.random.default_rng(2021)
+        methods = [tensor.SVDMethod()] + [gen_rand_svd_method(rng) for _ in range(10)]
+        for svd_method in methods:
+            algorithm = ContractDecomposeAlgorithm(qr_method=False, svd_method=svd_method)
+            self._run_contract_decompose(decompose_expr, xp, dtype, order, stream, algorithm)
 
     
-    @pytest.mark.parametrize(
-        "svd_method_seed", (None, 0, 1, 2)
-    )
-    def test_contract_qr_assisted_svd_decompose(self, decompose_expr, xp, dtype, order, stream, svd_method_seed):
-        svd_method = gen_rand_svd_method(seed=svd_method_seed)
-        algorithm = ContractDecomposeAlgorithm(qr_method={}, svd_method=svd_method)
-        self._run_contract_decompose(decompose_expr, xp, dtype, order, stream, algorithm)
+    def test_contract_qr_assisted_svd_decompose(self, decompose_expr, xp, dtype, order, stream):
+        rng = numpy.random.default_rng(2021)
+        methods = [tensor.SVDMethod()] + [gen_rand_svd_method(rng) for _ in range(10)]
+        for svd_method in methods:
+            algorithm = ContractDecomposeAlgorithm(qr_method={}, svd_method=svd_method)
+            self._run_contract_decompose(decompose_expr, xp, dtype, order, stream, algorithm)
 
 
 class TestContractDecomposeAlgorithm(_OptionsBase):
@@ -178,7 +176,7 @@ class TestContractDecomposeInfo(_OptionsBase):
                                         intermediate_modes=[(1, 3), (2, 4)])]
     )
     @pytest.mark.parametrize(
-        'svd_info', [None, tensor.SVDInfo(reduced_extent=2, full_extent=4, discarded_weight=0.01)]
+        'svd_info', [None, tensor.SVDInfo(reduced_extent=2, full_extent=4, discarded_weight=0.01, algorithm='gesvdj')]
     )
     @pytest.mark.parametrize(
         'svd_method', [False, {}, tensor.SVDMethod()]
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py b/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py
index 4e97467..32885db 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py
@@ -1,10 +1,14 @@
+import re
+import sys
 import threading
 
 import cupy as cp
 from cupy.cuda.runtime import getDevice, setDevice
 import pytest
 
+from cuquantum.cutensornet import _internal
 from cuquantum.cutensornet._internal import utils
+from cuquantum.utils import WHITESPACE_UNICODE
 
 
 class TestDeviceCtx:
@@ -85,3 +89,22 @@ def test_one_shot(self):
         with pytest.raises(Exception):
             with dev:
                 pass
+
+
+class TestGetSymbol:
+
+    def test_no_whitespace(self):
+        # Note: max(whitespace_s) = 12288
+        out = []
+        for i in range(0, 30000):
+            s = _internal.circuit_converter_utils._get_symbol(i)
+            assert not s.isspace()
+            out.append(s)
+
+        # check the mapping is unique
+        assert len(set(out)) == 30000
+
+    def test_whitespace_unicode_consistency(self):
+        all_s = ''.join(chr(c) for c in range(sys.maxunicode+1))
+        whitespace_s = ''.join(re.findall(r'\s', all_s))
+        assert WHITESPACE_UNICODE == whitespace_s
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_options.py b/python/tests/cuquantum_tests/cutensornet_tests/test_options.py
index 9f4079f..a8ab520 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_options.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_options.py
@@ -104,7 +104,7 @@ class TestOptimizerInfo(_OptionsBase):
 
     options_type = OptimizerInfo
 
-    # All fileds in OptimizerInfo are required, so we must test
+    # All fields in OptimizerInfo are required, so we must test
     # them at once
     def test_optimizer_info(self):
         self.create_options({
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_tensor.py b/python/tests/cuquantum_tests/cutensornet_tests/test_tensor.py
index 2272fa8..502ebc6 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_tensor.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_tensor.py
@@ -2,10 +2,11 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
+import copy
+import dataclasses
 import sys
 
 import cupy
-import dataclasses
 import numpy
 import pytest
 
@@ -35,12 +36,17 @@
     "xp", backend_names
 )
 @pytest.mark.parametrize(
-    "decompose_expr", list(set([expr[0] for expr in tensor_decomp_expressions])) # filter out duplicated expressions
+    "decompose_expr", tensor_decomp_expressions
+)
+@pytest.mark.parametrize(
+    "blocking", (True, "auto")
 )
 class TestDecompose:
     
-    def _run_decompose(self, decompose_expr, xp, dtype, order, stream, method, **kwargs):
-        factory = DecomposeFactory(decompose_expr)
+    def _run_decompose(
+            self, decompose_expr, xp, dtype, order, stream, method, **kwargs):
+        decompose_expr, shapes = copy.deepcopy(decompose_expr)
+        factory = DecomposeFactory(decompose_expr, shapes=shapes)
         operand = factory.generate_operands(factory.input_shapes, xp, dtype, order)[0]
         backend = sys.modules[infer_object_package(operand)]
 
@@ -49,10 +55,11 @@ def _run_decompose(self, decompose_expr, xp, dtype, order, stream, method, **kwa
         
         return_info = kwargs.pop("return_info", False)        
         outputs = tensor.decompose(decompose_expr, 
-                                operand, 
-                                method=method, 
-                                return_info=return_info, 
-                                stream=stream)
+                                   operand, 
+                                   method=method,
+                                   options={"blocking": kwargs["blocking"]},
+                                   stream=stream,
+                                   return_info=return_info)
         if stream:
             stream.synchronize()
         
@@ -72,7 +79,7 @@ def _run_decompose(self, decompose_expr, xp, dtype, order, stream, method, **kwa
             else:
                 u, s, v = outputs
                 u_ref, s_ref, v_ref = outputs_ref
-                info = None
+                info = {'algorithm': method.algorithm}
                 info_ref = None
             
             assert type(u) is type(v)
@@ -90,18 +97,22 @@ def _run_decompose(self, decompose_expr, xp, dtype, order, stream, method, **kwa
                                     info_ref=info_ref,
                                     **svd_kwargs)
     
-    def test_qr(self, decompose_expr, xp, dtype, order, stream):
-        self._run_decompose(decompose_expr, xp, dtype, order, stream, tensor.QRMethod())
+    def test_qr(self, decompose_expr, xp, dtype, order, stream, blocking):
+        self._run_decompose(
+            decompose_expr, xp, dtype, order, stream, tensor.QRMethod(),
+            blocking=blocking)
     
-    @pytest.mark.parametrize(
-        "svd_method_seed", (None, 0, 1, 2)
-    )
     @pytest.mark.parametrize(
         "return_info", (False, True)
     )
-    def test_svd(self, decompose_expr, xp, dtype, order, stream, return_info, svd_method_seed):
-        method = gen_rand_svd_method(seed=svd_method_seed)
-        self._run_decompose(decompose_expr, xp, dtype, order, stream, method, return_info=return_info)
+    def test_svd(
+            self, decompose_expr, xp, dtype, order, stream, return_info, blocking):
+        rng = numpy.random.default_rng(2021)
+        methods = [tensor.SVDMethod()] + [gen_rand_svd_method(rng) for _ in range(10)]
+        for method in methods:
+            self._run_decompose(
+                decompose_expr, xp, dtype, order, stream, method,
+                blocking=blocking, return_info=return_info)
 
 
 class TestDecompositionOptions(TestNetworkOptions):
@@ -134,11 +145,33 @@ def test_partition(self, partition):
     def test_normalization(self, normalization):
         self.create_options({'normalization': normalization})
 
+    @pytest.mark.parametrize(
+        'algorithm', ['gesvd', 'gesvdj', 'gesvdp', 'gesvdr']
+    )
+    def test_algorithm(self, algorithm):
+        options = {'algorithm': algorithm}
+        if algorithm == 'gesvdj':
+            options['gesvdj_tol'] = 1e-16
+            options['gesvdj_max_sweeps'] = 80
+        elif algorithm == 'gesvdr':
+            options['gesvdr_oversampling'] = 4
+            options['gesvdr_niters'] = 8
+        self.create_options(options)
+
 
 class TestSVDInfo(_OptionsBase):
 
     options_type = tensor.SVDInfo
 
     # All fields are required. Therefore we test them all at once.
-    def test_svd_info(self):
-        self.create_options({'reduced_extent': 6, 'full_extent': 8, 'discarded_weight': 0.02})
+    @pytest.mark.parametrize(
+        'algorithm', ['gesvd', 'gesvdj', 'gesvdp', 'gesvdr']
+    )
+    def test_svd_info(self, algorithm):
+        info = {'reduced_extent': 6, 'full_extent': 8, 'discarded_weight': 0.02, 'algorithm': algorithm}
+        if algorithm == 'gesvdj':
+            info['gesvdj_sweeps'] = 12
+            info['gesvdj_residual'] = 1e-12
+        elif algorithm == 'gesvdp':
+            info['gesvdp_err_sigma'] = 1e-8
+        self.create_options(info)
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_utils.py b/python/tests/cuquantum_tests/cutensornet_tests/test_utils.py
index 9ee56b4..faaabcd 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_utils.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_utils.py
@@ -10,6 +10,8 @@
 import numpy
 try:
     import torch
+    if not torch.cuda.is_available():
+        raise ImportError
 except ImportError:
     torch = None
 
@@ -284,6 +286,15 @@ def convert_by_format(self, operands, *, dummy=False):
 
 class DecomposeFactory(ExpressionFactory):
 
+    def __init__(self, expression, *, shapes=None):
+        super().__init__(expression)
+
+        if shapes is not None:
+            # overwrite the base class's dict
+            inputs, _ = self.expr.split("->")
+            inputs = inputs.split(",")
+            self.size_dict = dict((m, e) for k, v in zip(inputs, shapes) for m, e in zip(k, v))
+
     @property
     def modes(self):
         if self._modes is None:
@@ -301,20 +312,23 @@ def modes(self):
                 raise ValueError("decomposition does not support interleave format")
             
         return self._modes
-    
-def gen_rand_svd_method(seed=None):
-    if seed is None:
-        return tensor.SVDMethod()
-    else:
-        numpy.random.seed(seed)
-        method = {"max_extent": numpy.random.randint(1, high=6), 
-                "abs_cutoff": numpy.random.random() / 2.0, # [0, 0.5)
-                "rel_cutoff": numpy.random.random() / 2.0, # [0, 0.5)
-                "normalization": numpy.random.choice([None, "L1", "L2", "LInf"]),
-                "partition": numpy.random.choice([None, "U", "V", "UV"])}
-        return tensor.SVDMethod(**method)
 
 
+def gen_rand_svd_method(rng):
+    method = {"max_extent": rng.choice(range(1, 7)), 
+              "abs_cutoff": rng.random() / 2.0,  # [0, 0.5)
+              "rel_cutoff": 0.1 + rng.random() / 2.5 ,  # [0.1, 0.5)
+              "normalization": rng.choice([None, "L1", "L2", "LInf"]),
+              "partition": rng.choice([None, "U", "V", "UV"]),
+              "algorithm": rng.choice(['gesvd', 'gesvdj', 'gesvdp', 'gesvdr'])}
+    if method["algorithm"] == 'gesvdj':
+        method["gesvdj_tol"] = rng.choice([0, 1e-14])
+        method["gesvdj_max_sweeps"] = rng.choice([0, 100])
+    elif method["algorithm"] == 'gesvdr':
+        method["gesvdr_niters"] = rng.choice([0, 40])
+        # we can't set oversampling as it depends on matrix size here
+    return tensor.SVDMethod(**method)
+
 
 # We want to avoid fragmenting the stream-ordered mempools
 _predefined_streams = {
diff --git a/samples/custatevec/CMakeLists.txt b/samples/custatevec/CMakeLists.txt
index 04a8e1c..520a447 100644
--- a/samples/custatevec/CMakeLists.txt
+++ b/samples/custatevec/CMakeLists.txt
@@ -123,20 +123,25 @@ endfunction()
 
 add_custom_target(custatevec_examples)
 
-add_custatevec_example(custatevec_examples "cuStateVec.example.gate_application"     gate_application.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.permutation_matrix"   permutation_matrix.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.diagonal_matrix"      diagonal_matrix.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.exponential_pauli"    exponential_pauli.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.expectation"          expectation.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.expentation_pauli"    expectation_pauli.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.sampler"              sampler.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.measure_zbasis"       measure_zbasis.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.batch_measure"        batch_measure.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.accessor_get"         accessor_get.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.accessor_set"         accessor_set.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.test_matrix_type"     test_matrix_type.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.memory_handler"       memory_handler.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.swap_index_bits"      swap_index_bits.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.mgpu_swap_index_bits" mgpu_swap_index_bits.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.mgpu_sampler"         mgpu_sampler.cu)
-add_custatevec_example(custatevec_examples "cuStateVec.example.mgpu_batch_measure"   mgpu_batch_measure.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.initialize_sv"             initialize_sv.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.gate_application"          gate_application.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.permutation_matrix"        permutation_matrix.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.diagonal_matrix"           diagonal_matrix.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.batched_gate_application"  batched_gate_application.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.exponential_pauli"         exponential_pauli.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.expectation"               expectation.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.expentation_pauli"         expectation_pauli.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.sampler"                   sampler.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.measure_zbasis"            measure_zbasis.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.batch_measure"             batch_measure.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.batched_collapse"          batched_collapse.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.batched_abs2sum"           batched_abs2sum.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.batched_measure"           batched_measure.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.accessor_get"              accessor_get.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.accessor_set"              accessor_set.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.test_matrix_type"          test_matrix_type.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.memory_handler"            memory_handler.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.swap_index_bits"           swap_index_bits.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.mgpu_swap_index_bits"      mgpu_swap_index_bits.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.mgpu_sampler"              mgpu_sampler.cu)
+add_custatevec_example(custatevec_examples "cuStateVec.example.mgpu_batch_measure"        mgpu_batch_measure.cu)
diff --git a/samples/custatevec/Makefile b/samples/custatevec/Makefile
index a96ea9a..ffc2649 100644
--- a/samples/custatevec/Makefile
+++ b/samples/custatevec/Makefile
@@ -19,23 +19,29 @@ ARCH_FLAGS      = $(ARCH_FLAGS_SM70) $(ARCH_FLAGS_SM75) $(ARCH_FLAGS_SM80) $(ARC
 CXX_FLAGS       = -std=c++11 $(INCLUDE_DIRS) $(LIBRARY_DIRS) $(ARCH_FLAGS) $(LINKER_FLAGS)
 
 all: check-env
-	nvcc gate_application.cu     -o gate_application     ${CXX_FLAGS}
-	nvcc permutation_matrix.cu   -o permutation_matrix   ${CXX_FLAGS}
-	nvcc diagonal_matrix.cu      -o diagonal_matrix      ${CXX_FLAGS}
-	nvcc exponential_pauli.cu    -o exponential_pauli    ${CXX_FLAGS}
-	nvcc expectation.cu          -o expectation          ${CXX_FLAGS}
-	nvcc expectation_pauli.cu    -o expectation_pauli    ${CXX_FLAGS}
-	nvcc sampler.cu              -o sampler              ${CXX_FLAGS}
-	nvcc measure_zbasis.cu       -o measure_zbasis       ${CXX_FLAGS}
-	nvcc batch_measure.cu        -o batch_measure        ${CXX_FLAGS}
-	nvcc accessor_get.cu         -o accessor_get         ${CXX_FLAGS}
-	nvcc accessor_set.cu         -o accessor_set         ${CXX_FLAGS}
-	nvcc test_matrix_type.cu     -o test_matrix_type     ${CXX_FLAGS}
-	nvcc memory_handler.cu       -o memory_handler       ${CXX_FLAGS}
-	nvcc swap_index_bits.cu      -o swap_index_bits      ${CXX_FLAGS}
-	nvcc mgpu_swap_index_bits.cu -o mgpu_swap_index_bits ${CXX_FLAGS}
-	nvcc mgpu_batch_measure.cu   -o mgpu_batch_measure   ${CXX_FLAGS}
-	nvcc mgpu_sampler.cu         -o mgpu_sampler         ${CXX_FLAGS}
+	nvcc initialize_sv.cu            -o initialize_sv            ${CXX_FLAGS}
+	nvcc gate_application.cu         -o gate_application         ${CXX_FLAGS}
+	nvcc permutation_matrix.cu       -o permutation_matrix       ${CXX_FLAGS}
+	nvcc diagonal_matrix.cu          -o diagonal_matrix          ${CXX_FLAGS}
+	nvcc batched_gate_application.cu -o batched_gate_application ${CXX_FLAGS}
+	nvcc exponential_pauli.cu        -o exponential_pauli        ${CXX_FLAGS}
+	nvcc expectation.cu              -o expectation              ${CXX_FLAGS}
+	nvcc expectation_pauli.cu        -o expectation_pauli        ${CXX_FLAGS}
+	nvcc sampler.cu                  -o sampler                  ${CXX_FLAGS}
+	nvcc measure_zbasis.cu           -o measure_zbasis           ${CXX_FLAGS}
+	nvcc batch_measure.cu            -o batch_measure            ${CXX_FLAGS}
+	nvcc batched_collapse.cu         -o batched_collapse         ${CXX_FLAGS}
+	nvcc batched_abs2sum.cu          -o batched_abs2sum          ${CXX_FLAGS}
+	nvcc batched_measure.cu          -o batched_measure          ${CXX_FLAGS}
+	nvcc accessor_get.cu             -o accessor_get             ${CXX_FLAGS}
+	nvcc accessor_set.cu             -o accessor_set             ${CXX_FLAGS}
+	nvcc test_matrix_type.cu         -o test_matrix_type         ${CXX_FLAGS}
+	nvcc memory_handler.cu           -o memory_handler           ${CXX_FLAGS}
+	nvcc swap_index_bits.cu          -o swap_index_bits          ${CXX_FLAGS}
+	nvcc mgpu_swap_index_bits.cu     -o mgpu_swap_index_bits     ${CXX_FLAGS}
+	nvcc mgpu_batch_measure.cu       -o mgpu_batch_measure       ${CXX_FLAGS}
+	nvcc mgpu_sampler.cu             -o mgpu_sampler             ${CXX_FLAGS}
+
 
 check-env:
 	@ echo "" && \
@@ -50,15 +56,20 @@ check-env:
 	fi
 
 clean:
-	rm -f gate_application \
+	rm -f initialize_sv \
+		gate_application \
 		permutation_matrix \
 		diagonal_matrix \
+		batched_gate_application \
 		exponential_pauli \
 		expectation \
 		expectation_pauli \
 		sampler \
 		measure_zbasis \
 		batch_measure \
+		batched_collapse \
+		abs2sum_batched \
+		measure_batched \
 		accessor_get \
 		accessor_set \
 		test_matrix_type \
diff --git a/samples/custatevec/batched_abs2sum.cu b/samples/custatevec/batched_abs2sum.cu
new file mode 100644
index 0000000..bdc5c3a
--- /dev/null
+++ b/samples/custatevec/batched_abs2sum.cu
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cuComplex.h>        // cuDoubleComplex
+#include <custatevec.h>       // custatevecAbs2SumArrayBatched
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+#include "helper.hpp"         // HANDLE_ERROR, HANDLE_CUDA_ERROR
+
+int main(void) {
+
+    const int nSVs           = 2;
+    const int nIndexBits     = 3;
+    const int nSvElms        = (1 << nIndexBits);
+    const int bitOrderingLen = 1;
+
+    // square absolute values of state vector elements for 0/2-th bits will be summed up
+    const int bitOrdering[] = {1};
+
+    const custatevecIndex_t svStride = nSvElms;
+
+    // 2 state vectors are allocated contiguously in single memory chunk.
+    cuDoubleComplex h_svs[] = {{ 0.0,  0.0},  { 0.0,  0.1},  { 0.1,  0.1},  { 0.1,  0.2}, 
+                               { 0.2,  0.2},  { 0.3,  0.3},  { 0.3,  0.4},  { 0.4,  0.5},
+                               { 0.25, 0.25}, { 0.25, 0.25}, { 0.25, 0.25}, { 0.25, 0.25}, 
+                               { 0.25, 0.25}, { 0.25, 0.25}, { 0.25, 0.25}, { 0.25, 0.25}};
+
+    const custatevecIndex_t abs2sumStride = 2;
+    const custatevecIndex_t batchedAbs2sumSize = nSVs * abs2sumStride;
+
+    // abs2sum arrays are allocated contiguously in single memory chunk.
+    double abs2sum[batchedAbs2sumSize];
+    const double abs2sum_result[] = {0.27, 0.73, 0.5, 0.5};
+
+    cuDoubleComplex *d_svs;
+    HANDLE_CUDA_ERROR( cudaMalloc((void**)&d_svs, nSVs * nSvElms * sizeof(cuDoubleComplex)) );
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(d_svs, h_svs, nSVs * nSvElms * sizeof(cuDoubleComplex), 
+                       cudaMemcpyHostToDevice) );
+
+    //----------------------------------------------------------------------------------------------
+
+    // custatevec handle initialization
+    custatevecHandle_t handle;
+    HANDLE_ERROR( custatevecCreate(&handle) );
+
+    // compute abs2sum arrays
+    HANDLE_ERROR( custatevecAbs2SumArrayBatched(
+                  handle, d_svs, CUDA_C_64F, nIndexBits, nSVs, svStride, abs2sum, abs2sumStride,
+                  bitOrdering, bitOrderingLen, nullptr, nullptr, 0) );
+
+    // destroy handle
+    HANDLE_ERROR( custatevecDestroy(handle) );
+
+    //----------------------------------------------------------------------------------------------
+
+    HANDLE_CUDA_ERROR( cudaDeviceSynchronize() );
+
+    bool correct = true;
+    for (custatevecIndex_t i = 0; i < batchedAbs2sumSize; i++) {
+        if (!almost_equal(abs2sum[i], abs2sum_result[i])) {
+            correct = false;
+            break;
+        }
+    }
+
+    HANDLE_CUDA_ERROR( cudaFree(d_svs) );
+
+    if (correct) {
+        printf("abs2sum_batched example PASSED\n");
+        return EXIT_SUCCESS;
+    }
+    else {
+        printf("abs2sum_batched example FAILED: wrong result\n");
+        return EXIT_FAILURE;
+    }
+}
\ No newline at end of file
diff --git a/samples/custatevec/batched_collapse.cu b/samples/custatevec/batched_collapse.cu
new file mode 100644
index 0000000..0204ee6
--- /dev/null
+++ b/samples/custatevec/batched_collapse.cu
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cuComplex.h>        // cuDoubleComplex
+#include <custatevec.h>       // custatevecCollapseByBitStringBatched
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+#include "helper.hpp"         // HANDLE_ERROR, HANDLE_CUDA_ERROR
+
+int main(void) {
+
+    const int nSVs       = 2;
+    const int nIndexBits = 3;
+    const int svSize     = (1 << nIndexBits);
+    const int svStride   = (1 << nIndexBits);  // no padding
+
+    // 2 state vectors are allocated contiguously in single memory chunk.
+    cuDoubleComplex h_svs[]        = {{ 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.4, 0.5},
+                                      { 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.4, 0.5}};
+    cuDoubleComplex h_svs_result[] = {{ 0.0, 0.0}, { 0.0, 1.0}, { 0.0, 0.0}, { 0.0, 0.0},
+                                      { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0},
+                                      { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0},
+                                      { 0.0, 0.0}, { 0.0, 0.0}, { 0.6, 0.8}, { 0.0, 0.0}};
+
+    // 2 bitStrings are allocated contiguously in single memory chunk.
+    // The 1st SV collapses to |001> and the 2nd to |110>
+    // Note: bitStrings can also live on the device.
+    custatevecIndex_t bitStrings[] = {0b001, 0b110};
+
+    // bit ordering should only live on host
+    const int32_t bitOrdering[] = {0, 1, 2};
+    const uint32_t bitStringLen = nIndexBits;
+
+    // 2 norms are allocated contiguously in single memory chunk.
+    // Note: norms can also live on the device.
+    double norms[] = {0.01, 0.25};
+
+    cuDoubleComplex *d_svs;
+    HANDLE_CUDA_ERROR( cudaMalloc((void**)&d_svs, nSVs * svSize * sizeof(cuDoubleComplex)) );
+ 
+    HANDLE_CUDA_ERROR( cudaMemcpy(d_svs, h_svs, nSVs * svSize * sizeof(cuDoubleComplex),
+                       cudaMemcpyHostToDevice) );
+
+    //---------------------------------------------------------------------------------------------
+
+    // custatevec handle initialization
+    custatevecHandle_t handle;
+    HANDLE_ERROR( custatevecCreate(&handle) );
+
+    void* extraWorkspace = nullptr;
+    size_t extraWorkspaceSizeInBytes = 0;
+
+    // check the size of external workspace
+    HANDLE_ERROR( custatevecCollapseByBitStringBatchedGetWorkspaceSize(
+                  handle, nSVs, bitStrings, norms, &extraWorkspaceSizeInBytes) );
+
+    // allocate external workspace if necessary
+    if (extraWorkspaceSizeInBytes > 0)
+        HANDLE_CUDA_ERROR( cudaMalloc(&extraWorkspace, extraWorkspaceSizeInBytes) );
+
+    // collapse the quantum states to the target bitstrings
+    HANDLE_ERROR( custatevecCollapseByBitStringBatched(
+                  handle, d_svs, CUDA_C_64F, nIndexBits, nSVs, svStride,
+                  bitStrings, bitOrdering, bitStringLen, norms,
+                  extraWorkspace, extraWorkspaceSizeInBytes) );
+
+    // destroy handle
+    HANDLE_ERROR( custatevecDestroy(handle) );
+
+    //---------------------------------------------------------------------------------------------
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(h_svs, d_svs, nSVs * svSize * sizeof(cuDoubleComplex),
+                       cudaMemcpyDeviceToHost) );
+
+    bool correct = true;
+    for (int i = 0; i < nSVs * svSize; i++) {
+        if (!almost_equal(h_svs[i], h_svs_result[i])) {
+            correct = false;
+            break;
+        }
+    }
+
+    HANDLE_CUDA_ERROR( cudaFree(d_svs) );
+    if (extraWorkspaceSizeInBytes)
+        HANDLE_CUDA_ERROR( cudaFree(extraWorkspace) );
+
+    if (correct) {
+        printf("batched_collapse example PASSED\n");
+        return EXIT_SUCCESS;
+    }
+    else {
+        printf("batched_collapse example FAILED: wrong result\n");
+        return EXIT_FAILURE;
+    }
+
+}
diff --git a/samples/custatevec/batched_gate_application.cu b/samples/custatevec/batched_gate_application.cu
new file mode 100644
index 0000000..de6ee3f
--- /dev/null
+++ b/samples/custatevec/batched_gate_application.cu
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cuComplex.h>        // cuDoubleComplex
+#include <custatevec.h>       // custatevecApplyMatrixBatched
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+#include "helper.hpp"         // HANDLE_ERROR, HANDLE_CUDA_ERROR
+
+int main(void) {
+
+    const int nSVs       = 2;
+    const int nIndexBits = 3;
+    const int nSvSize    = (1 << nIndexBits);
+    const int svStride   = nSvSize;
+    const int nTargets   = 1;
+    const int nControls  = 2;
+    const int adjoint    = 0;
+
+    const int targets[]  = {2};
+    const int controls[] = {0, 1};
+
+    const int nMatrices = 2;
+    const int matrixIndices[] = {1, 0};
+
+    // 2 state vectors are allocated contiguously in single memory chunk.
+    cuDoubleComplex h_svs[]        = {{ 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.4, 0.5},
+                                      { 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.4, 0.5}};
+    cuDoubleComplex h_svs_result[] = {{ 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, {-0.4,-0.5},
+                                      { 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.4, 0.5}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.1, 0.2}};
+    // 2 gate matrices are allocated contiguously in single memory chunk.
+    cuDoubleComplex matrices[] = {{0.0, 0.0}, {1.0, 0.0},
+                                  {1.0, 0.0}, {0.0, 0.0},
+                                  {1.0, 0.0}, {0.0, 0.0},
+                                  {0.0, 0.0}, {-1.0, 0.0}};
+
+    cuDoubleComplex *d_svs;
+    HANDLE_CUDA_ERROR( cudaMalloc((void**)&d_svs, nSVs * svStride * sizeof(cuDoubleComplex)) );
+ 
+    HANDLE_CUDA_ERROR( cudaMemcpy(d_svs, h_svs, nSVs * svStride * sizeof(cuDoubleComplex),
+                       cudaMemcpyHostToDevice) );
+
+    //---------------------------------------------------------------------------------------------
+
+    // custatevec handle initialization
+    custatevecHandle_t handle;
+    HANDLE_ERROR( custatevecCreate(&handle) );
+
+    void* extraWorkspace = nullptr;
+    size_t extraWorkspaceSizeInBytes = 0;
+
+    // check the size of external workspace
+    HANDLE_ERROR( custatevecApplyMatrixBatchedGetWorkspaceSize(
+                  handle, CUDA_C_64F, nIndexBits, nSVs, svStride,
+                  CUSTATEVEC_MATRIX_MAP_TYPE_MATRIX_INDEXED, matrixIndices, matrices, CUDA_C_64F,
+                  CUSTATEVEC_MATRIX_LAYOUT_ROW, adjoint, nMatrices, nTargets, nControls,
+                  CUSTATEVEC_COMPUTE_64F, &extraWorkspaceSizeInBytes) );
+
+    // allocate external workspace if necessary
+    if (extraWorkspaceSizeInBytes > 0)
+        HANDLE_CUDA_ERROR( cudaMalloc(&extraWorkspace, extraWorkspaceSizeInBytes) );
+
+    // apply gate
+    HANDLE_ERROR( custatevecApplyMatrixBatched(
+                  handle, d_svs, CUDA_C_64F, nIndexBits, nSVs, svStride,
+                  CUSTATEVEC_MATRIX_MAP_TYPE_MATRIX_INDEXED, matrixIndices, matrices, CUDA_C_64F,
+                  CUSTATEVEC_MATRIX_LAYOUT_ROW, adjoint, nMatrices, targets, nTargets, controls,
+                  nullptr, nControls, CUSTATEVEC_COMPUTE_64F, extraWorkspace,
+                  extraWorkspaceSizeInBytes) );
+
+    // destroy handle
+    HANDLE_ERROR( custatevecDestroy(handle) );
+
+    //---------------------------------------------------------------------------------------------
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(h_svs, d_svs, nSVs * svStride * sizeof(cuDoubleComplex),
+                       cudaMemcpyDeviceToHost) );
+
+    bool correct = true;
+    for (int i = 0; i < nSVs * svStride; i++) {
+        if (!almost_equal(h_svs[i], h_svs_result[i])) {
+            correct = false;
+            break;
+        }
+    }
+
+    HANDLE_CUDA_ERROR( cudaFree(d_svs) );
+    if (extraWorkspaceSizeInBytes)
+        HANDLE_CUDA_ERROR( cudaFree(extraWorkspace) );
+
+    if (correct) {
+        printf("batched_gate_application example PASSED\n");
+        return EXIT_SUCCESS;
+    }
+    else {
+        printf("batched_gate_application example FAILED: wrong result\n");
+        return EXIT_FAILURE;
+    }
+
+}
\ No newline at end of file
diff --git a/samples/custatevec/batched_measure.cu b/samples/custatevec/batched_measure.cu
new file mode 100644
index 0000000..d10c921
--- /dev/null
+++ b/samples/custatevec/batched_measure.cu
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cuComplex.h>        // cuDoubleComplex
+#include <custatevec.h>       // custatevecMeasureBatched
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+#include "helper.hpp"         // HANDLE_ERROR, HANDLE_CUDA_ERROR
+
+int main(void) {
+
+    const int nSVs         = 2;
+    const int nIndexBits   = 3;
+    const int nSvElms      = (1 << nIndexBits);
+    const int bitStringLen = 3;
+
+    const int bitOrdering[] = {2, 1, 0};
+
+    const custatevecIndex_t svStride = nSvElms;
+
+    custatevecIndex_t bitStrings[nSVs];
+    const custatevecIndex_t bitStrings_result[] = {0b100, 0b011};
+
+    // In real appliction, random number in range [0, 1) will be used.
+    const double randnums[] = {0.009, 0.5}; 
+
+    // 2 state vectors are allocated contiguously in single memory chunk.
+    cuDoubleComplex h_svs[]        = {{ 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.4, 0.5},
+                                      { 0.0, 0.0}, { 0.0, 0.1}, { 0.1, 0.1}, { 0.1, 0.2}, 
+                                      { 0.2, 0.2}, { 0.3, 0.3}, { 0.3, 0.4}, { 0.4, 0.5}};
+    cuDoubleComplex h_svs_result[] = {{ 0.0, 0.0}, { 0.0, 1.0}, { 0.0, 0.0}, { 0.0, 0.0}, 
+                                      { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0},
+                                      { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, 
+                                      { 0.0, 0.0}, { 0.0, 0.0}, { 0.6, 0.8}, { 0.0, 0.0}};
+
+    cuDoubleComplex *d_svs;
+    HANDLE_CUDA_ERROR( cudaMalloc((void**)&d_svs, nSVs * nSvElms * sizeof(cuDoubleComplex)) );
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(d_svs, h_svs, nSVs * nSvElms * sizeof(cuDoubleComplex), 
+                       cudaMemcpyHostToDevice) );
+
+    //----------------------------------------------------------------------------------------------
+
+    // custatevec handle initialization
+    custatevecHandle_t handle;
+    HANDLE_ERROR( custatevecCreate(&handle) );
+
+    // batched measurement
+    HANDLE_ERROR( custatevecMeasureBatched(
+                  handle, d_svs, CUDA_C_64F, nIndexBits, nSVs, svStride, bitStrings, bitOrdering,
+                  bitStringLen, randnums, CUSTATEVEC_COLLAPSE_NORMALIZE_AND_ZERO) );
+
+    // destroy handle
+    HANDLE_ERROR( custatevecDestroy(handle) );
+
+    //----------------------------------------------------------------------------------------------
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(h_svs, d_svs, nSVs * nSvElms * sizeof(cuDoubleComplex),
+                       cudaMemcpyDeviceToHost) );
+
+    bool correct = true;
+    for (int i = 0; i < nSVs * nSvElms; i++) {
+        if (!almost_equal(h_svs[i], h_svs_result[i])) {
+            correct = false;
+            break;
+        }
+    }
+
+    for (int i = 0; i < nSVs; i++) {
+        if (bitStrings[i] != bitStrings_result[i]) {
+            correct = false;
+            break;
+        }
+    }
+
+    HANDLE_CUDA_ERROR( cudaFree(d_svs) );
+
+    if (correct) {
+        printf("measure_batched example PASSED\n");
+        return EXIT_SUCCESS;
+    }
+    else {
+        printf("measure_batched example FAILED: wrong result\n");
+        return EXIT_FAILURE;
+    }
+}
\ No newline at end of file
diff --git a/samples/custatevec/initialize_sv.cu b/samples/custatevec/initialize_sv.cu
new file mode 100644
index 0000000..506d0e5
--- /dev/null
+++ b/samples/custatevec/initialize_sv.cu
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <cuda_runtime_api.h> // cudaMalloc, cudaMemcpy, etc.
+#include <cuComplex.h>        // cuDoubleComplex
+#include <custatevec.h>       // custatevecInitializeStateVector
+#include <stdio.h>            // printf
+#include <stdlib.h>           // EXIT_FAILURE
+
+#include "helper.hpp"         // HANDLE_ERROR, HANDLE_CUDA_ERROR
+
+int main(void) {
+
+    const int nIndexBits = 3;
+    const int svSize = (1 << nIndexBits);
+
+    cuDoubleComplex h_sv[svSize];
+
+    cuDoubleComplex h_sv_result[] = {{ 1.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0},
+                                     { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}, { 0.0, 0.0}};
+
+    cuDoubleComplex *d_sv;
+    HANDLE_CUDA_ERROR( cudaMalloc((void**)&d_sv, svSize * sizeof(cuDoubleComplex)) );
+
+    // populate the device memory with junk values (for illustrative purpose only)
+    HANDLE_CUDA_ERROR( cudaMemset(d_sv, 0x7F, svSize * sizeof(cuDoubleComplex)) );
+
+    //----------------------------------------------------------------------------------------------
+
+    // custatevec handle initialization
+    custatevecHandle_t handle;
+    HANDLE_ERROR( custatevecCreate(&handle) );
+
+    // initialize the state vector
+    HANDLE_ERROR( custatevecInitializeStateVector(
+                  handle, d_sv, CUDA_C_64F, nIndexBits, CUSTATEVEC_STATE_VECTOR_TYPE_ZERO) );
+
+    // destroy handle
+    HANDLE_ERROR( custatevecDestroy(handle) );
+
+    //----------------------------------------------------------------------------------------------
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(h_sv, d_sv, svSize * sizeof(cuDoubleComplex),
+                       cudaMemcpyDeviceToHost) );
+
+    bool correct = true;
+    for (int i = 0; i < svSize; i++) {
+        if (!almost_equal(h_sv[i], h_sv_result[i])) {
+            correct = false;
+            break;
+        }
+    }
+
+    HANDLE_CUDA_ERROR( cudaFree(d_sv) );
+
+    if (correct) {
+        printf("initialize_sv example PASSED\n");
+        return EXIT_SUCCESS;
+    }
+    else {
+        printf("initialize_sv example FAILED: wrong result\n");
+        return EXIT_FAILURE;
+    }
+
+}
diff --git a/samples/cutensornet/CMakeLists.txt b/samples/cutensornet/CMakeLists.txt
index 7fdcc5e..1bee4d0 100644
--- a/samples/cutensornet/CMakeLists.txt
+++ b/samples/cutensornet/CMakeLists.txt
@@ -43,12 +43,6 @@ endfunction()
 # cutensornet_example dependencies
 # ##########################################
 
-set_with_fallback(CUTENSOR_ROOT NONE)
-
-if (CUTENSOR_ROOT STREQUAL "")
-    message(FATAL_ERROR "Please set the environment variables CUTENSOR_ROOT to the path of the cuTENSOR installation.")
-endif ()
-
 set_with_fallback(CUTENSORNET_ROOT CUQUANTUM_ROOT)
 
 if (CUTENSORNET_ROOT STREQUAL "")
@@ -84,13 +78,11 @@ function(add_cutensornet_example GROUP_TARGET EXAMPLE_NAME EXAMPLE_SOURCES)
     ${EXAMPLE_TARGET}
       PUBLIC
         ${CUDA_INCLUDE_DIRS}
-        ${CUTENSOR_ROOT}/include
         ${CUTENSORNET_ROOT}/include
   )
   target_link_directories(
     ${EXAMPLE_TARGET}
       PUBLIC
-        ${CUTENSOR_ROOT}/lib/11
         ${CUTENSORNET_ROOT}/lib
         ${CUTENSORNET_ROOT}/lib64
   )
@@ -98,17 +90,12 @@ function(add_cutensornet_example GROUP_TARGET EXAMPLE_NAME EXAMPLE_SOURCES)
     ${EXAMPLE_TARGET}
       PUBLIC
         cutensornet
-        cutensor
-        cudart
-        cusolver
-        cublasLt
         $<$<BOOL:${MPI_FOUND}>:MPI::MPI_CXX>
   )
   set_target_properties(
     ${EXAMPLE_TARGET}
       PROPERTIES
         POSITION_INDEPENDENT_CODE ON
-        CUDA_SEPARABLE_COMPILATION ON
         CUDA_ARCHITECTURES
           "70;75;80"
   )
@@ -129,7 +116,10 @@ endfunction()
 add_custom_target(cutensornet_examples)
 
 add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet" tensornet_example.cu)
-add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet" tensornet_example_reuse.cu)
+add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.reuse" tensornet_example_reuse.cu)
+add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.gradients" tensornet_example_gradients.cu)
+add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.marginal" high_level/marginal_example.cu)
+add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.sampler" high_level/sampling_example.cu)
 add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.svd" approxTN/tensor_svd_example.cu)
 add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.qr" approxTN/tensor_qr_example.cu)
 add_cutensornet_example(cutensornet_examples "cuTENSORNet.example.tensornet.gate" approxTN/gate_split_example.cu)
diff --git a/samples/cutensornet/Makefile b/samples/cutensornet/Makefile
index 746a813..3d7f7e7 100644
--- a/samples/cutensornet/Makefile
+++ b/samples/cutensornet/Makefile
@@ -4,13 +4,12 @@
 
 SHELL            := /bin/bash
 CUDA_PATH        := ${CUDA_PATH}
-CUTENSOR_ROOT    := ${CUTENSOR_ROOT}
 CUTENSORNET_ROOT ?= ${CUQUANTUM_ROOT}
 MPI_ROOT         := ${MPI_ROOT}
-
-INCLUDE_DIRS     := -I${CUTENSORNET_ROOT}/include -I${CUTENSOR_ROOT}/include -I${MPI_ROOT}/include
-LIBRARY_DIRS     := -L${CUTENSORNET_ROOT}/lib -L${CUTENSORNET_ROOT}/lib64 -L${CUTENSOR_ROOT}/lib/11
-LINKER_FLAGS     := -lcutensornet -lcutensor -lcudart -lcusolver
+CUDA_MAJOR_VERSION := $(shell nvcc --version | egrep -o "V[0-9]+.[0-9]+.[0-9]" | cut -c2-3)
+INCLUDE_DIRS     := -I${CUTENSORNET_ROOT}/include -I${MPI_ROOT}/include
+LIBRARY_DIRS     := -L${CUTENSORNET_ROOT}/lib -L${CUTENSORNET_ROOT}/lib64 
+LINKER_FLAGS     := -lcutensornet
 
 ARCH_FLAGS_SM70  = -gencode arch=compute_70,code=sm_70
 ARCH_FLAGS_SM75  = -gencode arch=compute_75,code=sm_75
@@ -24,10 +23,13 @@ CXX_FLAGS        = -std=c++11 $(INCLUDE_DIRS) $(LIBRARY_DIRS) $(LINKER_FLAGS) $(
 all: check-env
 	${CUDA_PATH}/bin/nvcc tensornet_example.cu -o tensornet_example ${CXX_FLAGS}
 	${CUDA_PATH}/bin/nvcc tensornet_example_reuse.cu -o tensornet_example_reuse ${CXX_FLAGS}
+	${CUDA_PATH}/bin/nvcc tensornet_example_gradients.cu -o tensornet_example_gradients ${CXX_FLAGS}
 	${CUDA_PATH}/bin/nvcc approxTN/tensor_svd_example.cu -o tensor_svd_example ${CXX_FLAGS}
 	${CUDA_PATH}/bin/nvcc approxTN/tensor_qr_example.cu -o tensor_qr_example ${CXX_FLAGS}
 	${CUDA_PATH}/bin/nvcc approxTN/gate_split_example.cu -o gate_split_example ${CXX_FLAGS}
 	${CUDA_PATH}/bin/nvcc approxTN/mps_example.cu -o mps_example ${CXX_FLAGS}
+	${CUDA_PATH}/bin/nvcc high_level/marginal_example.cu -o marginal_example ${CXX_FLAGS}
+	${CUDA_PATH}/bin/nvcc high_level/sampling_example.cu -o sampling_example ${CXX_FLAGS}
     ifdef MPI_ROOT
 		${CUDA_PATH}/bin/nvcc tensornet_example_mpi.cu -Xlinker -rpath,${MPI_ROOT}/lib -L${MPI_ROOT}/lib -o tensornet_example_mpi ${CXX_FLAGS} -lmpi
 		${CUDA_PATH}/bin/nvcc tensornet_example_mpi_auto.cu -Xlinker -rpath,${MPI_ROOT}/lib -L${MPI_ROOT}/lib -o tensornet_example_mpi_auto ${CXX_FLAGS} -lmpi
@@ -36,16 +38,9 @@ all: check-env
 check-env:
 	@ echo "" && \
 	echo "CUDA_PATH=${CUDA_PATH}"; \
-	echo "CUTENSOR_ROOT=${CUTENSOR_ROOT}"; \
 	echo "CUTENSORNET_ROOT=${CUTENSORNET_ROOT}"; \
     echo "MPI_ROOT=${MPI_ROOT}"; \
 	echo ""; \
-	if [[ -z "${CUTENSOR_ROOT}" ]]; \
-	then \
-		echo "" && \
-		echo "CUTENSOR_ROOT is not set." && \
-		exit 1; \
-	fi; \
 	if [[ -z "${CUTENSORNET_ROOT}" ]]; \
 	then \
 		echo "" && \
@@ -60,6 +55,14 @@ check-env:
 	fi
 
 clean:
-	rm -f tensornet_example tensornet_example.o tensornet_example_reuse tensornet_example_reuse.o tensornet_example_mpi tensornet_example_mpi.o tensornet_example_mpi_auto tensornet_example_mpi_auto.o
-	rm -f tensor_qr_example tensor_qr_example.o tensor_svd_example tensor_svd_example.o
-	rm -f gatesplit_example gatesplit_example.o mps_example mps_example.o
+	rm -f tensornet_example tensornet_example.o
+	rm -f tensornet_example_reuse tensornet_example_reuse.o
+	rm -f tensornet_example_gradients tensornet_example_gradients.o
+	rm -f tensor_svd_example tensor_svd_example.o
+	rm -f tensor_qr_example tensor_qr_example.o
+	rm -f gate_split_example gate_split_example.o
+	rm -f mps_example mps_example.o
+	rm -f marginal_example marginal_example.o
+	rm -f sampling_example sampling_example.o
+	rm -f tensornet_example_mpi tensornet_example_mpi.o
+	rm -f tensornet_example_mpi_auto tensornet_example_mpi_auto.o
diff --git a/samples/cutensornet/README.md b/samples/cutensornet/README.md
index 735a723..b618a00 100644
--- a/samples/cutensornet/README.md
+++ b/samples/cutensornet/README.md
@@ -50,6 +50,12 @@ The tensor SVD sample can be easily executed in a command shell using:
 ```
 The sample for tensor QR, gate split and MPS can also be executed in the same fashion.
 
+**Note**: Depending on how CUDA Toolkit and cuTENSOR are installed, you might need to add them to `LD_LIBRARY_PATH` like this:
+```
+export LD_LIBRARY_PATH=$CUDA_PATH/lib64:$CUTENSOR_ROOT/lib/11:$LD_LIBRARY_PATH
+```
+The cuTENSOR library path would depend on the CUDA major version. Please refer to the [Getting Started](https://docs.nvidia.com/cuda/cuquantum/cutensornet/getting_started.html) page for further detail.
+
 ## Support
 
 * **Supported SM Architectures:** SM 7.0, SM 7.5, SM 8.0, SM 8.6, SM 9.0
@@ -164,3 +170,14 @@ This sample demonstrates how to:
 * Mark input tensors as "constant" when creating a tensor network using `cutensornetCreateNetworkDescriptor`, by setting the corresponding `cutensornetTensorQualifiers_t` field.
 * Provide a cache workspace to the contraction plan which will be used to accelerate the subsequent contractions of the same network. It shows how to query the required cache memory size using `cutensornetWorkspaceGetMemorySize` with a `CUTENSORNET_WORKSPACE_CACHE` workspace-kind, and how to the provide the workspace memory using `cutensornetWorkspaceSetMemory`.
 * Provide a predefined contraction path to the contraction optimizer by calling `cutensornetContractionOptimizerInfoSetAttribute` with `CUTENSORNET_CONTRACTION_OPTIMIZER_INFO_PATH` attribute.
+
+### 9. Gradient via back-propagation (`tensornet_example_gradients.cu`)
+
+This sample demonstrates how to perform back-propagation to compute gradients of a tensor-network w.r.t. select input tensors.
+This sample largely builds on first sample provided above.
+
+This sample demonstrates how to:
+* Mark input tensors for gradient computation when creating a tensor network by calling `cutensornetNetworkSetAttribute`.
+* Provide a cache workspace to the contraction plan which will be used to hold intermediate data needed for gradient computation. It shows how to query the required cache memory size using `cutensornetWorkspaceGetMemorySize` with a `CUTENSORNET_WORKSPACE_CACHE` workspace-kind, and how to the provide the workspace memory using `cutensornetWorkspaceSetMemory`.
+* Call `cutensornetComputeGradientsBackward` to perform the gradient computation.
+* Call `cutensornetWorkspacePurgeCache` to clean up the cache and prepare for the next gradient calculation.
diff --git a/samples/cutensornet/approxTN/tensor_svd_example.cu b/samples/cutensornet/approxTN/tensor_svd_example.cu
index dd523c2..cd856eb 100644
--- a/samples/cutensornet/approxTN/tensor_svd_example.cu
+++ b/samples/cutensornet/approxTN/tensor_svd_example.cu
@@ -217,12 +217,14 @@ int main()
    printf("Initialize the cuTensorNet library and create all tensor descriptors.\n");
 
    // Sphinx: #5
-   /********************************
-   * Setup SVD truncation parameters
-   *********************************/
+   /**********************************************
+   * Setup SVD algorithm and truncation parameters
+   ***********************************************/
 
    cutensornetTensorSVDConfig_t svdConfig;
    HANDLE_ERROR( cutensornetCreateTensorSVDConfig(handle, &svdConfig) );
+
+   // set up truncation parameters
    double absCutoff = 1e-2;
    HANDLE_ERROR( cutensornetTensorSVDConfigSetAttribute(handle, 
                                           svdConfig, 
@@ -236,6 +238,21 @@ int main()
                                           &relCutoff, 
                                           sizeof(relCutoff)) );
    
+   // optional: choose gesvdj algorithm with customized parameters. Default is gesvd.
+   cutensornetTensorSVDAlgo_t svdAlgo = CUTENSORNET_TENSOR_SVD_ALGO_GESVDJ;
+   HANDLE_ERROR( cutensornetTensorSVDConfigSetAttribute(handle, 
+                                          svdConfig, 
+                                          CUTENSORNET_TENSOR_SVD_CONFIG_ALGO, 
+                                          &svdAlgo, 
+                                          sizeof(svdAlgo)) );
+   cutensornetGesvdjParams_t gesvdjParams{/*tol=*/1e-12, /*maxSweeps=*/80};
+   HANDLE_ERROR( cutensornetTensorSVDConfigSetAttribute(handle, 
+                                          svdConfig, 
+                                          CUTENSORNET_TENSOR_SVD_CONFIG_ALGO_PARAMS, 
+                                          &gesvdjParams, 
+                                          sizeof(gesvdjParams)) );
+   printf("Set up SVDConfig to use GESVDJ algorithm with truncation\n");
+   
    /********************************************************
    * Create SVDInfo to record runtime SVD truncation details
    *********************************************************/
@@ -337,11 +354,14 @@ int main()
 
    double discardedWeight{0};
    int64_t reducedExtent{0};
+   cutensornetGesvdjStatus_t gesvdjStatus;
    cudaDeviceSynchronize(); // device synchronization.
    HANDLE_ERROR( cutensornetTensorSVDInfoGetAttribute( handle, svdInfo, CUTENSORNET_TENSOR_SVD_INFO_DISCARDED_WEIGHT, &discardedWeight, sizeof(discardedWeight)) );
    HANDLE_ERROR( cutensornetTensorSVDInfoGetAttribute( handle, svdInfo, CUTENSORNET_TENSOR_SVD_INFO_REDUCED_EXTENT, &reducedExtent, sizeof(reducedExtent)) );
+   HANDLE_ERROR( cutensornetTensorSVDInfoGetAttribute( handle, svdInfo, CUTENSORNET_TENSOR_SVD_INFO_ALGO_STATUS, &gesvdjStatus, sizeof(gesvdjStatus)) );
 
    printf("elapsed time: %.2f ms\n", minTimeCUTENSOR * 1000.f);
+   printf("GESVDJ residual: %.4f, runtime sweeps = %d\n", gesvdjStatus.residual, gesvdjStatus.sweeps);
    printf("reduced extent found at runtime: %lu\n", reducedExtent);
    printf("discarded weight: %.2f\n", discardedWeight);
 
diff --git a/samples/cutensornet/high_level/marginal_example.cu b/samples/cutensornet/high_level/marginal_example.cu
new file mode 100644
index 0000000..5310a53
--- /dev/null
+++ b/samples/cutensornet/high_level/marginal_example.cu
@@ -0,0 +1,199 @@
+/* Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Sphinx: Marginal #1
+
+#include <cstdlib>
+#include <cstdio>
+#include <cassert>
+#include <complex>
+#include <vector>
+#include <bitset>
+#include <iostream>
+
+#include <cuda_runtime.h>
+#include <cutensornet.h>
+
+
+#define HANDLE_CUDA_ERROR(x) \
+{ const auto err = x; \
+  if( err != cudaSuccess ) \
+  { printf("CUDA error %s in line %d\n", cudaGetErrorString(err), __LINE__); fflush(stdout); std::abort(); } \
+};
+
+#define HANDLE_CUTN_ERROR(x) \
+{ const auto err = x; \
+  if( err != CUTENSORNET_STATUS_SUCCESS ) \
+  { printf("cuTensorNet error %s in line %d\n", cutensornetGetErrorString(err), __LINE__); fflush(stdout); std::abort(); } \
+};
+
+
+int main(int argc, char **argv)
+{
+  constexpr std::size_t fp64size = sizeof(double);
+
+  // Sphinx: Marginal #2
+
+  // Quantum state configuration
+  constexpr int32_t numQubits = 16;
+  const std::vector<int64_t> qubitDims(numQubits,2); // qubit dimensions
+  constexpr int32_t numMarginalModes = 2; // rank of the marginal (reduced density matrix)
+  const std::vector<int32_t> marginalModes({0,1}); // open qubits (must be in acsending order)
+  std::cout << "Quantum circuit: " << numQubits << " qubits\n";
+
+  // Sphinx: Marginal #3
+
+  // Initialize the cuTensorNet library
+  HANDLE_CUDA_ERROR(cudaSetDevice(0));
+  cutensornetHandle_t cutnHandle;
+  HANDLE_CUTN_ERROR(cutensornetCreate(&cutnHandle));
+  std::cout << "Initialized cuTensorNet library on GPU 0\n";
+
+  // Sphinx: Marginal #4
+
+  // Define necessary quantum gate tensors in Host memory
+  const double invsq2 = 1.0 / std::sqrt(2.0);
+  //  Hadamard gate
+  const std::vector<std::complex<double>> h_gateH {{invsq2, 0.0},  {invsq2, 0.0},
+                                                   {invsq2, 0.0}, {-invsq2, 0.0}};
+  //  CX gate
+  const std::vector<std::complex<double>> h_gateCX {{1.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0},
+                                                    {0.0, 0.0}, {1.0, 0.0}, {0.0, 0.0}, {0.0, 0.0},
+                                                    {0.0, 0.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}};
+
+  // Copy quantum gates to Device memory
+  void *d_gateH{nullptr}, *d_gateCX{nullptr};
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_gateH, 4 * (2 * fp64size)));
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_gateCX, 16 * (2 * fp64size)));
+  std::cout << "Allocated quantum gate memory on GPU\n";
+  HANDLE_CUDA_ERROR(cudaMemcpy(d_gateH, h_gateH.data(), 4 * (2 * fp64size), cudaMemcpyHostToDevice));
+  HANDLE_CUDA_ERROR(cudaMemcpy(d_gateCX, h_gateCX.data(), 16 * (2 * fp64size), cudaMemcpyHostToDevice));
+  std::cout << "Copied quantum gates to GPU memory\n";
+
+  // Sphinx: Marginal #5
+
+  // Allocate the specified quantum circuit reduced density matrix (marginal) in Device memory
+  void *d_rdm{nullptr};
+  std::size_t rdmDim = 1;
+  for(const auto & mode: marginalModes) rdmDim *= qubitDims[mode];
+  const std::size_t rdmSize = rdmDim * rdmDim;
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_rdm, rdmSize * (2 * fp64size)));
+
+  // Sphinx: Marginal #6
+
+  // Query the free memory on Device
+  std::size_t freeSize{0}, totalSize{0};
+  HANDLE_CUDA_ERROR(cudaMemGetInfo(&freeSize, &totalSize));
+  const std::size_t scratchSize = (freeSize - (freeSize % 4096)) / 2; // use half of available memory with alignment
+  void *d_scratch{nullptr};
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_scratch, scratchSize));
+  std::cout << "Allocated " << scratchSize << " bytes of scratch memory on GPU\n";
+
+  // Sphinx: Marginal #7
+
+  // Create the initial quantum state
+  cutensornetState_t quantumState;
+  HANDLE_CUTN_ERROR(cutensornetCreateState(cutnHandle, CUTENSORNET_STATE_PURITY_PURE, numQubits, qubitDims.data(),
+                    CUDA_C_64F, &quantumState));
+  std::cout << "Created the initial quantum state\n";
+
+  // Sphinx: Marginal #8
+
+  // Construct the final quantum circuit state (apply quantum gates) for the GHZ circuit
+  int64_t id;
+  HANDLE_CUTN_ERROR(cutensornetStateApplyTensor(cutnHandle, quantumState, 1, std::vector<int32_t>{{0}}.data(),
+                    d_gateH, nullptr, 1, 0, 1, &id));
+  for(int32_t i = 1; i < numQubits; ++i) {
+    HANDLE_CUTN_ERROR(cutensornetStateApplyTensor(cutnHandle, quantumState, 2, std::vector<int32_t>{{i-1,i}}.data(),
+                      d_gateCX, nullptr, 1, 0, 1, &id));
+  }
+  std::cout << "Applied quantum gates\n";
+
+  // Sphinx: Marginal #9
+
+  // Specify the desired reduced density matrix (marginal)
+  cutensornetStateMarginal_t marginal;
+  HANDLE_CUTN_ERROR(cutensornetCreateMarginal(cutnHandle, quantumState, numMarginalModes, marginalModes.data(),
+                    0, nullptr, std::vector<int64_t>{{1,2,4,8}}.data(), &marginal)); // using explicit strides
+  std::cout << "Created the specified quantum circuit reduced densitry matrix (marginal)\n";
+
+  // Sphinx: Marginal #10
+
+  // Configure the computation of the specified quantum circuit reduced density matrix (marginal)
+  const int32_t numHyperSamples = 8; // desired number of hyper samples used in the tensor network contraction path finder
+  HANDLE_CUTN_ERROR(cutensornetMarginalConfigure(cutnHandle, marginal,
+                    CUTENSORNET_MARGINAL_OPT_NUM_HYPER_SAMPLES, &numHyperSamples, sizeof(numHyperSamples)));
+
+  // Sphinx: Marginal #11
+
+  // Prepare the specified quantum circuit reduced densitry matrix (marginal)
+  cutensornetWorkspaceDescriptor_t workDesc;
+  HANDLE_CUTN_ERROR(cutensornetCreateWorkspaceDescriptor(cutnHandle, &workDesc));
+  std::cout << "Created the workspace descriptor\n";
+  HANDLE_CUTN_ERROR(cutensornetMarginalPrepare(cutnHandle, marginal, scratchSize, workDesc, 0x0));
+  std::cout << "Prepared the specified quantum circuit reduced density matrix (marginal)\n";
+
+  // Sphinx: Marginal #12
+
+  // Attach the workspace buffer
+  int64_t worksize {0};
+  HANDLE_CUTN_ERROR(cutensornetWorkspaceGetMemorySize(cutnHandle,
+                                                      workDesc,
+                                                      CUTENSORNET_WORKSIZE_PREF_RECOMMENDED,
+                                                      CUTENSORNET_MEMSPACE_DEVICE,
+                                                      CUTENSORNET_WORKSPACE_SCRATCH,
+                                                      &worksize));
+  std::cout << "Required scratch GPU workspace size (bytes) = " << worksize << std::endl;
+  if(worksize <= scratchSize) {
+    HANDLE_CUTN_ERROR(cutensornetWorkspaceSetMemory(cutnHandle, workDesc, CUTENSORNET_MEMSPACE_DEVICE,
+                      CUTENSORNET_WORKSPACE_SCRATCH, d_scratch, worksize));
+  }else{
+    std::cout << "ERROR: Insufficient workspace size on Device!\n";
+    std::abort();
+  }
+  std::cout << "Set the workspace buffer\n";
+
+  // Sphinx: Marginal #13
+
+  // Compute the specified quantum circuit reduced densitry matrix (marginal)
+  HANDLE_CUTN_ERROR(cutensornetMarginalCompute(cutnHandle, marginal, nullptr, workDesc, d_rdm, 0));
+  std::cout << "Computed the specified quantum circuit reduced density matrix (marginal)\n";
+  std::vector<std::complex<double>> h_rdm(rdmSize);
+  HANDLE_CUDA_ERROR(cudaMemcpy(h_rdm.data(), d_rdm, rdmSize * (2 * fp64size), cudaMemcpyDeviceToHost));
+  std::cout << "Reduced density matrix for " << numMarginalModes << " qubits:\n";
+  for(std::size_t i = 0; i < rdmDim; ++i) {
+    for(std::size_t j = 0; j < rdmDim; ++j) {
+      std::cout << " " << h_rdm[i + j * rdmDim];
+    }
+    std::cout << std::endl;
+  }
+
+  // Sphinx: Marginal #14
+
+  // Destroy the workspace descriptor
+  HANDLE_CUTN_ERROR(cutensornetDestroyWorkspaceDescriptor(workDesc));
+  std::cout << "Destroyed the workspace descriptor\n";
+
+  // Destroy the quantum circuit reduced density matrix
+  HANDLE_CUTN_ERROR(cutensornetDestroyMarginal(marginal));
+  std::cout << "Destroyed the quantum circuit state reduced density matrix (marginal)\n";
+
+  // Destroy the quantum circuit state
+  HANDLE_CUTN_ERROR(cutensornetDestroyState(quantumState));
+  std::cout << "Destroyed the quantum circuit state\n";
+
+  HANDLE_CUDA_ERROR(cudaFree(d_scratch));
+  HANDLE_CUDA_ERROR(cudaFree(d_rdm));
+  HANDLE_CUDA_ERROR(cudaFree(d_gateCX));
+  HANDLE_CUDA_ERROR(cudaFree(d_gateH));
+  std::cout << "Freed memory on GPU\n";
+
+  // Finalize the cuTensorNet library
+  HANDLE_CUTN_ERROR(cutensornetDestroy(cutnHandle));
+  std::cout << "Finalized the cuTensorNet library\n";
+
+  return 0;
+}
diff --git a/samples/cutensornet/high_level/sampling_example.cu b/samples/cutensornet/high_level/sampling_example.cu
new file mode 100644
index 0000000..b9b96bb
--- /dev/null
+++ b/samples/cutensornet/high_level/sampling_example.cu
@@ -0,0 +1,184 @@
+/* Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */  
+
+// Sphinx: Sampler #1
+
+#include <cstdlib>
+#include <cstdio>
+#include <cassert>
+#include <complex>
+#include <vector>
+#include <iostream>
+
+#include <cuda_runtime.h>
+#include <cutensornet.h>
+
+#define HANDLE_CUDA_ERROR(x) \
+{ const auto err = x; \
+  if( err != cudaSuccess ) \
+  { printf("CUDA error %s in line %d\n", cudaGetErrorString(err), __LINE__); fflush(stdout); std::abort(); } \
+};
+
+#define HANDLE_CUTN_ERROR(x) \
+{ const auto err = x; \
+  if( err != CUTENSORNET_STATUS_SUCCESS ) \
+  { printf("cuTensorNet error %s in line %d\n", cutensornetGetErrorString(err), __LINE__); fflush(stdout); std::abort(); } \
+};
+
+
+int main(int argc, char **argv)
+{
+  constexpr std::size_t fp64size = sizeof(double);
+
+  // Sphinx: Sampler #2
+
+  // Quantum state configuration
+  const int64_t numSamples = 100;
+  const int32_t numQubits = 16;
+  const std::vector<int64_t> qubitDims(numQubits, 2); // qubit size
+  std::cout << "Quantum circuit: " << numQubits << " qubits; " << numSamples << " samples\n";
+
+  // Sphinx: Sampler #3
+
+  // Initialize the cuTensorNet library
+  HANDLE_CUDA_ERROR(cudaSetDevice(0));
+  cutensornetHandle_t cutnHandle;
+  HANDLE_CUTN_ERROR(cutensornetCreate(&cutnHandle));
+  std::cout << "Initialized cuTensorNet library on GPU 0\n";
+
+  // Sphinx: Sampler #4
+
+  // Define necessary quantum gate tensors in Host memory
+  const double invsq2 = 1.0 / std::sqrt(2.0);
+  //  Hadamard gate
+  const std::vector<std::complex<double>> h_gateH {{invsq2, 0.0},  {invsq2, 0.0},
+                                                   {invsq2, 0.0}, {-invsq2, 0.0}};
+  //  CX gate
+  const std::vector<std::complex<double>> h_gateCX {{1.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0},
+                                                    {0.0, 0.0}, {1.0, 0.0}, {0.0, 0.0}, {0.0, 0.0},
+                                                    {0.0, 0.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}};
+
+  // Copy quantum gates to Device memory
+  void *d_gateH{nullptr}, *d_gateCX{nullptr};
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_gateH, 4 * (2 * fp64size)));
+  std::cout << "H gate buffer allocated on GPU: " << d_gateH << std::endl; //debug
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_gateCX, 16 * (2 * fp64size)));
+  std::cout << "CX gate buffer allocated on GPU: " << d_gateCX << std::endl; //debug
+  std::cout << "Allocated quantum gate memory on GPU\n";
+  HANDLE_CUDA_ERROR(cudaMemcpy(d_gateH, h_gateH.data(), 4 * (2 * fp64size), cudaMemcpyHostToDevice));
+  HANDLE_CUDA_ERROR(cudaMemcpy(d_gateCX, h_gateCX.data(), 16 * (2 * fp64size), cudaMemcpyHostToDevice));
+  std::cout << "Copied quantum gates to GPU memory\n";
+
+  // Sphinx: Sampler #5
+
+  // Create the initial quantum state
+  cutensornetState_t quantumState;
+  HANDLE_CUTN_ERROR(cutensornetCreateState(cutnHandle, CUTENSORNET_STATE_PURITY_PURE, numQubits, qubitDims.data(),
+                    CUDA_C_64F, &quantumState));
+  std::cout << "Created the initial quantum state\n";
+
+  // Sphinx: Sampler #6
+
+  // Construct the quantum circuit state (apply quantum gates)
+  int64_t id;
+  HANDLE_CUTN_ERROR(cutensornetStateApplyTensor(cutnHandle, quantumState, 1, std::vector<int32_t>{{0}}.data(),
+                    d_gateH, nullptr, 1, 0, 1, &id));
+  for(int32_t i = 1; i < numQubits; ++i) {
+    HANDLE_CUTN_ERROR(cutensornetStateApplyTensor(cutnHandle, quantumState, 2, std::vector<int32_t>{{i-1,i}}.data(),
+                      d_gateCX, nullptr, 1, 0, 1, &id));
+  }
+  std::cout << "Applied quantum gates\n";
+
+  // Sphinx: Sampler #7
+
+  // Create the quantum circuit sampler
+  cutensornetStateSampler_t sampler;
+  HANDLE_CUTN_ERROR(cutensornetCreateSampler(cutnHandle, quantumState, numQubits, nullptr, &sampler));
+  std::cout << "Created the quantum circuit sampler\n";
+
+  // Sphinx: Sampler #8
+
+  // Query the free memory on Device
+  std::size_t freeSize {0}, totalSize {0};
+  HANDLE_CUDA_ERROR(cudaMemGetInfo(&freeSize, &totalSize));
+  const std::size_t scratchSize = (freeSize - (freeSize % 4096)) / 2; // use half of available memory with alignment
+  void *d_scratch {nullptr};
+  HANDLE_CUDA_ERROR(cudaMalloc(&d_scratch, scratchSize));
+  std::cout << "Allocated " << scratchSize << " bytes of scratch memory on GPU: "
+            << "[" << d_scratch << ":" << (void*)(((char*)(d_scratch))  + scratchSize) << ")\n";
+
+  // Sphinx: Sampler #9
+
+  // Configure the quantum circuit sampler
+  const int32_t numHyperSamples = 8; // desired number of hyper samples used in the tensor network contraction path finder
+  HANDLE_CUTN_ERROR(cutensornetSamplerConfigure(cutnHandle, sampler,
+                    CUTENSORNET_SAMPLER_OPT_NUM_HYPER_SAMPLES, &numHyperSamples, sizeof(numHyperSamples)));
+
+  // Sphinx: Sampler #10
+
+  // Prepare the quantum circuit sampler
+  cutensornetWorkspaceDescriptor_t workDesc;
+  HANDLE_CUTN_ERROR(cutensornetCreateWorkspaceDescriptor(cutnHandle, &workDesc));
+  HANDLE_CUTN_ERROR(cutensornetSamplerPrepare(cutnHandle, sampler, scratchSize, workDesc, 0x0));
+  std::cout << "Prepared the quantum circuit state sampler\n";
+
+  // Sphinx: Sampler #11
+
+  // Attach the workspace buffer
+  int64_t worksize {0};
+  HANDLE_CUTN_ERROR(cutensornetWorkspaceGetMemorySize(cutnHandle,
+                                                      workDesc,
+                                                      CUTENSORNET_WORKSIZE_PREF_RECOMMENDED,
+                                                      CUTENSORNET_MEMSPACE_DEVICE,
+                                                      CUTENSORNET_WORKSPACE_SCRATCH,
+                                                      &worksize));
+  assert(worksize > 0);
+  if(worksize <= scratchSize) {
+    HANDLE_CUTN_ERROR(cutensornetWorkspaceSetMemory(cutnHandle, workDesc, CUTENSORNET_MEMSPACE_DEVICE,
+                      CUTENSORNET_WORKSPACE_SCRATCH, d_scratch, worksize));
+  }else{
+    std::cout << "ERROR: Insufficient workspace size on Device!\n";
+    std::abort();
+  }
+  std::cout << "Set the workspace buffer\n";
+
+  // Sphinx: Sampler #12
+
+  // Sample the quantum circuit state
+  std::vector<int64_t> samples(numQubits * numSamples); // samples[SampleId][QubitId] reside in Host memory
+  HANDLE_CUTN_ERROR(cutensornetSamplerSample(cutnHandle, sampler, numSamples, workDesc, samples.data(), 0));
+  std::cout << "Performed quantum circuit state sampling\n";
+  std::cout << "Bit-string samples:\n";
+  for(int64_t i = 0; i < numSamples; ++i) {
+    for(int64_t j = 0; j < numQubits; ++j) std::cout << " " << samples[i * numQubits + j];
+    std::cout << std::endl;
+  }
+
+  // Sphinx: Sampler #13
+
+  // Destroy the workspace descriptor
+  HANDLE_CUTN_ERROR(cutensornetDestroyWorkspaceDescriptor(workDesc));
+  std::cout << "Destroyed the workspace descriptor\n";
+
+  // Destroy the quantum circuit sampler
+  HANDLE_CUTN_ERROR(cutensornetDestroySampler(sampler));
+  std::cout << "Destroyed the quantum circuit state sampler\n";
+
+  // Destroy the quantum circuit state
+  HANDLE_CUTN_ERROR(cutensornetDestroyState(quantumState));
+  std::cout << "Destroyed the quantum circuit state\n";
+
+  HANDLE_CUDA_ERROR(cudaFree(d_scratch));
+  HANDLE_CUDA_ERROR(cudaFree(d_gateCX));
+  HANDLE_CUDA_ERROR(cudaFree(d_gateH));
+  std::cout << "Freed memory on GPU\n";
+
+  // Finalize the cuTensorNet library
+  HANDLE_CUTN_ERROR(cutensornetDestroy(cutnHandle));
+  std::cout << "Finalized the cuTensorNet library\n";
+
+  return 0;
+}
diff --git a/samples/cutensornet/tensornet_example.cu b/samples/cutensornet/tensornet_example.cu
index 7637fa3..9ef785c 100644
--- a/samples/cutensornet/tensornet_example.cu
+++ b/samples/cutensornet/tensornet_example.cu
@@ -418,7 +418,7 @@ int main()
                      R_d,
                      accumulateOutput,
                      workDesc,
-                     sliceGroup, // slternatively, NULL can also be used to contract over all slices instead of specifying a sliceGroup object
+                     sliceGroup, // alternatively, NULL can also be used to contract over all slices instead of specifying a sliceGroup object
                      stream) );
 
       // Synchronize and measure best timing
diff --git a/samples/cutensornet/tensornet_example_gradients.cu b/samples/cutensornet/tensornet_example_gradients.cu
new file mode 100644
index 0000000..0bc5511
--- /dev/null
+++ b/samples/cutensornet/tensornet_example_gradients.cu
@@ -0,0 +1,540 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Sphinx: #1
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <unordered_map>
+#include <vector>
+#include <cassert>
+
+#include <cuda_runtime.h>
+#include <cutensornet.h>
+
+
+#define HANDLE_ERROR(x)                                           \
+{ const auto err = x;                                             \
+  if( err != CUTENSORNET_STATUS_SUCCESS )                         \
+  { printf("Error: %s in line %d\n", cutensornetGetErrorString(err), __LINE__); \
+    fflush(stdout);                                               \
+  }                                                               \
+};
+
+#define HANDLE_CUDA_ERROR(x)                                      \
+{ const auto err = x;                                             \
+  if( err != cudaSuccess )                                        \
+  { printf("CUDA Error: %s in line %d\n", cudaGetErrorString(err), __LINE__); \
+    fflush(stdout);                                               \
+  }                                                               \
+};
+
+
+struct GPUTimer
+{
+   GPUTimer(cudaStream_t stream): stream_(stream)
+   {
+      cudaEventCreate(&start_);
+      cudaEventCreate(&stop_);
+   }
+
+   ~GPUTimer()
+   {
+      cudaEventDestroy(start_);
+      cudaEventDestroy(stop_);
+   }
+
+   void start()
+   {
+      cudaEventRecord(start_, stream_);
+   }
+
+   float seconds()
+   {
+      cudaEventRecord(stop_, stream_);
+      cudaEventSynchronize(stop_);
+      float time;
+      cudaEventElapsedTime(&time, start_, stop_);
+      return time * 1e-3;
+   }
+
+   private:
+   cudaEvent_t start_, stop_;
+   cudaStream_t stream_;
+};
+
+
+int main()
+{
+    static_assert(sizeof(size_t) == sizeof(int64_t), "Please build this sample on a 64-bit architecture!");
+
+    bool verbose = true;
+
+    // Check cuTensorNet version
+    const size_t cuTensornetVersion = cutensornetGetVersion();
+    if(verbose)
+        printf("cuTensorNet version: %ld\n", cuTensornetVersion);
+
+    // Set GPU device
+    int numDevices {0};
+    HANDLE_CUDA_ERROR( cudaGetDeviceCount(&numDevices) );
+    const int deviceId = 0;
+    HANDLE_CUDA_ERROR( cudaSetDevice(deviceId) );
+    cudaDeviceProp prop;
+    HANDLE_CUDA_ERROR( cudaGetDeviceProperties(&prop, deviceId) );
+
+    if(verbose) {
+        printf("===== device info ======\n");
+        printf("GPU-name:%s\n", prop.name);
+        printf("GPU-clock:%d\n", prop.clockRate);
+        printf("GPU-memoryClock:%d\n", prop.memoryClockRate);
+        printf("GPU-nSM:%d\n", prop.multiProcessorCount);
+        printf("GPU-major:%d\n", prop.major);
+        printf("GPU-minor:%d\n", prop.minor);
+        printf("========================\n");
+    }
+
+    typedef float floatType;
+    cudaDataType_t typeData = CUDA_R_32F;
+    cutensornetComputeType_t typeCompute = CUTENSORNET_COMPUTE_32F;
+
+    if(verbose)
+        printf("Included headers and defined data types\n");
+
+    // Sphinx: #2
+    /**********************
+    * Computing: O_{a,m} = A_{a,b,c,d} B_{b,c,d,e} C_{e,g,h} D_{g,h,i,j} E_{i,j,k,l} F_{k,l,m}
+    * We will execute the contraction and compute the gradients of input tensors A, B, C
+    **********************/
+
+    constexpr int32_t numInputs = 6;
+    std::vector<int32_t> gradInputIDs = {0, 1, 2};
+
+    // Create vectors of tensor modes
+    std::vector<std::vector<int32_t>> modesVec {
+        {'a','b','c','d'},
+        {'b','c','d','e'},
+        {'e','g','h'},
+        {'g','h','i','j'},
+        {'i','j','k','l'},
+        {'k','l','m'},
+        {'a','m'}
+    };
+
+    // Set mode extents
+    int64_t sameExtent = 36; // setting same extent for simplicity. In principle extents can differ.
+    std::unordered_map<int32_t, int64_t> extent;
+    for (auto &vec: modesVec)
+    {
+        for (auto &mode: vec)
+        {
+            extent[mode] = sameExtent;
+        }
+    }
+
+    // Create a vector of extents for each tensor
+    std::vector<std::vector<int64_t>> extentVec;
+    extentVec.resize(numInputs+1); // hold inputs + output tensors
+    for (int i = 0; i < numInputs+1; ++i)
+    {
+        for (auto mode : modesVec[i])
+            extentVec[i].push_back(extent[mode]);
+    }
+
+    if(verbose)
+        printf("Defined tensor network, modes, and extents\n");
+
+    // Sphinx: #3
+    /**********************
+    * Allocating data
+    **********************/
+
+    std::vector<size_t> elementsVec;
+    elementsVec.resize(numInputs+1); // hold inputs + output tensors
+    for (int i = 0; i < numInputs+1; ++i)
+    {
+        elementsVec[i] = 1;
+        for (auto mode : modesVec[i])
+            elementsVec[i] *= extent[mode];
+    }
+
+    size_t totalSize = 0;
+    std::vector<size_t> sizeVec;
+    sizeVec.resize(numInputs+1); // hold inputs + output tensors
+    for (int i = 0; i < numInputs+1; ++i)
+    {
+        sizeVec[i] = sizeof(floatType) * elementsVec[i];
+        totalSize += sizeVec[i];
+    }
+    if(verbose)
+        printf("Total GPU memory used for tensor storage: %.2f GiB\n",
+                (totalSize) / 1024. /1024. / 1024);
+
+    void* rawDataIn_d[numInputs];
+    void* O_d;
+    void* outputActivation_d;
+    for (int i = 0; i < numInputs; ++i)
+    {
+        HANDLE_CUDA_ERROR( cudaMalloc((void**) &rawDataIn_d[i], sizeVec[i]) );
+    }
+    HANDLE_CUDA_ERROR( cudaMalloc((void**) &O_d, sizeVec[numInputs]));
+    HANDLE_CUDA_ERROR( cudaMalloc((void**) &outputActivation_d, sizeVec[numInputs]));
+
+    floatType* rawDataIn_h[numInputs];
+    for (int i = 0; i < numInputs; ++i)
+    {
+        rawDataIn_h[i] = (floatType*) malloc(sizeVec[i]);
+        if (rawDataIn_h[i] == NULL)
+        {
+           printf("Error: Host memory allocation failed!\n");
+           return -1;
+        }
+    }
+    floatType *O_h = (floatType*) malloc(sizeof(floatType) * elementsVec[numInputs]);
+    if (O_h == NULL)
+    {
+        printf("Error: Host memory allocation failed!\n");
+        return -1;
+    }
+    floatType *outputActivation_h = (floatType*) malloc(sizeof(floatType) * elementsVec[numInputs]);
+    if (outputActivation_h == NULL)
+    {
+        printf("Error: Host memory allocation failed!\n");
+        return -1;
+    }
+
+    void* gradientsOut_d[numInputs] = {nullptr};
+    for (auto i : gradInputIDs)
+    {
+        HANDLE_CUDA_ERROR( cudaMalloc((void**) &gradientsOut_d[i], sizeVec[i]) );
+    }
+    void* gradientsOut_h[numInputs] = {nullptr};
+    for (auto i : gradInputIDs)
+    {
+        gradientsOut_h[i] = (floatType*) malloc(sizeVec[i]);
+        if (gradientsOut_h[i] == NULL)
+        {
+           printf("Error: Host memory allocation failed!\n");
+           return -1;
+        }
+    }
+
+    /*******************
+    * Initialize data
+    *******************/
+
+    memset(O_h, 0, sizeof(floatType) * elementsVec[numInputs]);
+    for (int i = 0; i < numInputs; ++i)
+    {
+        for (size_t e = 0; e < elementsVec[i]; ++e)
+            rawDataIn_h[i][e] = ((floatType) rand()) / RAND_MAX;
+    }
+    for (size_t e = 0; e < elementsVec[numInputs]; ++e)
+        outputActivation_h[e] = (floatType) 1.0;
+
+    for (int i = 0; i < numInputs; ++i)
+    {
+        HANDLE_CUDA_ERROR( cudaMemcpy(rawDataIn_d[i], rawDataIn_h[i], sizeVec[i], cudaMemcpyHostToDevice) );
+    }
+    HANDLE_CUDA_ERROR( cudaMemcpy(outputActivation_d, outputActivation_h, sizeVec[numInputs], cudaMemcpyHostToDevice) );
+
+    if(verbose)
+        printf("Allocated GPU memory for data, initialize data, and create library handle\n");
+
+    /*************************
+    * cuTensorNet
+    *************************/
+
+    cudaStream_t stream;
+    cudaStreamCreate(&stream);
+
+    cutensornetHandle_t handle;
+    HANDLE_ERROR( cutensornetCreate(&handle) );
+
+    // Sphinx: #4
+    /*******************************
+    * Create Network Descriptor
+    *******************************/
+
+    int32_t* modesIn[numInputs];
+    int32_t numModesIn[numInputs];
+    int64_t* extentsIn[numInputs];
+    int64_t* stridesIn[numInputs];
+    
+    for (int i = 0; i < numInputs; ++i)
+    {
+        modesIn[i] = modesVec[i].data();
+        numModesIn[i] = modesVec[i].size();
+        extentsIn[i] = extentVec[i].data();
+        stridesIn[i] = NULL; // strides are optional; if no stride is provided, cuTensorNet assumes a generalized column-major data layout
+    }
+
+    // Set up tensor network
+    cutensornetNetworkDescriptor_t descNet;
+    HANDLE_ERROR( cutensornetCreateNetworkDescriptor(handle,
+                        numInputs, numModesIn, extentsIn, stridesIn, modesIn, NULL,
+                        modesVec[numInputs].size(), extentVec[numInputs].data(), /*stridesOut = */NULL, modesVec[numInputs].data(),
+                        typeData, typeCompute,
+                        &descNet) );
+
+    /*******************************
+    * Set input tensor ids that requrie gradient
+    *******************************/
+
+    cutensornetTensorIDList_t tensorIDList {
+        .numTensors = static_cast<int32_t>(gradInputIDs.size()),
+        .data = gradInputIDs.data()
+    };
+
+    HANDLE_ERROR(cutensornetNetworkSetAttribute(handle,
+                                                descNet,
+                                                CUTENSORNET_NETWORK_INPUT_TENSORS_REQUIRE_GRAD,
+                                                &tensorIDList,
+                                                sizeof(cutensornetTensorIDList_t)));
+
+    if(verbose)
+        printf("Initialized the cuTensorNet library and created a tensor network descriptor\n");
+
+    // Sphinx: #5
+    /*******************************
+    * Choose workspace limit based on available resources.
+    *******************************/
+
+    size_t freeMem, totalMem;
+    HANDLE_CUDA_ERROR( cudaMemGetInfo(&freeMem, &totalMem) );
+    uint64_t workspaceLimit = (uint64_t)((double)freeMem * 0.9);
+    if(verbose)
+        printf("Workspace limit = %lu\n", workspaceLimit);
+
+    /*******************************
+    * Set contraction order
+    *******************************/
+
+    // Create contraction optimizer info
+    cutensornetContractionOptimizerInfo_t optimizerInfo;
+    HANDLE_ERROR( cutensornetCreateContractionOptimizerInfo(handle, descNet, &optimizerInfo) );
+
+    // set a predetermined contraction path
+    std::vector<int32_t> path{0,1,0,4,0,3,0,2,0,1};
+    const auto numContractions = numInputs - 1;
+    cutensornetContractionPath_t contPath;
+    contPath.data = reinterpret_cast<cutensornetNodePair_t*>(const_cast<int32_t*>(path.data()));
+    contPath.numContractions = numContractions;
+
+    // provide user-specified contPath
+    HANDLE_ERROR( cutensornetContractionOptimizerInfoSetAttribute(
+                    handle,
+                    optimizerInfo,
+                    CUTENSORNET_CONTRACTION_OPTIMIZER_INFO_PATH,
+                    &contPath,
+                    sizeof(contPath)));
+    int64_t numSlices = 1;
+
+    if(verbose)
+        printf("Set predetermined contraction path into cuTensorNet optimizer\n");
+
+    // Sphinx: #6
+    /*******************************
+    * Create workspace descriptor, allocate workspace, and set it.
+    *******************************/
+
+    cutensornetWorkspaceDescriptor_t workDesc;
+    HANDLE_ERROR( cutensornetCreateWorkspaceDescriptor(handle, &workDesc) );
+
+    // set SCRATCH workspace, which will be used during each network contraction operation, not needed afterwords
+    int64_t requiredWorkspaceSizeScratch = 0;
+    HANDLE_ERROR( cutensornetWorkspaceComputeContractionSizes(handle,
+                                                            descNet,
+                                                            optimizerInfo,
+                                                            workDesc) );
+
+    HANDLE_ERROR( cutensornetWorkspaceGetMemorySize(handle,
+                                                    workDesc,
+                                                    CUTENSORNET_WORKSIZE_PREF_MIN,
+                                                    CUTENSORNET_MEMSPACE_DEVICE,
+                                                    CUTENSORNET_WORKSPACE_SCRATCH,
+                                                    &requiredWorkspaceSizeScratch) );
+
+    void* workScratch = nullptr;
+    HANDLE_CUDA_ERROR( cudaMalloc(&workScratch, requiredWorkspaceSizeScratch) );
+
+    HANDLE_ERROR( cutensornetWorkspaceSetMemory(handle,
+                                                workDesc,
+                                                CUTENSORNET_MEMSPACE_DEVICE,
+                                                CUTENSORNET_WORKSPACE_SCRATCH,
+                                                workScratch,
+                                                requiredWorkspaceSizeScratch) );
+
+    // set CACHE workspace, which will be used across network contraction operations
+    int64_t requiredWorkspaceSizeCache = 0;
+    HANDLE_ERROR( cutensornetWorkspaceGetMemorySize(handle,
+                                                    workDesc,
+                                                    CUTENSORNET_WORKSIZE_PREF_MIN,
+                                                    CUTENSORNET_MEMSPACE_DEVICE,
+                                                    CUTENSORNET_WORKSPACE_CACHE,
+                                                    &requiredWorkspaceSizeCache) );
+
+    void* workCache = nullptr;
+    HANDLE_CUDA_ERROR( cudaMalloc(&workCache, requiredWorkspaceSizeCache) );
+
+    HANDLE_ERROR( cutensornetWorkspaceSetMemory(handle,
+                                                workDesc,
+                                                CUTENSORNET_MEMSPACE_DEVICE,
+                                                CUTENSORNET_WORKSPACE_CACHE,
+                                                workCache,
+                                                requiredWorkspaceSizeCache) );
+
+    if(verbose)
+        printf("Allocated and set up the GPU workspace\n");
+
+    // Sphinx: #7
+    /*******************************
+    * Initialize the pairwise contraction plan (for cuTENSOR).
+    *******************************/
+
+    cutensornetContractionPlan_t plan;
+    HANDLE_ERROR( cutensornetCreateContractionPlan(handle,
+                                                    descNet,
+                                                    optimizerInfo,
+                                                    workDesc,
+                                                    &plan) );
+
+    /*******************************
+    * Optional: Auto-tune cuTENSOR's cutensorContractionPlan to pick the fastest kernel
+    *           for each pairwise tensor contraction.
+    *******************************/
+    cutensornetContractionAutotunePreference_t autotunePref;
+    HANDLE_ERROR( cutensornetCreateContractionAutotunePreference(handle,
+                                                        &autotunePref) );
+
+    const int numAutotuningIterations = 5; // may be 0
+    HANDLE_ERROR( cutensornetContractionAutotunePreferenceSetAttribute(
+                            handle,
+                            autotunePref,
+                            CUTENSORNET_CONTRACTION_AUTOTUNE_MAX_ITERATIONS,
+                            &numAutotuningIterations,
+                            sizeof(numAutotuningIterations)) );
+
+    // Modify the plan again to find the best pair-wise contractions
+    HANDLE_ERROR( cutensornetContractionAutotune(handle,
+                                                    plan,
+                                                    rawDataIn_d,
+                                                    O_d,
+                                                    workDesc,
+                                                    autotunePref,
+                                                    stream) );
+
+    HANDLE_ERROR( cutensornetDestroyContractionAutotunePreference(autotunePref) );
+
+    if(verbose)
+        printf("Created a contraction plan for cuTensorNet and optionally auto-tuned it\n");
+
+    // Sphinx: #8
+    /**********************
+    * Execute the tensor network contraction
+    **********************/
+
+   // Create a cutensornetSliceGroup_t object from a range of slice IDs
+   cutensornetSliceGroup_t sliceGroup{};
+   HANDLE_ERROR( cutensornetCreateSliceGroupFromIDRange(handle, 0, numSlices, 1, &sliceGroup) );
+
+    GPUTimer timer {stream};
+    double minTimeCUTENSORNET = 1e100;
+    const int numRuns = 3; // number of repeats to get stable performance results
+    for (int i = 0; i < numRuns; ++i)
+    {
+        HANDLE_CUDA_ERROR( cudaMemcpy(O_d, O_h, sizeVec[numInputs], cudaMemcpyHostToDevice) ); // restore the output tensor on GPU
+        HANDLE_CUDA_ERROR( cudaDeviceSynchronize() );
+
+        /*
+        * Contract all slices of the tensor network
+        */
+        timer.start();
+
+        int32_t accumulateOutput = 0; // output tensor data will be overwritten
+        HANDLE_ERROR( cutensornetContractSlices(handle,
+                       plan,
+                       rawDataIn_d,
+                       O_d,
+                       accumulateOutput,
+                       workDesc,
+                       sliceGroup, // alternatively, NULL can also be used to contract over all slices instead of specifying a sliceGroup object
+                       stream) );
+
+        HANDLE_ERROR( cutensornetComputeGradientsBackward(handle,
+                        plan,
+                        rawDataIn_d,
+                        outputActivation_d, 
+                        gradientsOut_d,
+                        accumulateOutput,
+                        workDesc,
+                        stream) );
+
+        // Purge the cache to make room for the next run to use cache memory
+        HANDLE_ERROR( cutensornetWorkspacePurgeCache(handle, workDesc, CUTENSORNET_MEMSPACE_DEVICE) );
+
+        // Synchronize and measure best timing
+        auto time = timer.seconds();
+        minTimeCUTENSORNET = (time > minTimeCUTENSORNET) ? minTimeCUTENSORNET : time;
+    }
+
+    if(verbose)
+        printf("Contracted the tensor network and computed gradients\n");
+
+    HANDLE_CUDA_ERROR( cudaMemcpy(O_h, O_d, sizeVec[numInputs], cudaMemcpyDeviceToHost) ); // restore the output tensor on Host
+    
+    for (auto i : gradInputIDs)
+    {
+        HANDLE_CUDA_ERROR( cudaMemcpy(gradientsOut_h[i], gradientsOut_d[i], sizeVec[i], cudaMemcpyDeviceToHost) );
+    }
+
+    /*************************/
+
+    if(verbose) {
+        printf("Tensor network contraction and back-propagation time (ms): = %.3f\n", minTimeCUTENSORNET * 1000.f);
+    }
+
+    // Sphinx: #9
+    /***************
+    * Free resources
+    ****************/
+
+    // Free cuTensorNet resources
+    HANDLE_ERROR( cutensornetDestroySliceGroup(sliceGroup) );
+    HANDLE_ERROR( cutensornetDestroyContractionPlan(plan) );
+    HANDLE_ERROR( cutensornetDestroyWorkspaceDescriptor(workDesc) );
+    HANDLE_ERROR( cutensornetDestroyContractionOptimizerInfo(optimizerInfo) );
+    HANDLE_ERROR( cutensornetDestroyNetworkDescriptor(descNet) );
+    HANDLE_ERROR( cutensornetDestroy(handle) );
+
+    // Free Host memory resources
+    if (O_h) free(O_h);
+    if (outputActivation_h) free(outputActivation_h);
+    for (int i = 0; i < numInputs; ++i)
+    {
+        if (rawDataIn_h[i]) 
+            free(rawDataIn_h[i]);
+        if (gradientsOut_h[i]) 
+            free(gradientsOut_h[i]);
+    }
+    // Free GPU memory resources
+    if (workScratch) cudaFree(workScratch);
+    if (workCache) cudaFree(workCache);
+    if (O_d) cudaFree(O_d);
+    if (outputActivation_d) cudaFree(outputActivation_d);
+    for (int i = 0; i < numInputs; ++i)
+    {
+        if (rawDataIn_d[i]) 
+            cudaFree(rawDataIn_d[i]);
+        if (gradientsOut_d[i]) 
+            cudaFree(gradientsOut_d[i]);
+    }
+    if(verbose)
+        printf("Freed resources and exited\n");
+
+    return 0;
+}

From fbe0291672c51ee80b901b3ca14860878c7c9e46 Mon Sep 17 00:00:00 2001
From: Leo Fang <leof@nvidia.com>
Date: Wed, 12 Jul 2023 17:46:48 -0700
Subject: [PATCH 2/3] update hard-coded urls to new format

---
 benchmarks/README.md          | 2 +-
 extra/custatevec/README.md    | 4 ++--
 python/README.md              | 2 +-
 samples/cutensornet/README.md | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/benchmarks/README.md b/benchmarks/README.md
index 61c3d0e..4ff9780 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -12,7 +12,7 @@ You can install all optional dependencies via
 ```
 pip install .[all]
 ```
-if running outside of the [cuQuantum Appliance container](https://docs.nvidia.com/cuda/cuquantum/appliance/index.html).
+if running outside of the [cuQuantum Appliance container](https://docs.nvidia.com/cuda/cuquantum/latest/appliance/index.html).
 
 **Note: You may have to build `qsimcirq` and `qiskit-aer` GPU support from source if needed.**
 
diff --git a/extra/custatevec/README.md b/extra/custatevec/README.md
index 420bb2e..b3c8bca 100644
--- a/extra/custatevec/README.md
+++ b/extra/custatevec/README.md
@@ -1,6 +1,6 @@
 ## MPI Comm Plugin Extension
 
-The first version of [multi-node state vector simulator](https://docs.nvidia.com/cuda/cuquantum/appliance/qiskit.html) has been released in cuQuantum Appliance 22.11.  It currently supports a limited set of versions of OpenMPI and MPICH.  Other MPI libraries are supported by using an extension module called as External CommPlugin.
+The first version of [multi-node state vector simulator](https://docs.nvidia.com/cuda/cuquantum/latest/appliance/qiskit.html) has been released in cuQuantum Appliance 22.11.  It currently supports a limited set of versions of OpenMPI and MPICH.  Other MPI libraries are supported by using an extension module called as External CommPlugin.
 External CommPlugin is a small shared object that wraps MPI functions.  A customer needs to build its own external CommPlugin and link it to the MPI library of its preference to create a shared object.  Then, by specifying appropriate options to the simulator, the compiled shared object is dynamically loaded to use the MPI library for inter-process communications.
 
 ## Prerequisite
@@ -25,7 +25,7 @@ $ ls -l
 
 ## Simulator options
 
-The custom Comm Plugin object is selected by [cusvaer options](https://docs.nvidia.com/cuda/cuquantum/appliance/cusvaer.html#commplugin), `cusvaer_comm_plugin_type` and `cusvaer_comm_plugin_soname`.
+The custom Comm Plugin object is selected by [cusvaer options](https://docs.nvidia.com/cuda/cuquantum/latest/appliance/cusvaer.html#commplugin), `cusvaer_comm_plugin_type` and `cusvaer_comm_plugin_soname`.
 
 - `cusvaer_comm_plugin_type`: The value is `cusvaer.CommPluginType.EXTERNAL`
 - `cusvaer_comm_plugin_soname`  The name of the shared object of an external comm plugin
diff --git a/python/README.md b/python/README.md
index b40cadf..aeead2c 100644
--- a/python/README.md
+++ b/python/README.md
@@ -2,7 +2,7 @@
 
 ## Documentation
 
-Please visit the [NVIDIA cuQuantum Python documentation](https://docs.nvidia.com/cuda/cuquantum/python).
+Please visit the [NVIDIA cuQuantum Python documentation](https://docs.nvidia.com/cuda/cuquantum/latest/python).
 
 
 ## Installation
diff --git a/samples/cutensornet/README.md b/samples/cutensornet/README.md
index b618a00..d6b1945 100644
--- a/samples/cutensornet/README.md
+++ b/samples/cutensornet/README.md
@@ -1,6 +1,6 @@
 # cuTensorNet - Samples
 
-* [Documentation](https://docs.nvidia.com/cuda/cuquantum/cutensornet/index.html)
+* [Documentation](https://docs.nvidia.com/cuda/cuquantum/latest/cutensornet/index.html)
 
 ## Install
 
@@ -54,7 +54,7 @@ The sample for tensor QR, gate split and MPS can also be executed in the same fa
 ```
 export LD_LIBRARY_PATH=$CUDA_PATH/lib64:$CUTENSOR_ROOT/lib/11:$LD_LIBRARY_PATH
 ```
-The cuTENSOR library path would depend on the CUDA major version. Please refer to the [Getting Started](https://docs.nvidia.com/cuda/cuquantum/cutensornet/getting_started.html) page for further detail.
+The cuTENSOR library path would depend on the CUDA major version. Please refer to the [Getting Started](https://docs.nvidia.com/cuda/cuquantum/latest/cutensornet/getting_started.html) page for further detail.
 
 ## Support
 

From de5658f0a3f6f3ade02b57f48662b5ae6a2eddbe Mon Sep 17 00:00:00 2001
From: Leo Fang <leof@nvidia.com>
Date: Thu, 13 Jul 2023 09:42:36 -0700
Subject: [PATCH 3/3] sync with internal repo1 (commit 8963e92db)

---
 extra/custatevec/README.md                                    | 2 +-
 python/samples/custatevec/batched_abs2sum.py                  | 2 +-
 python/samples/custatevec/batched_collapse.py                 | 2 +-
 python/samples/custatevec/batched_gate_application.py         | 2 +-
 python/samples/custatevec/batched_measure.py                  | 2 +-
 python/samples/custatevec/initialize_sv.py                    | 2 +-
 python/setup.py                                               | 2 +-
 .../tests/cuquantum_tests/cutensornet_tests/test_internal.py  | 4 ++++
 samples/custatevec/batched_abs2sum.cu                         | 4 ++--
 samples/custatevec/batched_collapse.cu                        | 2 +-
 samples/custatevec/batched_gate_application.cu                | 4 ++--
 samples/custatevec/batched_measure.cu                         | 4 ++--
 samples/custatevec/initialize_sv.cu                           | 2 +-
 samples/cutensornet/high_level/marginal_example.cu            | 2 +-
 samples/cutensornet/high_level/sampling_example.cu            | 2 +-
 15 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/extra/custatevec/README.md b/extra/custatevec/README.md
index b3c8bca..75227f2 100644
--- a/extra/custatevec/README.md
+++ b/extra/custatevec/README.md
@@ -1,6 +1,6 @@
 ## MPI Comm Plugin Extension
 
-The first version of [multi-node state vector simulator](https://docs.nvidia.com/cuda/cuquantum/latest/appliance/qiskit.html) has been released in cuQuantum Appliance 22.11.  It currently supports a limited set of versions of OpenMPI and MPICH.  Other MPI libraries are supported by using an extension module called as External CommPlugin.
+The first version of [multi-node state vector simulator](https://docs.nvidia.com/cuda/cuquantum/latest/appliance/qiskit.html) has been released in cuQuantum Appliance 22.11.  It currently supports a limited set of versions of Open MPI and MPICH.  Other MPI libraries are supported by using an extension module (called External CommPlugin).
 External CommPlugin is a small shared object that wraps MPI functions.  A customer needs to build its own external CommPlugin and link it to the MPI library of its preference to create a shared object.  Then, by specifying appropriate options to the simulator, the compiled shared object is dynamically loaded to use the MPI library for inter-process communications.
 
 ## Prerequisite
diff --git a/python/samples/custatevec/batched_abs2sum.py b/python/samples/custatevec/batched_abs2sum.py
index 343911e..302881f 100644
--- a/python/samples/custatevec/batched_abs2sum.py
+++ b/python/samples/custatevec/batched_abs2sum.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/python/samples/custatevec/batched_collapse.py b/python/samples/custatevec/batched_collapse.py
index b33fc18..7972597 100644
--- a/python/samples/custatevec/batched_collapse.py
+++ b/python/samples/custatevec/batched_collapse.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/python/samples/custatevec/batched_gate_application.py b/python/samples/custatevec/batched_gate_application.py
index 37cf6bf..de3d0e7 100644
--- a/python/samples/custatevec/batched_gate_application.py
+++ b/python/samples/custatevec/batched_gate_application.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/python/samples/custatevec/batched_measure.py b/python/samples/custatevec/batched_measure.py
index 138a4bd..68180d4 100644
--- a/python/samples/custatevec/batched_measure.py
+++ b/python/samples/custatevec/batched_measure.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/python/samples/custatevec/initialize_sv.py b/python/samples/custatevec/initialize_sv.py
index 47c84ef..39d9538 100644
--- a/python/samples/custatevec/initialize_sv.py
+++ b/python/samples/custatevec/initialize_sv.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/python/setup.py b/python/setup.py
index b69a8a4..4e59fa7 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -82,7 +82,7 @@
     project_urls={
         "Bug Tracker": "https://github.com/NVIDIA/cuQuantum/issues",
         "User Forum": "https://github.com/NVIDIA/cuQuantum/discussions",
-        "Documentation": "https://docs.nvidia.com/cuda/cuquantum/python/",
+        "Documentation": "https://docs.nvidia.com/cuda/cuquantum/latest/python/",
         "Source Code": "https://github.com/NVIDIA/cuQuantum",
     },
     author="NVIDIA Corporation",
diff --git a/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py b/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py
index 32885db..9178064 100644
--- a/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py
+++ b/python/tests/cuquantum_tests/cutensornet_tests/test_internal.py
@@ -1,3 +1,7 @@
+# Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
 import re
 import sys
 import threading
diff --git a/samples/custatevec/batched_abs2sum.cu b/samples/custatevec/batched_abs2sum.cu
index bdc5c3a..2eaf838 100644
--- a/samples/custatevec/batched_abs2sum.cu
+++ b/samples/custatevec/batched_abs2sum.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -79,4 +79,4 @@ int main(void) {
         printf("abs2sum_batched example FAILED: wrong result\n");
         return EXIT_FAILURE;
     }
-}
\ No newline at end of file
+}
diff --git a/samples/custatevec/batched_collapse.cu b/samples/custatevec/batched_collapse.cu
index 0204ee6..11b3e4d 100644
--- a/samples/custatevec/batched_collapse.cu
+++ b/samples/custatevec/batched_collapse.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
diff --git a/samples/custatevec/batched_gate_application.cu b/samples/custatevec/batched_gate_application.cu
index de6ee3f..fd91119 100644
--- a/samples/custatevec/batched_gate_application.cu
+++ b/samples/custatevec/batched_gate_application.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -106,4 +106,4 @@ int main(void) {
         return EXIT_FAILURE;
     }
 
-}
\ No newline at end of file
+}
diff --git a/samples/custatevec/batched_measure.cu b/samples/custatevec/batched_measure.cu
index d10c921..a0ba34f 100644
--- a/samples/custatevec/batched_measure.cu
+++ b/samples/custatevec/batched_measure.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -89,4 +89,4 @@ int main(void) {
         printf("measure_batched example FAILED: wrong result\n");
         return EXIT_FAILURE;
     }
-}
\ No newline at end of file
+}
diff --git a/samples/custatevec/initialize_sv.cu b/samples/custatevec/initialize_sv.cu
index 506d0e5..0e8da36 100644
--- a/samples/custatevec/initialize_sv.cu
+++ b/samples/custatevec/initialize_sv.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+ * Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
diff --git a/samples/cutensornet/high_level/marginal_example.cu b/samples/cutensornet/high_level/marginal_example.cu
index 5310a53..8de8720 100644
--- a/samples/cutensornet/high_level/marginal_example.cu
+++ b/samples/cutensornet/high_level/marginal_example.cu
@@ -1,4 +1,4 @@
-/* Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+/* Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
diff --git a/samples/cutensornet/high_level/sampling_example.cu b/samples/cutensornet/high_level/sampling_example.cu
index b9b96bb..3c0c2e0 100644
--- a/samples/cutensornet/high_level/sampling_example.cu
+++ b/samples/cutensornet/high_level/sampling_example.cu
@@ -1,4 +1,4 @@
-/* Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES.
+/* Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */