Handle X gates in QTensorNetwork::ForceM()

Author: WrathfulSpatula

include/qcircuit.hpp

@@ -735,12 +735,39 @@ class QCircuit {
     void Run(QInterfacePtr qsim);
 
     /**
-     * Check if an index is any target qubit of this circuit.
+     * Check if an index is any target qubit of a nonclassical gate in this circuit.
      */
-    bool IsNonPhaseTarget(bitLenInt qubit)
+    bool IsNonClassicalTarget(bitLenInt qubit)
     {
         for (const QCircuitGatePtr& gate : gates) {
-            if ((gate->target == qubit) && !(gate->IsPhase())) {
+            if (gate->target != qubit) {
+                continue;
+            }
+            if (gate->IsInvert() && gate->controls.empty()) {
+                continue;
+            }
+            if (!(gate->IsPhase())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if an index is any target qubit of a nonclassical gate in this circuit.
+     */
+    bool IsNonClassicalTarget(bitLenInt qubit, bool* eigen)
+    {
+        for (const QCircuitGatePtr& gate : gates) {
+            if (gate->target != qubit) {
+                continue;
+            }
+            if (gate->IsInvert() && gate->controls.empty()) {
+                *eigen = !*eigen;
+                continue;
+            }
+            if (!(gate->IsPhase())) {
                 return true;
             }
         }
@@ -749,21 +776,27 @@ class QCircuit {
     }
 
     /**
-     * (If the qubit is not a target of a non-phase gate...) Delete this qubits' controls and phase targets.
+     * (If the qubit is not a target of a non-classical gate...) Delete this qubits' controls and phase targets.
      */
-    void DeletePhaseTarget(bitLenInt qubit, bool eigen)
+    bool DeleteClassicalTarget(bitLenInt qubit, bool eigen)
     {
         std::list<QCircuitGatePtr> nGates;
         gates.reverse();
         for (const QCircuitGatePtr& gate : gates) {
             if (gate->target == qubit) {
+                if (gate->IsInvert()) {
+                    eigen = !eigen;
+                    QCircuitGatePtr nGate = gate->Clone();
+                    nGates.insert(nGates.begin(), nGate);
+                }
                 continue;
             }
             QCircuitGatePtr nGate = gate->Clone();
             nGate->PostSelectControl(qubit, eigen);
             nGates.insert(nGates.begin(), nGate);
         }
         gates = nGates;
+        return eigen;
     }
 
     /**

src/qtensornetwork.cpp

@@ -236,11 +236,12 @@ bool QTensorNetwork::ForceM(bitLenInt qubit, bool result, bool doForce, bool doA
         return toRet;
     }
 
+    bool eigen = toRet;
     size_t layerId = circuit.size() - 1U;
     // Starting from latest circuit layer, if measurement commutes...
-    while (!(circuit[layerId]->IsNonPhaseTarget(qubit))) {
+    while (!(circuit[layerId]->IsNonClassicalTarget(qubit))) {
         const QCircuitPtr& c = circuit[layerId];
-        c->DeletePhaseTarget(qubit, toRet);
+        eigen = c->DeleteClassicalTarget(qubit, eigen);
 
         if (!layerId) {
             // The qubit has been simplified to |0> with no gates.
@@ -274,25 +275,30 @@ bool QTensorNetwork::ForceM(bitLenInt qubit, bool result, bool doForce, bool doA
     }
 
     // Insert terminal measurement.
-    measurements[layerId][qubit] = toRet;
+    measurements[layerId][qubit] = eigen;
 
     // If no qubit in this layer is unmeasured, we can completely telescope into classical state preparation.
     std::vector<bitLenInt> nonMeasuredQubits;
     nonMeasuredQubits.reserve(qubitCount);
     for (size_t i = 0U; i < qubitCount; ++i) {
         nonMeasuredQubits.push_back(i);
     }
+    std::map<bitLenInt, bool> m = measurements[layerId];
     for (const bitLenInt& q : nonMeasuredQubits) {
         size_t layer = layerId;
+        eigen = false;
         while (true) {
-            if (measurements[layer].find(q) != measurements[layer].end()) {
+            std::map<bitLenInt, bool>& ml = measurements[layer];
+            if (ml.find(q) != ml.end()) {
+                m[q] = ml[q] ^ eigen;
                 break;
             }
-            if (circuit[layer]->IsNonPhaseTarget(q)) {
+            if (circuit[layer]->IsNonClassicalTarget(q, &eigen)) {
                 // Nothing more to do; tell the user the result.
                 return toRet;
             }
             if (!layer) {
+                m[q] = eigen;
                 break;
             }
             --layer;
@@ -302,7 +308,6 @@ bool QTensorNetwork::ForceM(bitLenInt qubit, bool result, bool doForce, bool doA
 
     // All bits have been measured in this layer.
     // None of the previous layers matter.
-    const std::map<bitLenInt, bool>& m = measurements[layerId];
 
     // Erase all of the previous layers.
     for (size_t i = 0U; i < layerId; ++i) {