add obs include paulis to all-ops circuit

Author: Strilanc

src/stim/circuit/circuit.test.cc

@@ -1807,12 +1807,14 @@ Circuit stim::generate_test_circuit_with_all_operations() {
         DETECTOR(1, 2, 3) rec[-1]
         OBSERVABLE_INCLUDE(0) rec[-1]
         MPAD 0 1 0
+        OBSERVABLE_INCLUDE(1) Z2 Z3
         TICK
 
         # Inverted measurements.
         MRX !0
         MY !1
         MZZ !2 3
+        OBSERVABLE_INCLUDE(1) rec[-1]
         MYY !4 !5
         MPP X6*!Y7*Z8
         TICK

src/stim/cmd/command_m2d.cc

@@ -1,17 +1,3 @@
-// Copyright 2021 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 #include "stim/cmd/command_m2d.h"
 
 #include "command_help.h"

src/stim/cmd/command_m2d.test.cc

@@ -154,3 +154,30 @@ TEST(command_m2d, m2d_obs_size_misalign_11_obs) {
         trim(std::string(1024, '0') + "\n"));
     ASSERT_EQ(tmp_obs.read_contents(), "00000000000\n");
 }
+
+TEST(command_m2d, unphysical_observable_annotations) {
+    RaiiTempNamedFile tmp_circuit(R"CIRCUIT(
+        QUBIT_COORDS(0, 0) 0
+        QUBIT_COORDS(1, 0) 1
+        QUBIT_COORDS(0, 1) 2
+        QUBIT_COORDS(1, 1) 3
+        OBSERVABLE_INCLUDE(0) X0 X1
+        OBSERVABLE_INCLUDE(1) Z0 Z2
+        MPP X0*X1*X2*X3 Z0*Z1 Z2*Z3
+        DEPOLARIZE1(0.001) 0 1 2 3
+        MPP X0*X1*X2*X3 Z0*Z1 Z2*Z3
+        DETECTOR rec[-1] rec[-4]
+        DETECTOR rec[-2] rec[-5]
+        DETECTOR rec[-3] rec[-6]
+        OBSERVABLE_INCLUDE(0) X0 X1
+        OBSERVABLE_INCLUDE(1) Z0 Z2
+    )CIRCUIT");
+    RaiiTempNamedFile tmp_obs;
+
+    ASSERT_EQ(
+        trim(run_captured_stim_main(
+            {"m2d", "--in_format=01", "--obs_out", tmp_obs.path.c_str(), "--circuit", tmp_circuit.path.c_str()},
+            "000000\n100100\n000110\n")),
+        trim("000\n000\n011\n"));
+    ASSERT_EQ(tmp_obs.read_contents(), "00\n00\n00\n");
+}

src/stim/diagram/circuit_timeline_helper.cc

@@ -1,11 +1,9 @@
 #include "stim/diagram/circuit_timeline_helper.h"
 
-#include "stim/diagram/diagram_util.h"
-
 using namespace stim;
 using namespace stim_draw_internal;
 
-void CircuitTimelineHelper::skip_loop_iterations(CircuitTimelineLoopData loop_data, uint64_t skipped_reps) {
+void CircuitTimelineHelper::skip_loop_iterations(const CircuitTimelineLoopData &loop_data, uint64_t skipped_reps) {
     if (loop_data.num_repetitions > 0) {
         vec_pad_add_mul(cur_coord_shift, loop_data.shift_per_iteration, skipped_reps);
         measure_offset += loop_data.measurements_per_iteration * skipped_reps;
@@ -95,6 +93,11 @@ GateTarget CircuitTimelineHelper::rec_to_qubit(const GateTarget &target) {
 }
 
 GateTarget CircuitTimelineHelper::pick_pseudo_target_representing_measurements(const CircuitInstruction &op) {
+    for (const auto &t : op.targets) {
+        if (t.is_qubit_target() || t.is_pauli_target()) {
+            return t;
+        }
+    }
     // First check if coordinates prefix-match a qubit's coordinates.
     if (!op.args.empty()) {
         auto coords = shifted_coordinates_in_workspace(op.args);

src/stim/diagram/circuit_timeline_helper.h

@@ -69,7 +69,7 @@ struct CircuitTimelineHelper {
 
     stim::GateTarget rec_to_qubit(const stim::GateTarget &target);
     stim::GateTarget pick_pseudo_target_representing_measurements(const stim::CircuitInstruction &op);
-    void skip_loop_iterations(CircuitTimelineLoopData loop_data, uint64_t skipped_reps);
+    void skip_loop_iterations(const CircuitTimelineLoopData &loop_data, uint64_t skipped_reps);
     void do_record_measure_result(uint32_t target_qubit);
     void do_repeat_block(const stim::Circuit &circuit, const stim::CircuitInstruction &op);
     void do_next_operation(const stim::Circuit &circuit, const stim::CircuitInstruction &op);

src/stim/diagram/timeline/timeline_ascii_drawer.cc

@@ -427,27 +427,54 @@ void DiagramTimelineAsciiDrawer::do_observable_include(const ResolvedTimelineOpe
     SpanRef<const GateTarget> rec_targets = op.targets;
     rec_targets.ptr_start++;
 
+    bool had_paulis = false;
+    for (const auto &t : rec_targets) {
+        if (t.is_pauli_target()) {
+            had_paulis = true;
+            std::stringstream ss;
+            ss << "L" << (op.args.empty() ? 0 : op.args[0]) << "*=";
+            ss << t.pauli_type();
+            diagram.add_entry(
+                AsciiDiagramEntry{
+                    {
+                        m2x(cur_moment),
+                        q2y(t.qubit_value()),
+                        GATE_ALIGNMENT_X,
+                        GATE_ALIGNMENT_Y,
+                    },
+                    ss.str(),
+                });
+        }
+    }
+
+    bool had_rec = false;
     std::stringstream ss;
-    ss << "OBSERVABLE_INCLUDE:L" << (op.args.empty() ? 0 : op.args[0]) << "*=";
-    for (size_t k = 0; k < rec_targets.size(); k++) {
-        if (k) {
-            ss << "*";
+    ss << "OBSERVABLE_INCLUDE:L" << (op.args.empty() ? 0 : op.args[0]);
+    ss << "*=";
+    for (const auto &t : rec_targets) {
+        if (t.is_measurement_record_target()) {
+            if (had_rec) {
+                ss << "*";
+            }
+            had_rec = true;
+            write_rec_index(ss, t.value());
         }
-        write_rec_index(ss, rec_targets[k].value());
     }
-    if (rec_targets.empty()) {
-        ss.put('1');
+    if (had_rec || !had_paulis) {
+        if (rec_targets.empty()) {
+            ss.put('1');
+        }
+        diagram.add_entry(
+            AsciiDiagramEntry{
+                {
+                    m2x(cur_moment),
+                    q2y(pseudo_target.qubit_value()),
+                    GATE_ALIGNMENT_X,
+                    GATE_ALIGNMENT_Y,
+                },
+                ss.str(),
+            });
     }
-    diagram.add_entry(
-        AsciiDiagramEntry{
-            {
-                m2x(cur_moment),
-                q2y(pseudo_target.qubit_value()),
-                GATE_ALIGNMENT_X,
-                GATE_ALIGNMENT_Y,
-            },
-            ss.str(),
-        });
 }
 
 void DiagramTimelineAsciiDrawer::do_resolved_operation(const ResolvedTimelineOperation &op) {