tensorcircuit-nightly 1.3.0.dev20250728__py3-none-any.whl → 1.4.0.dev20251103__py3-none-any.whl

tensorcircuit/results/counts.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, Optional, Sequence
 
 import numpy as np
 
+from ..quantum import _decode_basis_label
 
 Tensor = Any
 ct = Dict[str, int]
@@ -89,14 +90,24 @@ def marginal_count(count: ct, keep_list: Sequence[int]) -> ct:
     return reverse_count(ncount)
 
 
-def count2vec(count: ct, normalization: bool = True) -> Tensor:
+def count2vec(
+    count: ct, normalization: bool = True, dim: Optional[int] = None
+) -> Tensor:
     """
-    Convert count dictionary to probability vector.
+    Convert a dictionary of counts (with string keys) to a probability/count vector.
+
+    Support:
+      - base-d string (d <= 36), characters taken from 0-9A-Z (case-insensitive)
+        For example:
+          qubit: '0101'
+          qudit: '012' or '09A' (A represents 10, which means [0, 9, 10])
 
     :param count: A dictionary mapping bit strings to counts
     :type count: ct
     :param normalization: Whether to normalize the counts to probabilities, defaults to True
     :type normalization: bool, optional
+    :param dim: Dimensionality of the vector, defaults to 2
+    :type dim: int, optional
     :return: Probability vector as numpy array
     :rtype: Tensor
 
@@ -105,44 +116,47 @@ def count2vec(count: ct, normalization: bool = True) -> Tensor:
     >>> count2vec({"00": 2, "10": 3, "11": 5})
     array([0.2, 0. , 0.3, 0.5])
     """
-    nqubit = len(list(count.keys())[0])
-    probability = [0] * 2**nqubit
-    shots = sum([v for k, v in count.items()])
-    for k, v in count.items():
-        if normalization is True:
-            v /= shots  # type: ignore
-        probability[int(k, 2)] = v
-    return np.array(probability)
 
+    if not count:
+        return np.array([], dtype=float)
 
-def vec2count(vec: Tensor, prune: bool = False) -> ct:
-    """
-    Convert probability vector to count dictionary.
+    dim = 2 if dim is None else dim
 
-    :param vec: Probability vector
-    :type vec: Tensor
-    :param prune: Whether to remove near-zero probabilities, defaults to False
-    :type prune: bool, optional
-    :return: Count dictionary
-    :rtype: ct
+    n = len(next(iter(count)).upper())
+    prob = np.zeros(dim**n, dtype=float)
+    shots = float(sum(count.values())) if normalization else 1.0
+    if shots == 0:
+        return prob
+
+    powers = [dim**p for p in range(n)][::-1]
+    for k, v in count.items():
+        digits = _decode_basis_label(k, n, dim)
+        idx = sum(dig * p for dig, p in zip(digits, powers))
+        prob[idx] = (v / shots) if normalization else v
+
+    return prob
 
-    :Example:
 
-    >>> vec2count(np.array([0.2, 0.3, 0.1, 0.4]))
-    {'00': 0.2, '01': 0.3, '10': 0.1, '11': 0.4}
+def vec2count(vec: Tensor, prune: bool = False, dim: Optional[int] = None) -> ct:
     """
-    from ..quantum import count_vector2dict
+    Map a count/probability vector of length D to a dictionary with base-d string keys (0-9A-Z).
+    Only generate string keys when d <= 36; if d is inferred to be > 36, raise a NotImplementedError.
 
+    :param vec: A one-dimensional vector of length D = d**n
+    :param prune: Whether to prune near-zero elements (threshold 1e-8)
+    :param dim: Dimensionality of the vector, defaults to 2
+    :return: {base-d string key: value}, key length n
+    """
+    from ..quantum import count_vector2dict, _infer_num_sites
+
+    dim = 2 if dim is None else dim
     if isinstance(vec, list):
         vec = np.array(vec)
-    n = int(np.log(vec.shape[0]) / np.log(2) + 1e-9)
-    c = count_vector2dict(vec, n, key="bin")
-    if prune is True:
-        nc = c.copy()
-        for k, v in c.items():
-            if np.abs(v) < 1e-8:
-                del nc[k]
-        return nc
+    n = _infer_num_sites(int(vec.shape[0]), dim)
+    c: ct = count_vector2dict(vec, n, key="bin", dim=dim)  # type: ignore
+    if prune:
+        c = {k: v for k, v in c.items() if np.abs(v) >= 1e-8}
+
     return c
 
 

tensorcircuit/shadows.py

@@ -334,7 +334,7 @@ def entropy_shadow(
 
 def renyi_entropy_2(snapshots: Tensor, sub: Optional[Sequence[int]] = None) -> Tensor:
     r"""To calculate the second order Renyi entropy of a subsystem from snapshot, please refer to
-    Brydges, T. et al. Science 364, 260–263 (2019). This function is not jitable.
+    Brydges, T. et al. Science 364, 260-263 (2019). This function is not jitable.
 
     :param snapshots: shape = (ns, repeat, nq)
     :type: Tensor

tensorcircuit/simplify.py

