Improve the performance of automatic detector computation

[nelimee]

After tqec/tqec#356 being merged, we know have a reasonably efficient way of computing automatically detectors. It should scale quite well with k (i.e., code distance, circuit size, ...). One issue we still have is that the detector computation part is still quite slow: tqec/tqec#356 (comment) shows some timings for a circuit implementing a logical CNOT, and shows that computing the detectors even for a small experiment (k=1) requires more than 2 full seconds of computation.

It would be nice to be able to gain at least half an order of magnitude on these numbers if we can.

[HaoTy]

Profiling on annotating large circuits suggests that the two major performance bottlenecks are

1. flow matching (addressed by Reimplement flow matching using Gaussian elimination #45), and
2. the implementation of PauliString (see Make PauliString more efficient #47).

We may also be able to rewrite some of the logic using stim.Circuit.flow_generators() and stim.Circuit.solve_flow_measurements(), which are optimized C++ functions (although the latter doesn't guarantee optimality).

         198501432 function calls (195172749 primitive calls) in 71.418 seconds

   Ordered by: internal time
   List reduced from 190 to 25 due to restriction <25>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
   476404   13.936    0.000   13.936    0.000 {method 'solve' of 'pycryptosat.Solver' objects}
 21282643   10.868    0.000   16.089    0.000 pauli.py:127(anticommutes)
 70092781    8.615    0.000    8.615    0.000 {method 'keys' of 'dict' objects}
    64762    4.847    0.000   23.748    0.000 pauli.py:135(collapse_by)
    24714    3.233    0.000    3.361    0.000 pauli.py:61(from_stim_pauli_string)
  5956224    2.980    0.000    4.422    0.000 pauli.py:177(overlaps)
 15528971    2.637    0.000    4.577    0.000 pauli.py:48(qubits)
 15457302    2.400    0.000   14.093    0.000 pauli.py:123(commutes)
 18156054    2.184    0.000    2.184    0.000 {method 'get' of 'dict' objects}
      520    2.178    0.004    5.341    0.010 sat.py:120(encode_pauli_string_commuting_cover_sat_problem_in_solver)
   476404    1.927    0.000    1.927    0.000 solvers.py:7468(get_model)
  9362162    1.490    0.000    2.575    0.000 pauli.py:197(__getitem__)
   476404    1.425    0.000   18.471    0.000 solvers.py:7531(enum_models)
3137536/32    1.228    0.000    3.893    0.122 copy.py:119(deepcopy)
   476404    1.136    0.000   19.607    0.000 cover.py:314(<genexpr>)
    18324    0.997    0.000    2.041    0.000 pauli.py:96(__mul__)
  5847880    0.939    0.000    5.335    0.000 boundary.py:48(<genexpr>)
   476745    0.864    0.000    0.864    0.000 {method 'add_clause' of 'pycryptosat.Solver' objects}
    26213    0.696    0.000    6.816    0.000 boundary.py:13(__init__)
 33568/64    0.574    0.000    3.891    0.061 copy.py:192(_deepcopy_list)
   127020    0.559    0.000    0.851    0.000 pauli.py:33(__init__)
    28725    0.503    0.000    5.874    0.000 {built-in method builtins.any}
  9259488    0.482    0.000    0.482    0.000 pauli.py:201(pauli_literal_to_bools)
 67040/32    0.461    0.000    3.892    0.122 copy.py:248(_reconstruct)
  8554560    0.409    0.000    0.409    0.000 pauli.py:194(__hash__)

Note that this is a benchmark on directly annotating a large circuit, which is not how detectors are annotated in tqec bu reflects the performance bottleneck better.