Add docs

Signed-off-by: Ben Howe <bhowe@nvidia.com>

Author: bmhowe23

docs/sphinx/api/qec/nv_qldpc_decoder_api.rst

@@ -33,10 +33,10 @@
                           [0, 1, 0, 1, 1, 0, 1],
                           [0, 0, 1, 0, 1, 1, 1]], dtype=np.uint8) # sample 3x7 PCM
             opts = dict() # see below for options
-            # Note: H must be in row-major order. If you use
-            # `scipy.sparse.csr_matrix.todense()` to get the parity check
-            # matrix, you must specify todense(order='C') to get a row-major
-            # matrix.
+            # H may also be a scipy.sparse matrix (CSR, CSC, COO, or any
+            # other scipy.sparse format), which avoids a full dense rows×cols
+            # allocation for large PCMs.  Any format is normalised to CSR
+            # internally; no call to .toarray() or .todense() is needed.
             nvdec = qec.get_decoder('nv-qldpc-decoder', H, **opts)
 
       .. tab:: C++

docs/sphinx/components/qec/introduction.rst

@@ -644,6 +644,10 @@ CUDA-Q QEC supports implementing decoders in Python using the :code:`@qec.decode
     @qec.decoder("my_decoder")
     class MyDecoder:
         def __init__(self, H, **kwargs):
+            # H is a scipy.sparse matrix or a dense numpy uint8 array,
+            # mirroring whatever was passed to qec.get_decoder().
+            # Pass it unchanged to Decoder.__init__ so the C++ base class
+            # stores a compact sparse representation without a dense allocation.
             qec.Decoder.__init__(self, H)
             self.H = H
             # Initialize with optional kwargs

docs/sphinx/examples/qec/python/nv-qldpc-decoder.py

@@ -41,9 +41,8 @@ def parse_csr_mat(j, dims, mat_name):
     # Create a data array of ones.
     data = np.ones(indptr[-1], dtype=np.uint8)
 
-    # Build the CSR matrix and return it as a dense numpy array.
-    csr = csr_matrix((data, indices, indptr), shape=dims, dtype=np.uint8)
-    return csr.toarray()
+    # Build and return the sparse matrix directly — no dense allocation.
+    return csr_matrix((data, indices, indptr), shape=dims, dtype=np.uint8)
 
 
 def parse_H_csr(j, dims):
@@ -57,7 +56,7 @@ def parse_obs_csr(j, dims):
     """
     Parse a CSR-style observable matrix from an input file in JSON format"
     """
-    return parse_csr_mat(j, dims, "obs_mat")
+    return parse_csr_mat(j, dims, "obs_mat").toarray()
 
 
 ### Main decoder loop ###

docs/sphinx/examples_rst/qec/decoders.rst

@@ -9,6 +9,16 @@ The relationship between errors and syndromes is captured mathematically by the
 stabilizer measurement, while each column represents a possible error. When we multiply an error pattern by this matrix, we get the syndrome 
 that would result from those errors.
 
+.. note::
+   **scipy.sparse interop** — :func:`cudaq_qec.get_decoder` and
+   :class:`cudaq_qec.Decoder` accept a ``scipy.sparse`` matrix (CSR, CSC,
+   COO, or any other ``scipy.sparse`` format) as the parity-check matrix
+   ``H``.  This is the preferred form for large PCMs because no dense
+   ``rows x cols`` allocation is made — the matrix is normalised to CSR
+   internally.  Dense NumPy ``uint8`` arrays remain supported.
+   ``scipy`` is an optional dependency; if it is not installed, pass a dense
+   NumPy array instead.
+
 Detector Error Model
 +++++++++++++++++++++