@@ -121,7 +121,9 @@ def _split_two_qubit_gate(
     if fixed_choice == 2:  # swap one
         return n3, n4, True  # swap
     s2 = n3.tensor.shape[-1]
-    if (s1 >= 4) and (s2 >= 4):
+    if (s1 >= n[0].dimension * n[2].dimension) and (
+        s2 >= n[1].dimension * n[3].dimension
+    ):
         # jax jit unspport split_node with trun_err anyway
         # tf function doesn't work either, though I believe it may work on tf side
         # CANNOT DONE(@refraction-ray): tf.function version with trun_err set

tensorcircuit/stabilizercircuit.py

@@ -96,10 +96,12 @@ class StabilizerCircuit(AbstractCircuit):
 
         if name.lower() in self.gate_map:
             # self._stim_circuit.append(gate_map[name.lower()], list(index))
-            instruction = f"{self.gate_map[name.lower()]} {' '.join(map(str, index))}"
+            gn = self.gate_map[name.lower()]
+            instruction = f"{gn} {' '.join(map(str, index))}"
             self._stim_circuit.append_from_stim_program_text(instruction)
             # append is much slower
-            self.current_sim.do(stim.Circuit(instruction))
+            # self.current_sim.do(stim.Circuit(instruction))
+            getattr(self.current_sim, gn.lower())(*index)
         else:
             raise ValueError(f"Gate {name} is not supported in stabilizer simulation")
 

tensorcircuit/templates/blocks.py

@@ -91,7 +91,7 @@ def QAOA_block(
                 e2,
                 unitary=G._zz_matrix,
                 theta=paramzz * g[e1][e2].get("weight", 1.0),
-                **kws
+                **kws,
             )
     else:
         i = 0
@@ -157,7 +157,7 @@ def qft(
     *index: int,
     do_swaps: bool = True,
     inverse: bool = False,
-    insert_barriers: bool = False
+    insert_barriers: bool = False,
 ) -> Circuit:
     """
     This function applies quantum fourier transformation (QFT) to the selected circuit lines

tensorcircuit/templates/hamiltonians.py

@@ -17,13 +17,14 @@ def _create_empty_sparse_matrix(shape: Tuple[int, int]) -> Any:
 def heisenberg_hamiltonian(
     lattice: AbstractLattice,
     j_coupling: Union[float, List[float], Tuple[float, ...]] = 1.0,
+    interaction_scope: str = "neighbors",
 ) -> Any:
-    """
+    r"""
     Generates the sparse matrix of the Heisenberg Hamiltonian for a given lattice.
 
     The Heisenberg Hamiltonian is defined as:
-    H = J * Σ_{<i,j>} (X_i X_j + Y_i Y_j + Z_i Z_j)
-    where the sum is over all unique nearest-neighbor pairs <i,j>.
+    :math:`H = J\sum_{i,j} (X_i X_j + Y_i Y_j + Z_i Z_j)`
+    where the sum is over a specified set of interacting pairs {i,j}.
 
     :param lattice: An instance of a class derived from AbstractLattice,
         which provides the geometric information of the system.
@@ -32,11 +33,23 @@ def heisenberg_hamiltonian(
         isotropic model (Jx=Jy=Jz) or a list/tuple of 3 floats for an
         anisotropic model (Jx, Jy, Jz). Defaults to 1.0.
     :type j_coupling: Union[float, List[float], Tuple[float, ...]], optional
+    :param interaction_scope: Defines the range of interactions.
+        - "neighbors": Includes only nearest-neighbor pairs (default).
+        - "all": Includes all unique pairs of sites.
+    :type interaction_scope: str, optional
     :return: The Hamiltonian as a backend-agnostic sparse matrix.
     :rtype: Any
     """
     num_sites = lattice.num_sites
-    neighbor_pairs = lattice.get_neighbor_pairs(k=1, unique=True)
+    if interaction_scope == "neighbors":
+        neighbor_pairs = lattice.get_neighbor_pairs(k=1, unique=True)
+    elif interaction_scope == "all":
+        neighbor_pairs = lattice.get_all_pairs()
+    else:
+        raise ValueError(
+            f"Invalid interaction_scope: '{interaction_scope}'. "
+            "Must be 'neighbors' or 'all'."
+        )
 
     if isinstance(j_coupling, (float, int)):
         js = [float(j_coupling)] * 3
@@ -73,13 +86,21 @@ def heisenberg_hamiltonian(
 def rydberg_hamiltonian(
     lattice: AbstractLattice, omega: float, delta: float, c6: float
 ) -> Any:
-    """
+    r"""
     Generates the sparse matrix of the Rydberg atom array Hamiltonian.
 
     The Hamiltonian is defined as:
-    H = Σ_i (Ω/2)X_i - Σ_i δ(1 - Z_i)/2 + Σ_{i<j} V_ij (1-Z_i)/2 (1-Z_j)/2
-      = Σ_i (Ω/2)X_i + Σ_i (δ/2)Z_i + Σ_{i<j} (V_ij/4)(Z_iZ_j - Z_i - Z_j)
-    where V_ij = C6 / |r_i - r_j|^6.
+    .. math::
+
+    H = \sum_i \frac{\Omega}{2} X_i
+        - \sum_i \frac{\delta}{2} \bigl(1 - Z_i \bigr)
+        + \sum_{i<j} \frac{V_{ij}}{4} \bigl(1 - Z_i \bigr)\bigl(1 - Z_j \bigr)
+
+      = \sum_i \frac{\Omega}{2} X_i
+        + \sum_i \frac{\delta}{2} Z_i
+        + \sum_{i<j} \frac{V_{ij}}{4}\,\bigl(Z_i Z_j - Z_i - Z_j \bigr)
+
+    where :math:`V_{ij} = C6 / |r_i - r_j|^6`.
 
     Note: Constant energy offset terms (proportional to the identity operator)
     are ignored in this implementation.