Unitary Synthesis of ChoiMixTableau for Diagonalisation

pytket/conanfile.py

@@ -32,7 +32,7 @@ def package(self):
         cmake.install()
 
     def requirements(self):
-        self.requires("tket/1.2.30@tket/stable")
+        self.requires("tket/1.2.31@tket/stable")
         self.requires("tklog/0.3.3@tket/stable")
         self.requires("tkrng/0.3.3@tket/stable")
         self.requires("tkassert/0.3.3@tket/stable")

pytket/tests/ansatz_sequence_test.py

@@ -88,9 +88,9 @@ def test_nontrivial_sequence() -> None:
             GraphColourMethod.Exhaustive: (3, 28, 20, 19),
         },
         PauliPartitionStrat.NonConflictingSets: {
-            GraphColourMethod.LargestFirst: (6, 28, 28, 28),
-            GraphColourMethod.Lazy: (6, 28, 28, 26),
-            GraphColourMethod.Exhaustive: (6, 28, 28, 26),
+            GraphColourMethod.LargestFirst: (6, 28, 28, 26),
+            GraphColourMethod.Lazy: (6, 28, 28, 28),
+            GraphColourMethod.Exhaustive: (6, 28, 28, 28),
         },
     }
 

tket/CMakeLists.txt

@@ -195,7 +195,6 @@ target_sources(tket
         src/ZX/MBQCRewrites.cpp
         src/ZX/ZXRWSequences.cpp
         src/Converters/ChoiMixTableauConverters.cpp
-        src/Converters/PauliGadget.cpp
         src/Converters/PauliGraphConverters.cpp
         src/Converters/Gauss.cpp
         src/Converters/PhasePoly.cpp
@@ -344,7 +343,6 @@ target_sources(tket
         include/tket/ZX/ZXGenerator.hpp
         include/tket/Converters/Converters.hpp
         include/tket/Converters/Gauss.hpp
-        include/tket/Converters/PauliGadget.hpp
         include/tket/Converters/PhasePoly.hpp
         include/tket/Converters/UnitaryTableauBox.hpp
         include/tket/Placement/NeighbourPlacements.hpp

tket/conanfile.py

@@ -23,7 +23,7 @@
 
 class TketConan(ConanFile):
     name = "tket"
-    version = "1.2.30"
+    version = "1.2.31"
     package_type = "library"
     license = "Apache 2"
     homepage = "https://github.com/CQCL/tket"

tket/include/tket/Circuit/CircUtils.hpp

@@ -107,6 +107,8 @@ std::pair<Circuit, Complex> decompose_2cx_VD(const Eigen::Matrix4cd& U);
  */
 std::pair<Circuit, Complex> decompose_2cx_DV(const Eigen::Matrix4cd& U);
 
+Expr pauli_angle_convert_or_throw(Complex pauliCoeff, const Expr& angle);
+
 /**
  * Construct a phase gadget
  *
@@ -127,12 +129,16 @@ Circuit phase_gadget(
  * \f$ e^{-\frac12 i \pi t \sigma_0 \otimes \sigma_1 \otimes \cdots} \f$
  * where \f$ \sigma_i \in \{I,X,Y,Z\} \f$ are the Pauli operators.
  *
- * @param paulis Pauli operators
+ * @param pauli Pauli operators
  * @param t angle in half-turns
  * @param cx_config CX configuration
  */
 Circuit pauli_gadget(
-    const std::vector<Pauli>& paulis, const Expr& t,
+    QubitPauliTensor pauli, Expr t,
+    CXConfigType cx_config = CXConfigType::Snake);
+
+Circuit pauli_gadget_pair(
+    QubitPauliTensor pauli0, Expr t0, QubitPauliTensor pauli1, Expr t1,
     CXConfigType cx_config = CXConfigType::Snake);
 
 /**

tket/include/tket/Circuit/PauliExpBoxes.hpp

@@ -214,4 +214,16 @@ class PauliExpCommutingSetBox : public Box {
   CXConfigType cx_config_;
 };
 
+void append_single_pauli_gadget_as_pauli_exp_box(
+    Circuit &circ, const QubitPauliTensor &pauli, Expr angle,
+    CXConfigType cx_config);
+
+void append_pauli_gadget_pair_as_box(
+    Circuit &circ, const QubitPauliTensor &pauli0, Expr angle0,
+    const QubitPauliTensor &pauli1, Expr angle1, CXConfigType cx_config);
+
+void append_commuting_pauli_gadget_set_as_box(
+    Circuit &circ, const std::list<std::pair<QubitPauliTensor, Expr>> &gadgets,
+    CXConfigType cx_config);
+
 }  // namespace tket

tket/include/tket/Clifford/ChoiMixTableau.hpp

@@ -45,7 +45,8 @@ class ChoiMixTableau {
    * When mapped to a sparse readable representation, independent
    * QubitPauliTensor objects are used for each segment, so we no longer expect
    * their individual phases to be +-1, instead only requiring this on their
-   * product.
+   * product. get_row() will automatically transpose the input segment term so
+   * it is presented as RxS s.t. SCR = C.
    *
    * Columns of the tableau are indexed by pair of Qubit id and a tag to
    * distinguish input vs output. Rows are not maintained in any particular
@@ -93,6 +94,7 @@ class ChoiMixTableau {
    * Construct a tableau directly from its rows.
    * Each row is represented as a product of QubitPauliTensors where the first
    * is over the input qubits and the second is over the outputs.
+   * A row RxS is a pair s.t. SCR = C
    */
   explicit ChoiMixTableau(const std::list<row_tensor_t>& rows);
   /**
@@ -123,12 +125,17 @@ class ChoiMixTableau {
    */
   unsigned get_n_outputs() const;
 
+  qubit_vector_t input_qubits() const;
+  qubit_vector_t output_qubits() const;
+
   /**
-   * Read off a row as a Pauli string
+   * Read off a row as a Pauli string.
+   * Returns a pair of Pauli strings RxS such that SCR = C
    */
   row_tensor_t get_row(unsigned i) const;
   /**
-   * Combine rows into a single row
+   * Combine rows into a single row.
+   * Returns a pair of Pauli strings RxS such that SCR = C
    */
   row_tensor_t get_row_product(const std::vector<unsigned>& rows) const;
 

tket/include/tket/Clifford/SymplecticTableau.hpp

@@ -20,12 +20,6 @@
 
 namespace tket {
 
-// Forward declare friend classes for converters
-class ChoiMixTableau;
-class UnitaryTableau;
-class UnitaryRevTableau;
-class Circuit;
-
 /**
  * Boolean encoding of Pauli
  * <x, z> = <false, false> ==> I
@@ -173,7 +167,6 @@ class SymplecticTableau {
    */
   void gaussian_form();
 
- private:
   /**
    * Number of rows
    */
@@ -196,6 +189,7 @@ class SymplecticTableau {
    */
   SymplecticTableau conjugate() const;
 
+ private:
   /**
    * Helper methods for manipulating the tableau when applying gates
    */
@@ -206,18 +200,6 @@ class SymplecticTableau {
   void col_mult(
       const MatrixXb::ColXpr &a, const MatrixXb::ColXpr &b, bool flip,
       MatrixXb::ColXpr &w, VectorXb &pw);
-
-  friend class UnitaryTableau;
-  friend class ChoiMixTableau;
-  friend Circuit unitary_tableau_to_circuit(const UnitaryTableau &tab);
-  friend std::pair<Circuit, unit_map_t> cm_tableau_to_circuit(
-      const ChoiMixTableau &tab);
-  friend std::ostream &operator<<(std::ostream &os, const UnitaryTableau &tab);
-  friend std::ostream &operator<<(
-      std::ostream &os, const UnitaryRevTableau &tab);
-
-  friend void to_json(nlohmann::json &j, const SymplecticTableau &tab);
-  friend void from_json(const nlohmann::json &j, SymplecticTableau &tab);
 };
 
 JSON_DECL(SymplecticTableau)

tket/include/tket/Converters/Converters.hpp

@@ -51,9 +51,148 @@ ChoiMixTableau circuit_to_cm_tableau(const Circuit &circ);
  * Since Circuit does not support distinct qubit addresses for inputs and
  * outputs, also returns a map from the output qubit IDs in the tableau to their
  * corresponding outputs in the circuit
+ *
+ * If synth_type == ChoiMixSynthType::exact, the circuit produced will be the
+ * (possibly non-unitary) channel whose stabilisers are exactly those of the
+ * tableau and no more, using initialisations, post-selections, discards,
+ * resets, and collapses to ensure this.
+ *
+ * If synth_type == ChoiMixSynthType::unitary, the circuit produced will be a
+ * unitary whose stabilisers include all rows of the tableau and possibly more.
+ * This is useful when we are treating the ChoiMixTableau as a means to encode a
+ * diagonalisation problem, since we are generally looking for a unitary as we
+ * may wish to apply the inverse afterwards (e.g. conjugating some rotations to
+ * implement a set of Pauli gadgets).
+ *
+ * Not every ChoiMixTableau can be extended to a unitary by just adding rows,
+ * e.g. if it requires any initialisation or post-selections. In this case, we
+ * call a qubit "spare" if its column in the tableau is Pauli::I in every row.
+ * If there are more inputs than outputs, then we also suppose there are
+ * additional spare output qubits which we will name the same as some qubits
+ * that only appear in the inputs, or vice versa. The synthesis guarantees that,
+ * if we take the unitary, initialise all spare inputs, and post-select on all
+ * spare outputs, every row from the original tableau is a stabiliser for the
+ * remaining projector. When the tableau does not contain enough spare qubits,
+ * an error is thrown. If it would be useful to automatically extend with
+ * additional qubits to guarantee a synthesis, or treat such rows in a different
+ * way, please submit a feature request.
+ *
+ * Example 1:
+ * ZXI -> III
+ * YYZ -> III
+ * This becomes a diagonalisation circuit followed by post-selections. For
+ * unitary synthesis, each row could be mapped to an arbitrary diagonal string
+ * over the outputs.
+ *
+ * Example 2:
+ * Z -> ZZ
+ * X -> IY
+ * Z -> -XX
+ * Combining the first and last rows reveals an initialisation is required for I
+ * -> YY. Since there are two output qubits, at least one of them does not
+ * already exist in the input fragment so we can freely add an extra qubit on
+ * the input side, initialise it and apply a unitary mapping IZ -> YY. For
+ * unitary synthesis, this could manifest as either altering the first row to ZZ
+ * -> ZZ or the last row to ZZ -> -XX.
+ *
+ * Example 3:
+ * ZX -> IZ
+ * II -> ZI
+ * We require an initialised qubit for the final row, but both input and output
+ * spaces only have q[0] and q[1], of which both inputs need to be open for the
+ * first row. In exact synthesis, we can obtain an initialised qubit by
+ * resetting a qubit after reducing the first row to only a single qubit. In
+ * unitary synthesis, the reset is not permitted and there are not enough qubits
+ * to have a designated initialised qubit, so an exception is thrown. However,
+ * if the input and output qubits had different names (e.g. inputs q[0], q[1],
+ * outputs p[0], p[1]), then the synthesised circuit may have up to four qubits
+ * and there are then enough to use a separate initialised qubit.
  */
-std::pair<Circuit, unit_map_t> cm_tableau_to_circuit(
-    const ChoiMixTableau &circ);
+
+/**
+ * Constructs a circuit producing the same effect as a ChoiMixTableau.
+ * Since Circuit does not support distinct qubit addresses for inputs and
+ * outputs, also returns a map from the output qubit IDs in the tableau to their
+ * corresponding outputs in the circuit.
+ *
+ * The circuit produced will be the (possibly non-unitary) channel whose
+ * stabilisers are exactly those of the tableau and no more, using
+ * initialisations, post-selections, discards, resets, and collapses to ensure
+ * this. It will automatically reuse qubits so no more qubits will be needed
+ * than max(tab.get_n_inputs(), tab.get_n_outputs()).
+ *
+ * Example 1:
+ * ZXI -> ()
+ * YYZ -> ()
+ * This becomes a diagonalisation circuit followed by post-selections.
+ *
+ * Example 2:
+ * Z -> ZZ
+ * X -> IY
+ * Z -> -XX
+ * Combining the first and last rows reveals an initialisation is required for I
+ * -> YY. Since there are two output qubits, at least one of them does not
+ * already exist in the input fragment so we can freely add an extra qubit on
+ * the input side, initialise it and apply a unitary mapping IZ -> YY.
+ *
+ * Example 3:
+ * ZX -> IZ
+ * II -> ZI
+ * We require an initialised qubit for the final row, but both input and output
+ * spaces only have q[0] and q[1], of which both inputs need to be open for the
+ * first row. We can obtain an initialised qubit by resetting a qubit after
+ * reducing the first row to only a single qubit.
+ */
+std::pair<Circuit, qubit_map_t> cm_tableau_to_exact_circuit(
+    const ChoiMixTableau &tab, CXConfigType cx_config = CXConfigType::Snake);
+
+/**
+ * We define a unitary extension of a ChoiMixTableau to be a unitary circuit
+ * whose stabilizer group contain all the rows of the ChoiMixTableau and
+ * possibly more. This is useful when we are treating the ChoiMixTableau as a
+ * means to encode a diagonalisation problem, since we are generally looking for
+ * a unitary as we may wish to apply the inverse afterwards (e.g. conjugating
+ * some rotations to implement a set of Pauli gadgets).
+ *
+ * Not every ChoiMixTableau can be extended to a unitary by just adding rows,
+ * e.g. if it requires any initialisation or post-selections. In this case, the
+ * unitary circuit is extended with additional input qubits which are assumed to
+ * be zero-initialised, and additional output qubits which are assumed to be
+ * post-selected. The synthesis guarantees that, if we take the unitary,
+ * initialise all designated inputs, and post-select on all designated outputs,
+ * every row from the original tableau is a stabiliser for the remaining
+ * projector. When not enough additional qubit names are provided, an error is
+ * thrown.
+ *
+ *
+ * Example 1:
+ * ZXI -> ()
+ * YYZ -> ()
+ * Since, in exact synthesis, at least two post-selections would be required, we
+ * pick two names from post_names. This is then a diagonalisation circuit which
+ * maps each row to an arbitrary diagonal string over post_names.
+ *
+ * Example 2:
+ * Z -> ZZ
+ * X -> IY
+ * Z -> -XX
+ * Combining the first and last rows reveals an initialisation is required for I
+ * -> YY. We extend the inputs with a qubit from init_names. The initialisation
+ * can manifest as either altering the first row to ZZ -> ZZ or the last row to
+ * ZZ -> -XX.
+ *
+ * Example 3:
+ * ZX -> IZ
+ * II -> ZI
+ * We require an initialised qubit for the final row, but both input and output
+ * spaces only have q[0] and q[1], of which both inputs need to be open for the
+ * first row. Unlike exact synthesis, we cannot reuse qubits, so the returned
+ * circuit will be over 3 qubits, extending with a name from init_names.
+ */
+std::pair<Circuit, qubit_map_t> cm_tableau_to_unitary_extension_circuit(
+    const ChoiMixTableau &tab, const std::vector<Qubit> &init_names = {},
+    const std::vector<Qubit> &post_names = {},
+    CXConfigType cx_config = CXConfigType::Snake);
 
 PauliGraph circuit_to_pauli_graph(const Circuit &circ);