[Verifier] Distinguish parameters only for arithmetic expressions from concrete parameters which uses trigonometric functions (#204)

* [Verifier] Distinguish parameters only for arithmetic expressions from concrete parameters which uses trigonometric functions

* code format

* Parse int/float when reading param info

Author: xumingkuan

src/python/verifier/verifier.py

@@ -601,7 +601,9 @@ def compute_params(param_info):
     for i in range(len(param_info)):
         if param_info[i] == "":  # symbolic
             params.append(symbolic_params.pop(0))
-        elif isinstance(param_info[i], (int, float)):  # concrete
+        elif isinstance(param_info[i], int):  # concrete parameter for calculation
+            params.append(param_info[i])
+        elif isinstance(param_info[i], float):  # concrete parameter to be directly used
             params.append((math.cos(param_info[i]), math.sin(param_info[i])))
         else:  # expression
             op = param_info[i][0]

src/quartz/circuitseq/circuitgate.cpp

@@ -265,7 +265,7 @@ std::string CircuitGate::to_qasm_style_string(Context *ctx,
     for (auto input_wire : input_wires) {
       if (input_wire->is_parameter()) {
         // Ensures the wire is valid.
-        assert(ctx->param_has_value(input_wire->index));
+        assert(ctx->param_is_const(input_wire->index));
 
         // Determines the parameter value with respect to reparameterization.
         std::ostringstream out;

src/quartz/circuitseq/circuitseq.cpp

@@ -996,7 +996,7 @@ std::string CircuitSeq::to_qasm_style_string(Context *ctx,
                                              int param_precision) const {
   // Checks if parameters are in use.
   for (auto param : get_input_param_indices(ctx)) {
-    if (ctx->param_is_symbolic(param)) {
+    if (!ctx->param_is_const(param)) {
       std::cerr << "to_qasm_style_string only supports consts." << std::endl;
       break;
     }

src/quartz/context/context.cpp

@@ -217,6 +217,10 @@ int Context::get_new_param_id(const ParamType &param) {
   return param_info_->get_new_param_id(param);
 }
 
+int Context::get_new_arithmetic_param_id(const ParamType &param) {
+  return param_info_->get_new_arithmetic_param_id(param);
+}
+
 int Context::get_new_param_id() {
   return param_info_->get_new_param_id(may_use_halved_params_);
 }
@@ -238,8 +242,8 @@ bool Context::param_is_symbolic(int id) const {
   return param_info_->param_is_symbolic(id);
 }
 
-bool Context::param_has_value(int id) const {
-  return param_info_->param_has_value(id);
+bool Context::param_is_const(int id) const {
+  return param_info_->param_is_const(id);
 }
 
 bool Context::param_is_expression(int id) const {
@@ -261,7 +265,7 @@ Context::compute_parameters(const std::vector<ParamType> &input_parameters) {
 
 std::vector<int> Context::get_param_permutation(
     const std::vector<int> &input_param_permutation) {
-  int num_parameters = (int)param_info_->is_parameter_symbolic_.size();
+  int num_parameters = (int)param_info_->parameter_class_.size();
   std::vector<int> result = input_param_permutation;
   result.resize(num_parameters, -1);  // fill with -1
   for (int i = (int)input_param_permutation.size(); i < num_parameters; i++) {
@@ -307,7 +311,7 @@ std::vector<int> Context::get_param_permutation(
 void Context::generate_parameter_expressions(
     int max_num_operators_per_expression) {
   assert(max_num_operators_per_expression == 1);
-  int num_input_parameters = (int)param_info_->is_parameter_symbolic_.size();
+  int num_input_parameters = (int)param_info_->parameter_class_.size();
   assert(num_input_parameters > 0);
   if (!param_info_->parameter_expressions_.empty()) {
     std::cerr << "Context::generate_parameter_expressions() called twice for a "
@@ -350,25 +354,7 @@ std::vector<InputParamMaskType> Context::get_param_masks() const {
 }
 
 std::string Context::param_info_to_json() const {
-  std::string result = "[";
-  result += "[";
-  result += std::to_string(param_info_->is_parameter_symbolic_.size());
-  for (int i = 0; i < (int)param_info_->is_parameter_symbolic_.size(); i++) {
-    result += ", ";
-    if (param_is_expression(i)) {
-      result += param_info_->parameter_wires_[i]->input_gates[0]->to_json();
-    } else if (param_info_->is_parameter_symbolic_[i]) {
-      result += "\"\"";
-    } else {
-      result += to_string_with_precision(param_info_->parameter_values_[i],
-                                         /*precision=*/17);
-    }
-  }
-  result += "], ";
-  result += to_json_style_string_with_precision(param_info_->random_parameters_,
-                                                /*precision=*/17);
-  result += "]";
-  return result;
+  return param_info_->to_json();
 }
 
 bool Context::load_param_info_from_json(std::istream &fin) {
@@ -386,8 +372,8 @@ bool Context::load_param_info_from_json(std::istream &fin) {
   }
   int num_params;
   fin >> num_params;
-  param_info_->is_parameter_symbolic_.clear();
-  param_info_->is_parameter_symbolic_.reserve(num_params);
+  param_info_->parameter_class_.clear();
+  param_info_->parameter_class_.reserve(num_params);
   param_info_->parameter_wires_.clear();
   param_info_->parameter_wires_.reserve(num_params);
   param_info_->parameter_values_.clear();
@@ -416,10 +402,23 @@ bool Context::load_param_info_from_json(std::istream &fin) {
       assert(id == i);
     } else {
       // concrete parameter
-      fin.unget();
-      ParamType val;
-      fin >> val;
-      int id = get_new_param_id(val);
+      bool is_float = false;
+      std::string s;  // record the number string
+      while (ch != ',' && ch != ']') {
+        s += ch;
+        if (ch == '.' || ch == 'e' || ch == 'E') {
+          is_float = true;
+        }
+        fin >> ch;
+      }
+      fin.unget();  // put the ',' or ']' back
+      ParamType val = std::stod(s);
+      int id;
+      if (is_float) {
+        id = get_new_param_id(val);
+      } else {
+        id = get_new_arithmetic_param_id(val);
+      }
       assert(id == i);
     }
   }

src/quartz/context/context.h

@@ -81,6 +81,12 @@ class Context {
    * @return The index of the new concrete parameter.
    */
   int get_new_param_id(const ParamType &param);
+  /**
+   * Create a new concrete (integer) parameter that can only be used in
+   * arithmetic expressions.
+   * @return The index of the new concrete parameter.
+   */
+  int get_new_arithmetic_param_id(const ParamType &param);
   /**
    * Create a new symbolic parameter.
    * @return The index of the new symbolic parameter.
@@ -98,7 +104,7 @@ class Context {
   [[nodiscard]] int get_num_parameters() const;
   [[nodiscard]] int get_num_input_symbolic_parameters() const;
   [[nodiscard]] bool param_is_symbolic(int id) const;
-  [[nodiscard]] bool param_has_value(int id) const;
+  [[nodiscard]] bool param_is_const(int id) const;
   [[nodiscard]] bool param_is_expression(int id) const;
   [[nodiscard]] bool param_is_halved(int id) const;
 

src/quartz/context/param_info.cpp

@@ -1,5 +1,7 @@
 #include "param_info.h"
 
+#include "quartz/utils/string_utils.h"
+
 #include <cassert>
 
 namespace quartz {
@@ -36,14 +38,15 @@ std::vector<ParamType> ParamInfo::get_all_generated_parameters() const {
 }
 
 ParamType ParamInfo::get_param_value(int id) const {
-  assert(id >= 0 && id < (int)parameter_values_.size());
-  assert(!is_parameter_symbolic_[id]);
+  assert(id >= 0 && id < (int)parameter_class_.size());
+  assert(parameter_class_[id].is_const());
   return parameter_values_[id];
 }
 
 void ParamInfo::set_param_value(int id, const ParamType &param) {
-  assert(id >= 0 && id < (int)is_parameter_symbolic_.size());
-  assert(!is_parameter_symbolic_[id]);
+  assert(id >= 0 && id < (int)parameter_class_.size());
+  assert(parameter_class_[id] == ParamClass::concrete_const ||
+         parameter_class_[id] == ParamClass::arithmetic_int);
   while (id >= (int)parameter_values_.size()) {
     parameter_values_.emplace_back();
   }
@@ -55,10 +58,22 @@ std::vector<ParamType> ParamInfo::get_all_input_param_values() const {
 }
 
 int ParamInfo::get_new_param_id(const ParamType &param) {
-  int id = (int)is_parameter_symbolic_.size();
-  assert(id == (int)is_parameter_halved_.size());
-  is_parameter_symbolic_.push_back(false);
-  is_parameter_halved_.push_back(false);
+  int id = (int)parameter_class_.size();
+  assert(id == (int)parameter_class_.size());
+  parameter_class_.emplace_back(ParamClass::concrete_const);
+  auto wire = std::make_unique<CircuitWire>();
+  wire->type = CircuitWire::input_param;
+  wire->index = id;
+  parameter_wires_.push_back(std::move(wire));
+  set_param_value(id, param);
+  return id;
+}
+
+int ParamInfo::get_new_arithmetic_param_id(const ParamType &param) {
+  int id = (int)parameter_class_.size();
+  assert(id == (int)parameter_class_.size());
+  assert((int)param == param);
+  parameter_class_.emplace_back(ParamClass::arithmetic_int);
   auto wire = std::make_unique<CircuitWire>();
   wire->type = CircuitWire::input_param;
   wire->index = id;
@@ -68,9 +83,9 @@ int ParamInfo::get_new_param_id(const ParamType &param) {
 }
 
 int ParamInfo::get_new_param_id(bool is_halved) {
-  int id = (int)is_parameter_symbolic_.size();
-  is_parameter_symbolic_.push_back(true);
-  is_parameter_halved_.push_back(is_halved);
+  int id = (int)parameter_class_.size();
+  parameter_class_.emplace_back(is_halved ? ParamClass::symbolic_halved
+                                          : ParamClass::symbolic);
   // Make sure to generate a random parameter for each symbolic parameter.
   gen_random_parameters(id + 1);
   auto wire = std::make_unique<CircuitWire>();
@@ -83,11 +98,15 @@ int ParamInfo::get_new_param_id(bool is_halved) {
 int ParamInfo::get_new_param_expression_id(
     const std::vector<int> &parameter_indices, Gate *op) {
   bool is_symbolic = is_symbolic_constant(op);
+  bool is_const = true;
   for (auto &input_id : parameter_indices) {
-    assert(input_id >= 0 && input_id < (int)is_parameter_symbolic_.size());
-    if (param_is_symbolic(input_id)) {
+    assert(input_id >= 0 && input_id < (int)parameter_class_.size());
+    if (parameter_class_[input_id].is_symbolic()) {
       is_symbolic = true;
     }
+    if (!parameter_class_[input_id].is_const()) {
+      is_const = false;
+    }
   }
   if (!is_symbolic) {
     // A concrete parameter, no need to create an expression.
@@ -99,9 +118,9 @@ int ParamInfo::get_new_param_expression_id(
     }
     return get_new_param_id(op->compute(input_params));
   }
-  int id = (int)is_parameter_symbolic_.size();
-  is_parameter_symbolic_.push_back(true);
-  is_parameter_halved_.push_back(false);
+  int id = (int)parameter_class_.size();
+  parameter_class_.emplace_back(is_const ? ParamClass::symbolic_constexpr
+                                         : ParamClass::expression);
   auto circuit_gate = std::make_unique<CircuitGate>();
   circuit_gate->gate = op;
   for (auto &input_id : parameter_indices) {
@@ -119,21 +138,21 @@ int ParamInfo::get_new_param_expression_id(
 }
 
 int ParamInfo::get_num_parameters() const {
-  return (int)is_parameter_symbolic_.size();
+  return (int)parameter_class_.size();
 }
 
 int ParamInfo::get_num_input_symbolic_parameters() const {
   return (int)random_parameters_.size();
 }
 
 bool ParamInfo::param_is_symbolic(int id) const {
-  return id >= 0 && id < (int)is_parameter_symbolic_.size() &&
-         is_parameter_symbolic_[id];
+  return id >= 0 && id < (int)parameter_class_.size() &&
+         parameter_class_[id].is_symbolic();
 }
 
-bool ParamInfo::param_has_value(int id) const {
-  return id >= 0 && id < (int)is_parameter_symbolic_.size() &&
-         !is_parameter_symbolic_[id];
+bool ParamInfo::param_is_const(int id) const {
+  return id >= 0 && id < (int)parameter_class_.size() &&
+         parameter_class_[id].is_const();
 }
 
 bool ParamInfo::param_is_expression(int id) const {
@@ -142,8 +161,9 @@ bool ParamInfo::param_is_expression(int id) const {
 }
 
 bool ParamInfo::param_is_halved(int id) const {
-  return id >= 0 && id < (int)is_parameter_halved_.size() &&
-         is_parameter_halved_[id];
+  return id >= 0 && id < (int)parameter_class_.size() &&
+         parameter_class_[id] == ParamClass::symbolic_halved;
+  // TODO: halved parameter expressions
 }
 
 CircuitWire *ParamInfo::get_param_wire(int id) const {
@@ -158,10 +178,10 @@ std::vector<ParamType>
 ParamInfo::compute_parameters(const std::vector<ParamType> &input_parameters) {
   // Creates a param list, assuming that all symbolic params are defined first.
   auto result = input_parameters;
-  result.resize(is_parameter_symbolic_.size());
+  result.resize(parameter_class_.size());
   // Populates constant parameters.
   for (int i = 0; i < result.size(); ++i) {
-    if (!is_parameter_symbolic_[i]) {
+    if (parameter_class_[i].is_const()) {
       result[i] = parameter_values_[i];
     }
   }
@@ -180,7 +200,7 @@ ParamInfo::compute_parameters(const std::vector<ParamType> &input_parameters) {
 }
 
 std::vector<InputParamMaskType> ParamInfo::get_param_masks() const {
-  std::vector<InputParamMaskType> param_mask(is_parameter_symbolic_.size());
+  std::vector<InputParamMaskType> param_mask(parameter_class_.size());
   for (int i = 0; i < (int)param_mask.size(); i++) {
     if (!param_is_expression(i)) {
       param_mask[i] = ((InputParamMaskType)1) << i;
@@ -195,4 +215,35 @@ std::vector<InputParamMaskType> ParamInfo::get_param_masks() const {
   }
   return param_mask;
 }
+
+std::string ParamInfo::to_json() const {
+  std::string result = "[";
+  result += "[";
+  result += std::to_string(parameter_class_.size());
+  for (int i = 0; i < (int)parameter_class_.size(); i++) {
+    result += ", ";
+    if (parameter_class_[i] == ParamClass::arithmetic_int) {
+      // arithmetic int
+      result += std::to_string((int)parameter_values_[i]);
+    } else if (parameter_class_[i].is_input()) {
+      if (parameter_class_[i].is_symbolic()) {
+        // input symbolic
+        result += "\"\"";
+        // TODO: halved parameter
+      } else {
+        // input concrete
+        result += to_string_with_precision(parameter_values_[i],
+                                           /*precision=*/17);
+      }
+    } else {
+      // expression
+      result += parameter_wires_[i]->input_gates[0]->to_json();
+    }
+  }
+  result += "], ";
+  result += to_json_style_string_with_precision(random_parameters_,
+                                                /*precision=*/17);
+  result += "]";
+  return result;
+}
 }  // namespace quartz