Added PF channel support. (#528)

* Added PF channel support.

* conflict fixup.

Author: MichaelBroughton

tensorflow_quantum/core/serialize/serializer.py

@@ -365,6 +365,39 @@ def _phase_damp_channel_deserializer():
         args=args)
 
 
+def _phase_flip_channel_serializer():
+    """Make standard serializer for PhaseFlip channel."""
+    args = [
+        # cirq channels can't contain symbols.
+        cirq.google.SerializingArg(serialized_name="p",
+                                   serialized_type=float,
+                                   op_getter=lambda x: x.gate.p),
+        cirq.google.SerializingArg(serialized_name="control_qubits",
+                                   serialized_type=str,
+                                   op_getter=lambda x: ''),
+        cirq.google.SerializingArg(serialized_name="control_values",
+                                   serialized_type=str,
+                                   op_getter=lambda x: '')
+    ]
+    return cirq.google.GateOpSerializer(gate_type=cirq.PhaseFlipChannel,
+                                        serialized_gate_id="PF",
+                                        args=args,
+                                        can_serialize_predicate=_CONSTANT_TRUE)
+
+
+def _phase_flip_channel_deserializer():
+    """Make standard deserializer for PhaseFlip channel."""
+
+    args = [
+        cirq.google.DeserializingArg(serialized_name="p",
+                                     constructor_arg_name="p")
+    ]
+    return cirq.google.GateOpDeserializer(
+        serialized_gate_id="PF",
+        gate_constructor=cirq.PhaseFlipChannel,
+        args=args)
+
+
 # Gates.
 def _eigen_gate_serializer(gate_type, serialized_id):
     """Make standard serializer for eigen gates."""
@@ -671,7 +704,8 @@ def _scalar_combiner(exponent, global_shift, exponent_scalar,
     _gad_channel_serializer(),
     _identity_gate_serializer(),
     _phase_damp_channel_serializer(),
-    _reset_channel_serializer()
+    _reset_channel_serializer(),
+    _phase_flip_channel_serializer()
 ]
 
 DESERIALIZERS = [
@@ -688,7 +722,8 @@ def _scalar_combiner(exponent, global_shift, exponent_scalar,
     _gad_channel_deserializer(),
     _identity_gate_deserializer(),
     _phase_damp_channel_deserializer(),
-    _reset_channel_deserializer()
+    _reset_channel_deserializer(),
+    _phase_flip_channel_deserializer()
 ]
 
 SERIALIZER = cirq.google.SerializableGateSet(gate_set_name="tfq_gate_set",

tensorflow_quantum/core/serialize/serializer_test.py

@@ -428,7 +428,11 @@ def _get_noise_proto_pairs():
 
         # Phase damp.
         (cirq.Circuit(cirq.phase_damp(gamma=0.1)(q0)),
-         _build_op_proto("PD", ['gamma'], [0.1], ['0_0']))
+         _build_op_proto("PD", ['gamma'], [0.1], ['0_0'])),
+
+        # Phase flip.
+        (cirq.Circuit(cirq.phase_flip(p=0.1)(q0)),
+         _build_op_proto("PF", ['p'], [0.1], ['0_0']))
     ]
     return pairs
 

tensorflow_quantum/core/src/circuit_parser_qsim.cc

@@ -717,6 +717,27 @@ inline Status PhaseDampingChannel(const Operation& op,
   return Status::OK();
 }
 
