Phase-sensitive Algebra (#768)

## Description

This PR extends the symplectic representation with a **phase-sensitive
algebra** so that the additional phase-bits are transformed according to
the properties of the Pauli matrices.

The Pauli-representation layer now supports phases of the whole
**n-qubit Pauli group** $\mathfrak{P}_n$, meaning a `Pauli` represents
an element of the n-qubit Pauli group and the rows of a `PauliTableau` a
subgroup of $\mathfrak{P}_n$.
As the symplectic representation `( x | z )` removes phase information,
`Pauli` contains the member `phase` (or property `phase_exponent`),
which together define the n-qubit Pauli operator $i^{\text{phase}}
X^{\text{x}} Z^{\text{z}}$. With this representation, Pauli
multiplication and the relation $Y = iXZ$ can be fully simulated with
the symplectic vector and the phase exponent.

I did *not* restrict the representation to **Hermitian** Paulis (in that
case, `Pauli` would only have phases $\pm 1$) or to an Abelian subgroup
without $-I$ (in that case, `PauliTableau` could use the commutation
assumption to simplify phases to $\pm 1$ during Pauli-multiplication).
In my *subjective* opinion, those restrictions should be enforced by the
code layer above (`*Code`) and *not* the Pauli-representation.
Consequently, however, `Pauli*` supports a slightly more complex algebra
due to the possible phases $1, i, -1, -i$. I would also agree that there
is no use case yet for the theoretically complete (but more complex)
representation of the full Pauli group. So this is an open question.

However, even with a restricted version, the simple **Boolean addition
of the symplectic vector** (concatenated with a phase bit) is not the
correct algebraic operation to simulate phase-sensitive Pauli
multiplication, since we would need to include a **correction term** for
the phase bit that depends on the $X$/$Z$ overlap. Eg:
$P_1 = X \otimes X , P_2 = Z \otimes Z $ 
$P_1 * P_2 = (X \otimes X)*(Z \otimes Z) = (XZ) \otimes (XZ) = (-iY)
\otimes (-iY) = i^2 (Y \otimes Y) = - Y \otimes Y$

Previous representation $(x | z | p)$ with $p \in \\{0,1\\}$ and $P =
(-1)^p P_1 \otimes .. \otimes P_n$ and $(x_i | z_i) \sim I \text{ if }
(0|0); X \text{ if } (1|0); Y \text{ if } (1|1); Z \text{ if } (0|1)$
meaning $P = (-1)^p i^{x * z} X^x Z^z$:
$P_1  \sim (00|11|0) , P_2  \sim (11|00|0)$ 
$(11|00|0) + (00|11|0) = (11|11|0) \sim (-1)^0 i^{2} (XX) (ZZ) = Y
\otimes Y \not = - Y \otimes Y$ thus normal binary addition $+$ does not
work for the phases in this representation

Phase-sensitive calculation should be $(x | z | e)$ with $e \in \\{0,1,
2, 3\\}$ with $i^e X^x Z^z$:
$P_1 \sim (11|00|0) , P_2 \sim (11|00|0)$
$(11|00|0) \oplus (00|11|0) = (11|11|0) \sim i^0 (XX) (ZZ) = -Y \otimes
Y $
with $\oplus$ calculating the new phase as $e = e_1 + e_2 + 2*(z_1 *
x_2) \text{ mod } 4$

Thus, either way, the normal mod2 `row_echelon` cannot be used in the
phase-sensitive context, and we would need a `pauli_ row_echelon` with
the correction; nonetheless, no matter if we only restrict ourselves to
Hermitian Paulis.

Another open question is whether there is a need to **document** the
representation layers (or at least high-level classes like `*Code`) and
their assumptions in the generated Website.

Additionally, we fix the assumption that `generators` of the code have
to be **linearly independent**.

Fixes #767 

Assisted-by: GPT-5.6 Sol as first reviewer

## Checklist

- [x] The pull request only contains commits that are focused and
relevant to this change.
- [x] I have added appropriate tests that cover the new/changed
functionality.
- [x] I have updated the documentation to reflect these changes.
- [x] The changes follow the project's style guidelines and introduce no
new warnings.
- [x] The changes are fully tested and pass the CI checks.
- [x] I have reviewed my own code changes.

**If PR contains AI-assisted content:**

- [x] Any agent that created, edited, or submitted GitHub content was
explicitly authorized for that scope, as required by our [AI Usage
Guidelines](https://github.com/munich-quantum-toolkit/qecc/blob/main/docs/ai_usage.md).
- [ ] Every agent-authored or agent-edited public text body begins with
the visible disclosure `🤖 *AI text below* 🤖` (titles are exempt).
- [ ] AI-assisted commits include an `Assisted-by: [Model Name] via
[Tool Name]` footer.
- [x] I confirm that I have personally reviewed and understood all
AI-generated content, and accept full responsibility for it.

---------

Co-authored-by: Ludwig Schmid <117631861+lsschmid@users.noreply.github.com>
Co-authored-by: Ludwig Schmid <ludwig.s.schmid@tum.de>

Author: MaxieHelenBichmann

docs/PauliConventions.md

@@ -0,0 +1,121 @@
+# Pauli Conventions
+
+This page pins down how Pauli operators, their phases, and stabilizer groups are
+represented in `mqt.qecc.codes.core.pauli`. The conventions matter: a phase that
+is read as if it were a sign bit produces silently wrong results rather than an
+error.
+
+## The representation
+
+A `Pauli` on $n$ qubits is stored as a binary symplectic support $(x \mid z)$
+together with a **phase exponent** $p \in \{0,1,2,3\}$:
+
+$$
+P = i^{p}\, X^{x} Z^{z}
+\qquad\text{where}\qquad
+X^{x} Z^{z} = \bigotimes_{j=1}^{n} X^{x_j} Z^{z_j}
+$$
+
+The exponent is stored in `Pauli.phase_exponent`; for a `PauliTableau` the
+per-row exponents are in `PauliTableau.phase_exponents`.
+
+The single-qubit letters follow from this with $Y = iXZ$:
+
+| letter | $(x_j \mid z_j)$ | contribution to $p$ |
+| ------ | ---------------- | ------------------- |
+| `I`    | $(0 \mid 0)$     | 0                   |
+| `X`    | $(1 \mid 0)$     | 0                   |
+| `Z`    | $(0 \mid 1)$     | 0                   |
+| `Y`    | $(1 \mid 1)$     | 1                   |
+
+So a Hermitian Pauli with a `+` sign has $p = x \cdot z$, which is the number of
+`Y` letters modulo four — **not** zero. `Pauli(support)` with no explicit
+exponent picks exactly this canonical positive Hermitian choice.
+
+## Exponents are not sign bits
+
+`phase_exponent` carries four values, not two. The two are related by
+
+$$
+P = (-1)^{r}\, i^{\,x \cdot z}\, X^{x} Z^{z},
+\qquad
+r = \frac{p - x \cdot z}{2} \bmod 2
+$$
+
+Use the explicit converters rather than reaching for the raw exponent:
+
+- `Pauli.sign()` / `PauliTableau.signs()` return the binary sign $r$, and raise
+  `InvalidPauliError` on a non-Hermitian operator, which has no real sign.
+- `Pauli.from_symplectic_and_sign(support, sign)` and
+  `PauliTableau.phase_from_signs(matrix, signs)` go the other way.
+- `Pauli.is_hermitian()` / `PauliTableau.is_hermitian()` test whether a sign
+  exists at all.
+
+## Multiplication needs a correction term
+
+Because $Z^{z_1} X^{x_2} = (-1)^{z_1 \cdot x_2} X^{x_2} Z^{z_1}$, the product of
+two Paulis is
+
+$$
+P_1 P_2 = i^{\,p_1 + p_2 + 2 (z_1 \cdot x_2)}
+X^{x_1 \oplus x_2} Z^{z_1 \oplus z_2}
+$$
+
+The extra $2(z_1 \cdot x_2)$ is why
+**XOR-ing symplectic rows and XOR-ing their signs is not Pauli multiplication**.
+Concretely:
+
+$$(X \otimes X)(Z \otimes Z) = -\,Y \otimes Y$$
+
+while XOR-ing the two `+` signs would predict $+\,Y \otimes Y$. Note the
+correction depends on the number of qubits: $(XXXX)(ZZZZ) = +YYYY$.
+
+Consequences for anyone combining rows of a signed tableau:
+
+- Use `PauliTableau.multiply_rows(target, source)`, never a raw XOR on
+  `tableau.tableau.data` followed by an XOR on the phases.
+- Use `pauli_row_echelon`, not `mod2.row_echelon`, whenever phases must survive
+  the reduction. A plain mod-2 reduction is only safe on a CSS tableau, where
+  the pivoting never combines an X-type row with a Z-type row and the correction
+  term vanishes.
+- `PauliTableau.independent_rows()` selects rows by support only and is
+  explicitly phase-insensitive; do not use it to decide anything about signs.
+
+## Which layer enforces what
+
+The two layers deliberately allow different things:
+
+- **`Pauli` / `PauliTableau` represent the full $n$-qubit Pauli group
+  $\mathfrak{P}_n$.** Non-Hermitian elements such as `+iX` are legal and
+  necessary: row reduction genuinely produces them as intermediates, since
+  $X \cdot Z = -iY$.
+- **`StabilizerCode` enforces the stabilizer conditions.** Its constructor
+  rejects generators that do not commute, are not Hermitian, or together
+  generate $-I$. Those checks — not the Pauli layer — are what guarantee a valid
+  code.
+
+Generators need **not** be independent. A redundant generating set is accepted
+and kept as given, so `CSSCode` preserves the check matrices you pass in,
+including redundant rows that matter for single-shot decoding and meta-checks.
+Group-level comparisons (`equal_stabilizer_group`, `stabilizer_equivalent`,
+`is_stabilizer`) compare the generated groups and are unaffected by redundancy.
+
+## Subgroups and rank
+
+`pauli_row_echelon` returns a `PauliRowEchelon`, whose `rank` is $\log_2 |G|$
+for the generated subgroup $G$. This includes the central scalars, so it can
+exceed the number of pivot columns:
+
+| generators    | generated subgroup                                | order | `rank` |
+| ------------- | ------------------------------------------------- | ----- | ------ |
+| `["XX","ZZ"]` | $\{I, XX, ZZ, -YY\}$ — no scalars beyond $I$      | 4     | 2      |
+| `["+iX"]`     | $\{I, iX, -I, -iX\}$ — one pivot, scalars $\pm I$ | 4     | 2      |
+| `["X","Z"]`   | $\{\pm I, \pm X, \pm Z, \pm iY\}$ — anticommuting | 8     | 3      |
+
+The middle row has a single pivot column yet rank 2: the generator squares to
+$-I$, so the subgroup contains scalars the support alone cannot account for. The
+last row picks up $-I$ from the anticommutator.
+
+To test many Paulis against one subgroup, compute the echelon once and call
+`pauli_in_reduced_subgroup`; `PauliTableau.is_in_subgroup` redoes the
+elimination on every call.

docs/architecture.md

@@ -42,3 +42,8 @@ Binary algebra
 
 The layers describe a *builds on* relationship, not exclusively class
 inheritance.
+
+Layer 3 carries the phase of a Pauli operator as an exponent rather than a sign
+bit, and layer 4 is where Hermiticity and the absence of $-I$ are enforced. The
+{doc}`Pauli conventions <PauliConventions>` page spells out both, along with why
+combining rows of a signed tableau is not a mod-2 row operation.

docs/index.md

@@ -45,6 +45,7 @@ tools/compilation
 
 installation
 architecture
+PauliConventions
 references
 ```
 

src/mqt/qecc/circuit_synthesis/encoding.py

@@ -361,23 +361,25 @@ def synthesize_encoding_circuit(
         "CliffordSynthesisConfig must be provided when use_cnots_if_css is False."
     )
 
+    additional_x_rows = code.x_logicals.tableau.data[additional_x_checks]
+    additional_z_rows = code.z_logicals.tableau.data[additional_z_checks]
     gens_mat: npt.NDArray[np.int8] = np.vstack((
         code.symplectic,
-        code.x_logicals.tableau.data[additional_x_checks],
-        code.z_logicals.tableau.data[additional_z_checks],
+        additional_x_rows,
+        additional_z_rows,
     ))
     gens_phase: npt.NDArray[np.int8] = np.hstack((
-        code.generators.phase,
-        np.zeros(len(additional_x_checks), dtype=np.int8),
-        np.zeros(len(additional_z_checks), dtype=np.int8),
+        code.generators.phase_exponents,
+        code.x_logicals.phase_exponents[additional_x_checks],
+        code.z_logicals.phase_exponents[additional_z_checks],
     ))
     log_mat: npt.NDArray[np.int8] = np.vstack((
         np.delete(code.x_logicals.tableau.data, additional_checks, axis=0),
         np.delete(code.z_logicals.tableau.data, additional_checks, axis=0),
     ))
     log_phase: npt.NDArray[np.int8] = np.hstack((
-        np.delete(code.x_logicals.phase, additional_checks, axis=0),
-        np.delete(code.z_logicals.phase, additional_checks, axis=0),
+        np.delete(code.x_logicals.phase_exponents, additional_checks, axis=0),
+        np.delete(code.z_logicals.phase_exponents, additional_checks, axis=0),
     ))
 
     return encoder_from_stabilizers_and_logicals(
@@ -462,32 +464,33 @@ def optimize_tableau(tableau: PauliTableau, stab_rows: list[int]) -> PauliTablea
                 if i == j:
                     continue
                 tab = tableau.copy()
-                mat = tab.tableau.data
-                destabs = mat[:half][stab_rows]
-                stabs = mat[half:][stab_rows]
-                stabs[i] ^= stabs[j]
-                destabs[j] ^= destabs[i]
-                mat[:half][stab_rows] = destabs
-                mat[half:][stab_rows] = stabs
-                new_score, _ = score_symplectic(PauliTableau(mat, tableau.phase.copy()))
+
+                stab_i_abs, stab_j_abs = half + stab_rows[i], half + stab_rows[j]
+                destab_i_abs, destab_j_abs = stab_rows[i], stab_rows[j]
+
+                # Multiplying a stabilizer onto another must be mirrored on the
+                # destabilizers in the opposite direction to preserve the symplectic form.
+                tab.multiply_rows(stab_i_abs, stab_j_abs)
+                tab.multiply_rows(destab_j_abs, destab_i_abs)
+
+                new_score, _ = score_symplectic(tab)
                 if lexicographical_compare_np(new_score, best[1]):
                     best = (tab, new_score)
                     improved = True
             for j in range(len(logical_rows)):
                 tab = tableau.copy()
-                mat = tab.tableau.data
-                destabs = mat[:half][stab_rows]
-                stabs = mat[half:][stab_rows]
 
-                other_log = mat[logical_rows[(j + k) % (2 * k)]]
+                other_log_abs = logical_rows[(j + k) % (2 * k)]
+                destab_i_abs = stab_rows[i]
+                log_j_abs = logical_rows[j]
+                stab_i_abs = half + stab_rows[i]
 
-                destabs[i] ^= other_log
-                logj = mat[logical_rows[j]]
+                # The stabilizer row is read by the second multiplication, so it must
+                # not be one of the rows written by the first.
+                tab.multiply_rows(destab_i_abs, other_log_abs)
+                tab.multiply_rows(log_j_abs, stab_i_abs)
 
-                logj ^= stabs[i]
-                mat[:half][stab_rows] = destabs
-                mat[logical_rows[j]] = logj
-                new_score, _ = score_symplectic(PauliTableau(mat, tableau.phase.copy()))
+                new_score, _ = score_symplectic(tab)
                 if lexicographical_compare_np(new_score, best[1]):
                     best = (tab, new_score)
                     improved = True
@@ -515,11 +518,11 @@ def combine_stabilizer_and_logical_tableau(stabilizers: PauliTableau, logicals:
     # Combine stabilizers and logicals into a single tableau
     x_logicals = logicals.tableau.data[: logicals.num_rows() // 2]
     z_logicals = logicals.tableau.data[logicals.num_rows() // 2 :]
-    x_logicals_phase = logicals.phase[: logicals.num_rows() // 2]
-    z_logicals_phase = logicals.phase[logicals.num_rows() // 2 :]
+    x_logicals_phase = logicals.phase_exponents[: logicals.num_rows() // 2]
+    z_logicals_phase = logicals.phase_exponents[logicals.num_rows() // 2 :]
     combined_matrix = np.vstack([x_logicals, z_logicals, stabilizers.tableau.data])
 
-    combined_phase = np.hstack([x_logicals_phase, z_logicals_phase, stabilizers.phase])
+    combined_phase = np.hstack([x_logicals_phase, z_logicals_phase, stabilizers.phase_exponents])
     combined_tableau = PauliTableau(combined_matrix, combined_phase)
 
     # Complete with destabilizers for the stabilizers only

src/mqt/qecc/circuit_synthesis/exact/search.py

@@ -17,7 +17,7 @@
 
 from mqt.qecc import mod2
 
-from ...codes.core.pauli import CheckMatrix, StabilizerTableau
+from ...codes.core.pauli import CheckMatrix, StabilizerTableau, pauli_row_echelon
 from ..circuits import CliffordIsometry, CNOTCircuit
 from .encoding_interface import (
     CliffordDepthEncoding,
@@ -506,9 +506,9 @@ def _combine_stabilizers_and_logicals(
     ])
 
     combined_phase = np.concatenate([
-        x_logicals.phase,
-        z_logicals.phase,
-        stabilizers.phase,
+        x_logicals.phase_exponents,
+        z_logicals.phase_exponents,
+        stabilizers.phase_exponents,
     ])
 
     return StabilizerTableau(combined_matrix, combined_phase)
@@ -671,7 +671,7 @@ def _logical_sign_corrections(
     k = num_target_rows - n
     target_x = target_tableau.tableau.data[:num_target_rows, :n].astype(np.int8)
     target_z = target_tableau.tableau.data[:num_target_rows, n:].astype(np.int8)
-    target_signs = target_tableau.phase[:num_target_rows].astype(np.int8)
+    target_signs = target_tableau.signs()[:num_target_rows].astype(np.int8)
 
     x_correction = np.zeros(n, dtype=np.int8)
     z_correction = np.zeros(n, dtype=np.int8)
@@ -718,17 +718,24 @@ def _stabilizer_sign_corrections(
 
     target_x = target_tableau.tableau.data[:num_target_rows, :n].astype(np.int8)
     target_z = target_tableau.tableau.data[:num_target_rows, n:].astype(np.int8)
-    target_signs = target_tableau.phase[:num_target_rows].astype(np.int8)
+    target_signs = target_tableau.signs()[:num_target_rows].astype(np.int8)
 
     circ_stab_symp = np.hstack([circ.z2x[pivot_qubits], circ.z2z[pivot_qubits]])  # (num_stab x 2n)
     circ_stab_sign = circ.z_sign[np.array(pivot_qubits)]
     targ_stab_symp = np.hstack([target_x[2 * k :], target_z[2 * k :]])  # (num_stab x 2n)
 
-    _, r_circ = _gf2_rref_track(circ_stab_symp)
-    _, r_targ = _gf2_rref_track(targ_stab_symp)
+    # Phase-sensitive reduction: the sign of a product of Paulis is not the XOR of
+    # their signs, so the canonical signs must come from the Pauli row echelon.
+    circ_echelon = pauli_row_echelon(
+        StabilizerTableau(circ_stab_symp, StabilizerTableau.phase_from_signs(circ_stab_symp, circ_stab_sign))
+    )
+    targ_echelon = pauli_row_echelon(
+        StabilizerTableau(targ_stab_symp, StabilizerTableau.phase_from_signs(targ_stab_symp, target_signs[2 * k :]))
+    )
 
-    s_circ_can = r_circ @ circ_stab_sign % 2
-    s_targ_can = r_targ @ target_signs[2 * k :] % 2
+    r_circ = circ_echelon.transform
+    s_circ_can = circ_echelon.reduced.signs()
+    s_targ_can = targ_echelon.reduced.signs()
 
     phase_diff = (s_circ_can ^ s_targ_can).astype(np.int8)
     if not np.any(phase_diff):

src/mqt/qecc/circuit_synthesis/exact/verification.py

@@ -49,13 +49,13 @@ def verify_clifford_unitary(circuit: CliffordIsometry, target: StabilizerTableau
 
     act_x: npt.NDArray[np.int8] = actual.tableau.data[:n]
     act_z: npt.NDArray[np.int8] = actual.tableau.data[n:]
-    act_xp: npt.NDArray[np.int8] = actual.phase[:n]
-    act_zp: npt.NDArray[np.int8] = actual.phase[n:]
+    act_xp: npt.NDArray[np.int8] = actual.phase_exponents[:n]
+    act_zp: npt.NDArray[np.int8] = actual.phase_exponents[n:]
 
     tgt_x: npt.NDArray[np.int8] = target.tableau.data[:n]
     tgt_z: npt.NDArray[np.int8] = target.tableau.data[n:]
-    tgt_xp: npt.NDArray[np.int8] = target.phase[:n]
-    tgt_zp: npt.NDArray[np.int8] = target.phase[n:]
+    tgt_xp: npt.NDArray[np.int8] = target.phase_exponents[:n]
+    tgt_zp: npt.NDArray[np.int8] = target.phase_exponents[n:]
 
     # Find permutation π such that actual.X[q] == target.X[π(q)] for each q.
     perm: dict[int, int] = {}
@@ -117,9 +117,9 @@ def verify_clifford_isometry(
     if num_rows != expected_rows:
         return False
 
-    x_logicals = StabilizerTableau(target.tableau.data[:k, :], target.phase[:k])
-    z_logicals = StabilizerTableau(target.tableau.data[k : 2 * k, :], target.phase[k : 2 * k])
-    stabilizers = StabilizerTableau(target.tableau.data[2 * k :, :], target.phase[2 * k :])
+    x_logicals = StabilizerTableau(target.tableau.data[:k, :], target.phase_exponents[:k])
+    z_logicals = StabilizerTableau(target.tableau.data[k : 2 * k, :], target.phase_exponents[k : 2 * k])
+    stabilizers = StabilizerTableau(target.tableau.data[2 * k :, :], target.phase_exponents[2 * k :])
 
     circuit_code = circuit.get_code()
     target_code = StabilizerCode(stabilizers, x_logicals=x_logicals, z_logicals=z_logicals)

src/mqt/qecc/circuit_synthesis/operations.py

@@ -121,9 +121,13 @@ def apply_stabilizer_tableau_inplace(self, tableau: PauliTableau) -> None:
         n = tableau.n
         mat = tableau.tableau.data
 
+        signs = tableau.signs()
         _apply_transvection_numba(
-            mat[:, self.i], mat[:, self.i + n], mat[:, self.j], mat[:, self.j + n], tableau.phase, *self.v
+            mat[:, self.i], mat[:, self.i + n], mat[:, self.j], mat[:, self.j + n], signs, *self.v
         )
+        # Write into the existing array: the symplectic data above is mutated in place,
+        # so rebinding here would leave a caller holding the old phase array.
+        tableau.phase_exponents[:] = PauliTableau.phase_from_signs(mat, signs)
 
     def apply_stabilizer_tableau(self, tableau: PauliTableau, inplace: bool = False) -> PauliTableau:
         """Apply the transvection operation to a stabilizer tableau."""
@@ -132,9 +136,11 @@ def apply_stabilizer_tableau(self, tableau: PauliTableau, inplace: bool = False)
         n = out.n
         mat = out.tableau.data
 
+        signs = out.signs()
         _apply_transvection_numba(
-            mat[:, self.i], mat[:, self.i + n], mat[:, self.j], mat[:, self.j + n], out.phase, *self.v
+            mat[:, self.i], mat[:, self.i + n], mat[:, self.j], mat[:, self.j + n], signs, *self.v
         )
+        out.phase_exponents[:] = PauliTableau.phase_from_signs(mat, signs)
 
         return out
 

src/mqt/qecc/circuit_synthesis/transvection.py

@@ -138,7 +138,7 @@ def _score_transvections(
     scored: list[tuple[TableauOperation, int | tuple[int, ...]]] = []
 
     original_state = tableau.tableau.data.copy()
-    original_phase = tableau.phase.copy()
+    original_phase = tableau.phase_exponents.copy()
     for op in operations:
         op.apply_stabilizer_tableau_inplace(tableau)
         h_vec, _ = score_symplectic(tableau)
@@ -148,7 +148,7 @@ def _score_transvections(
             scored.append((op, score_value))
 
         tableau.tableau.data[:] = original_state
-        tableau.phase[:] = original_phase
+        tableau.phase_exponents[:] = original_phase
     scored.sort(key=operator.itemgetter(1))
     return scored
 
@@ -383,7 +383,7 @@ def fix_tableau_signs_in_place(tableau: PauliTableau) -> list[PauliOperation]:
     x_part = tableau.tableau.data[:, :n]
     z_part = tableau.tableau.data[:, n:]
 
-    phase = tableau.phase.copy()
+    phase = tableau.signs()
 
     if not np.any(phase):
         return []