Struct BasicApproximationTable 

pub struct BasicApproximationTable {
    pub entries: Vec<(Vec<&'static str>, SU2)>,
}

Look up table of gate sequences for the universal gate set {H, T, Tdg, S, Sdg}.

Two-stage Clifford+T construction. The single-qubit Clifford group modulo global phase has only 24 elements, so a naïve BFS over the 5-atom alphabet quickly collapses every branch onto that 24-element coset and stalls. To get richer SU(2) coverage we decouple the order-24 Clifford subgroup from the T-count growth:

1. Stage 1 — Clifford enumeration. BFS over {H, S, Sdg} until saturation produces exactly 24 distinct unitaries (up to global phase). Each carries a sequence of length ≤ 6 — the Clifford diameter for this generator set.

2. Stage 2 — T-count strata. For each k = 1 … max_t_count, build S_k from S_{k-1} by appending T or Tdg, then a Clifford from Stage 1. Every entry in S_k therefore has T-count exactly k, sandwiched between Cliffords. Global de-duplication across all strata via the spatial-hash grid keeps the table compact.

The resulting table covers the {H,T} normal form up to T-count max_t_count, with Cliffords absorbed at no extra T-count. Each additional stratum genuinely expands the SU(2) reach (the Clifford+T group is dense) rather than re-deriving cosets the previous depth already covered.

Fields

entries: Vec<(Vec<&'static str>, SU2)>

(gate_sequence, SU2_matrix) pairs. Pub for test introspection.

Implementations

impl BasicApproximationTable

pub fn build(table_depth: usize) -> Self

Build the basic approximation table via the two-stage Clifford+T BFS.

Stage 1 enumerates the 24-element single-qubit Clifford group from {H, S, Sdg}. Stage 2 builds T-count strata S_1, …, S_K where each S_k extends S_{k-1} by T or Tdg followed by an arbitrary Clifford. Global dedup keeps the table compact while every stratum genuinely extends SU(2) coverage (the Clifford+T group is dense).

table_depth is re-interpreted as the maximum T-count for the new algorithm (it was the BFS depth previously). Internally capped at MAX_T_COUNT_LIMIT to avoid combinatorial explosion at large values — a table_depth of 10 collapses to the same internal cap.

pub fn find_closest<'a>(&'a self, target: &SU2) -> (&'a [&'static str], f64)

Find the sequence in the table closest to target (up-to-global-phase distance).

Returns the slice of gate names and the distance achieved. O(N) linear scan over the entire table.

pub fn len(&self) -> usize

Number of entries in the table.