+inline Status PhaseFlipChannel(const Operation& op,
+                               const unsigned int num_qubits,
+                               const unsigned int time,
+                               NoisyQsimCircuit* ncircuit) {
+  int q;
+  bool unused;
+  float p;
+  Status u;
+  unused = absl::SimpleAtoi(op.qubits(0).id(), &q);
+
+  u = ParseProtoArg(op, "p", {}, &p);
+  if (!u.ok()) {
+    return u;
+  }
+
+  auto chan =
+      qsim::Cirq::PhaseFlipChannel<float>::Create(time, num_qubits - q - 1, p);
+  ncircuit->channels.push_back(chan);
+  return Status::OK();
+}
+
 tensorflow::Status ParseAppendChannel(const Operation& op,
                                       const unsigned int num_qubits,
                                       const unsigned int time,
@@ -729,7 +750,7 @@ tensorflow::Status ParseAppendChannel(const Operation& op,
           {"DP", &DepolarizingChannel}, {"ADP", &AsymmetricDepolarizingChannel},
           {"GAD", &GADChannel},         {"AD", &AmplitudeDampingChannel},
           {"RST", &ResetChannel},       {"PD", &PhaseDampingChannel},
-      };
+          {"PF", &PhaseFlipChannel}};
 
   auto build_f = chan_func_map.find(op.gate().id());
   if (build_f == chan_func_map.end()) {

tensorflow_quantum/core/src/circuit_parser_qsim_test.cc

@@ -1459,6 +1459,42 @@ TEST(QsimCircuitParserTest, PhaseDamping) {
   ASSERT_EQ(test_circuit.num_qubits, 1);
 }
 
+TEST(QsimCircuitParserTest, PhaseFlip) {
+  float p = 0.1234;
+  auto reference = qsim::Cirq::PhaseFlipChannel<float>::Create(0, 0, p);
+  Program program_proto;
+  Circuit* circuit_proto = program_proto.mutable_circuit();
+  circuit_proto->set_scheduling_strategy(circuit_proto->MOMENT_BY_MOMENT);
+  Moment* moments_proto = circuit_proto->add_moments();
+
+  // Add channel.
+  Operation* operations_proto = moments_proto->add_operations();
+  Gate* gate_proto = operations_proto->mutable_gate();
+  gate_proto->set_id("PF");
+
+  // Set the args.
+  google::protobuf::Map<std::string, Arg>* args_proto =
+      operations_proto->mutable_args();
+  (*args_proto)["p"] = MakeArg(p);
+
+  // Set the control args.
+  (*args_proto)["control_qubits"] = MakeControlArg("");
+  (*args_proto)["control_values"] = MakeControlArg("");
+
+  // Set the qubits.
+  Qubit* qubits_proto = operations_proto->add_qubits();
+  qubits_proto->set_id("0");
+
+  NoisyQsimCircuit test_circuit;
+
+  ASSERT_EQ(
+      NoisyQsimCircuitFromProgram(program_proto, {}, 1, false, &test_circuit),
+      tensorflow::Status::OK());
+  AssertChannelEqual(test_circuit.channels[0], reference);
+  ASSERT_EQ(test_circuit.channels.size(), 1);
+  ASSERT_EQ(test_circuit.num_qubits, 1);
+}
+
 TEST(QsimCircuitParserTest, NoisyEmpty) {
   Program program_proto;
   Circuit* circuit_proto = program_proto.mutable_circuit();

tensorflow_quantum/python/util.py

@@ -34,6 +34,7 @@
     cirq.GeneralizedAmplitudeDampingChannel,
     cirq.ResetChannel,
     cirq.PhaseDampingChannel,
+    cirq.PhaseFlipChannel,
 ]
 
 
@@ -82,6 +83,7 @@ def get_supported_channels():
     channel_mapping[cirq.AmplitudeDampingChannel(0.01)] = 1
     channel_mapping[cirq.ResetChannel()] = 1
     channel_mapping[cirq.PhaseDampingChannel(0.01)] = 1
+    channel_mapping[cirq.PhaseFlipChannel(0.01)] = 1
 
     return channel_mapping
 
@@ -528,6 +530,10 @@ def _channel_approx_eq(op_true, op_deser, atol=1e-5):
         if isinstance(op_deser, cirq.PhaseDampingChannel):
             return abs(op_true.gamma - op_deser.gamma) < atol
 
+    if isinstance(op_true, cirq.PhaseFlipChannel):
+        if isinstance(op_deser, cirq.PhaseFlipChannel):
+            return abs(op_true.p - op_deser.p) < atol
+
     return False