Always squash symbolic circuits in Transforms::squash_1qb_to_Rz_PhasedX() (#2162)

Author: cqc-alec

TKET_VERSION

@@ -1 +1 @@
-2.1.82
+2.1.83

pytket/docs/changelog.md

@@ -1,9 +1,10 @@
 # Changelog
 
-# 2.17.0 (unreleased)
+# 2.17.0 (May 2026)
 
 Fixes:
-- Fix handling of wasm function calls in circuit boxes
+- Fix handling of wasm function calls in circuit boxes.
+- Fix handling of symbolic circuits in Transforms::squash_1qb_to_Rz_PhasedX().
 
 ## 2.16.0 (March 2026)
 

tket-c-api/src/tket-c-api.cpp

@@ -149,7 +149,7 @@ TketError tket_clifford_simp(
 TketError tket_squash_phasedx_rz(TketCircuit *tc) {
   if (!tc) return TKET_ERROR_NULL_POINTER;
 
-  Transforms::squash_1qb_to_Rz_PhasedX(true).apply(tc->circuit);
+  Transforms::squash_1qb_to_Rz_PhasedX().apply(tc->circuit);
 
   return TKET_SUCCESS;
 }

tket/include/tket/Transformations/BasicOptimisation.hpp

@@ -132,11 +132,8 @@ Transform normalise_TK2();
  * @brief Squash single qubit gates into PhasedX and Rz gates.
  *
  * Commute Rzs to the back if possible.
- *
- * @param always_squash_symbols whether to squash symbols regardless of
- *        complexity increase
  */
-Transform squash_1qb_to_Rz_PhasedX(bool always_squash_symbols = false);
+Transform squash_1qb_to_Rz_PhasedX();
 
 /**
  * Generate a transform that rounds all angles to the nearest \f$ \pi / 2^n \f$.

tket/src/Predicates/PassGenerators.cpp

@@ -270,7 +270,7 @@ PassPtr gen_auto_rebase_pass(const OpTypeSet& allowed_gates, bool allow_swaps) {
 PassPtr gen_auto_squash_pass(const OpTypeSet& singleqs) {
   auto find_squash = [singleqs]() {
     if (singleqs.contains(OpType::Rz) && singleqs.contains(OpType::PhasedX)) {
-      return Transforms::squash_1qb_to_Rz_PhasedX(false);
+      return Transforms::squash_1qb_to_Rz_PhasedX();
     } else {
       auto tk1_replacement = find_tk1_replacement(singleqs);
       return Transforms::squash_factory(singleqs, tk1_replacement, false);

tket/src/Predicates/PassLibrary.cpp

@@ -470,7 +470,7 @@ const PassPtr &ZZPhaseToRz() {
 
 const PassPtr &SquashRzPhasedX() {
   static const PassPtr pp([]() {
-    Transform t = Transforms::squash_1qb_to_Rz_PhasedX(true);
+    Transform t = Transforms::squash_1qb_to_Rz_PhasedX();
     PredicatePtrMap s_ps;
     PredicateClassGuarantees g_postcons{
         {typeid(GateSetPredicate), Guarantee::Clear}};

tket/src/Transformations/RzPhasedXSquash.cpp

@@ -14,8 +14,13 @@
 
 #include "tket/Transformations/RzPhasedXSquash.hpp"
 
+#include <algorithm>
 #include <memory>
+#include <tkassert/Assert.hpp>
+#include <vector>
 
+#include "tket/Circuit/Command.hpp"
+#include "tket/OpType/OpType.hpp"
 #include "tket/Transformations/BasicOptimisation.hpp"
 #include "tket/Transformations/Decomposition.hpp"
 #include "tket/Transformations/PQPSquash.hpp"
@@ -93,15 +98,20 @@ std::pair<Circuit, Gate_ptr> RzPhasedXSquasher::flush(
   return {replacement, rz3_gate};
 }
 
-Transform squash_1qb_to_Rz_PhasedX(bool always_squash_symbols) {
-  return Transform([always_squash_symbols](Circuit &circ) {
+Transform squash_1qb_to_Rz_PhasedX() {
+  return Transform([](Circuit &circ) {
     bool reverse = false;
     bool success = decompose_ZX().apply(circ);
     auto squasher = std::make_unique<RzPhasedXSquasher>(reverse);
-    return SingleQubitSquash(
-               std::move(squasher), circ, reverse, always_squash_symbols)
-               .squash() ||
-           success;
+    success =
+        SingleQubitSquash(std::move(squasher), circ, reverse, true).squash() ||
+        success;
+    // Assert that all the Rx gates resulting from decompose_ZX() have gone.
+    std::vector<Command> cmds = circ.get_commands();
+    TKET_ASSERT(!std::any_of(cmds.begin(), cmds.end(), [](const Command &cmd) {
+      return cmd.get_op_ptr()->get_type() == OpType::Rx;
+    }));
+    return success;
   });
 }
 

tket/test/src/test_CompilerPass.cpp

@@ -2350,6 +2350,24 @@ SCENARIO("AutoSquash") {
     REQUIRE_THROWS_AS(gen_auto_squash_pass({OpType::Rx}), Unsupported);
     REQUIRE_THROWS_AS(gen_auto_squash_pass({}), Unsupported);
   }
+  GIVEN("Squashing PhasedX and Rz with a symbolic circuit") {
+    // https://github.com/Quantinuum/tket/issues/2152
+    Sym asym = SymEngine::symbol("a");
+    Expr alpha(asym);
+    Circuit circ0(2);
+    circ0.add_op<unsigned>(OpType::PhasedX, {0.5, 0.5}, {1});
+    circ0.add_op<unsigned>(OpType::Rz, alpha, {1});
+    circ0.add_op<unsigned>(OpType::PhasedX, {0.5, 0.0}, {1});
+    circ0.add_op<unsigned>(OpType::ZZPhase, 1.0, {0, 1});
+    CompilationUnit cu(circ0);
+    gen_auto_squash_pass({OpType::PhasedX, OpType::Rz})->apply(cu);
+    Circuit circ1 = cu.get_circ_ref();
+    symbol_map_t symmap;
+    symmap[asym] = 0.0;
+    circ0.symbol_substitution(symmap);
+    circ1.symbol_substitution(symmap);
+    REQUIRE(test_unitary_comparison(circ0, circ1));
+  }
 }
 
 SCENARIO("Efficient TK2 synthesis") {

tket/test/src/test_Synthesis.cpp

@@ -2148,7 +2148,7 @@ SCENARIO("Test squash Rz PhasedX") {
     circ.add_op<unsigned>(OpType::PhasedX, {alpha, beta}, {0});
     circ.add_op<unsigned>(OpType::Rz, 0.5, {0});
     circ.add_op<unsigned>(OpType::PhasedX, {0.5, 0.5}, {0});
-    Transforms::squash_1qb_to_Rz_PhasedX(true).apply(circ);
+    Transforms::squash_1qb_to_Rz_PhasedX().apply(circ);
     OpTypeSet allowed = {OpType::Rz, OpType::PhasedX};
     for (const Command &cmd : circ) {
       OpType optype = cmd.get_op_ptr()->get_type();