ClassicalOps.hpp

Go to the documentation of this file.

// Copyright Quantinuum
//
// 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.
 
#pragma once
 
#include <memory>
 
#include "Op.hpp"
#include "OpPtr.hpp"
 
namespace tket {
 
class ClassicalOp : public Op {
 public:
  ClassicalOp(
      OpType type, unsigned n_i, unsigned n_io, unsigned n_o,
      const std::string &name = "");
 
  SymSet free_symbols() const override { return {}; }
  unsigned n_qubits() const override { return 0; }
 
  op_signature_t get_signature() const override { return sig_; }
 
  nlohmann::json serialize() const override;
 
  static Op_ptr deserialize(const nlohmann::json &j);
 
  std::string get_name(bool latex = false) const override;
 
  unsigned get_n_i() const { return n_i_; }
 
  unsigned get_n_io() const { return n_io_; }
 
  unsigned get_n_o() const { return n_o_; }
 
  bool is_equal(const Op &other) const override;
 
 protected:
  const unsigned n_i_;
  const unsigned n_io_;
  const unsigned n_o_;
  const std::string name_;
  std::vector<EdgeType> sig_;
};
 
class ClassicalEvalOp : public ClassicalOp {
 public:
  ClassicalEvalOp(
      OpType type, unsigned n_i, unsigned n_io, unsigned n_o,
      const std::string &name = "");
 
  virtual std::vector<bool> eval(const std::vector<bool> &x) const = 0;
 
  bool is_equal(const Op &other) const override;
};
 
class ClassicalTransformOp : public ClassicalEvalOp {
 public:
  ClassicalTransformOp(
      unsigned n, const std::vector<uint64_t> &values,
      const std::string &name = "ClassicalTransform");
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<ClassicalTransformOp>(*this);
  }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
 
  std::vector<uint64_t> get_values() const { return values_; }
 
 private:
  const std::vector<uint64_t> values_;
};
 
class WASMOp : public ClassicalOp {
 public:
  WASMOp(
      unsigned _n, unsigned _ww_n, std::vector<unsigned> _width_i_parameter,
      std::vector<unsigned> _width_o_parameter, const std::string &_func_name,
      const std::string &_wasm_uid);
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<WASMOp>(*this);
  }
 
  bool is_extern() const override { return true; }
 
  nlohmann::json serialize() const override;
 
  static Op_ptr deserialize(const nlohmann::json &j);
 
  bool is_equal(const Op &other) const override;
 
  unsigned get_n() const { return n_; }
 
  unsigned get_ww_n() const { return ww_n_; }
 
  unsigned get_n_i32() const { return n_i32_; }
 
  std::vector<unsigned> get_width_i_parameter() const {
    return width_i_parameter_;
  }
 
  std::vector<unsigned> get_width_o_parameter() const {
    return width_o_parameter_;
  }
 
  std::string get_func_name() const { return func_name_; }
 
  std::string get_wasm_file_uid() const { return wasm_file_uid_; }
 
 private:
  const unsigned n_;
 
  const unsigned ww_n_;
 
  const unsigned n_i32_;
 
  const std::vector<unsigned> width_i_parameter_;
 
  const std::vector<unsigned> width_o_parameter_;
 
  const std::string func_name_;
 
  const std::string wasm_file_uid_;
};
 
class SetBitsOp : public ClassicalEvalOp {
 public:
  explicit SetBitsOp(const std::vector<bool> &values)
      : ClassicalEvalOp(OpType::SetBits, 0, 0, values.size(), "SetBits"),
        values_(values) {}
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<SetBitsOp>(*this);
  }
 
  std::string get_name(bool latex) const override;
 
  std::vector<bool> get_values() const { return values_; }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
 
 private:
  std::vector<bool> values_;
};
 
class CopyBitsOp : public ClassicalEvalOp {
 public:
  explicit CopyBitsOp(unsigned n)
      : ClassicalEvalOp(OpType::CopyBits, n, 0, n, "CopyBits") {}
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<CopyBitsOp>(*this);
  }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
};
 
class PredicateOp : public ClassicalEvalOp {
 public:
  PredicateOp(OpType type, unsigned n, const std::string &name = "")
      : ClassicalEvalOp(type, n, 0, 1, name) {}
};
 
class RangePredicateOp : public PredicateOp {
 public:
  RangePredicateOp(
      unsigned n, uint64_t a = 0,
      uint64_t b = std::numeric_limits<uint64_t>::max())
      : PredicateOp(OpType::RangePredicate, n, "RangePredicate"), a(a), b(b) {}
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<RangePredicateOp>(*this);
  }
 
  std::string get_name(bool latex) const override;
 
  uint64_t upper() const { return b; }
 
  uint64_t lower() const { return a; }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
 
  bool is_equal(const Op &other) const override;
 
 private:
  uint64_t a;
  uint64_t b;
};
 
class ExplicitPredicateOp : public PredicateOp {
 public:
  ExplicitPredicateOp(
      unsigned n, const std::vector<bool> &values,
      const std::string &name = "ExplicitPredicate");
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<ExplicitPredicateOp>(*this);
  }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
 
  std::vector<bool> get_values() const { return values_; }
 
 private:
  const std::vector<bool> values_;
};
 
class ModifyingOp : public ClassicalEvalOp {
 public:
  ModifyingOp(OpType type, unsigned n, const std::string &name)
      : ClassicalEvalOp(type, n, 1, 0, name) {}
};
 
class ExplicitModifierOp : public ModifyingOp {
 public:
  ExplicitModifierOp(
      unsigned n, const std::vector<bool> &values,
      const std::string &name = "ExplicitModifier");
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<ExplicitModifierOp>(*this);
  }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
 
  std::vector<bool> get_values() const { return values_; }
 
 private:
  const std::vector<bool> values_;
};
 
class MultiBitOp : public ClassicalEvalOp {
 public:
  MultiBitOp(std::shared_ptr<const ClassicalEvalOp> op, unsigned n);
 
  Op_ptr symbol_substitution(
      const SymEngine::map_basic_basic &) const override {
    return std::make_shared<MultiBitOp>(*this);
  }
 
  std::string get_name(bool latex) const override;
 
  std::shared_ptr<const ClassicalEvalOp> get_op() const { return op_; }
 
  unsigned get_n() const { return n_; }
 
  std::vector<bool> eval(const std::vector<bool> &x) const override;
 
  bool is_equal(const Op &other) const override;
 
 private:
  std::shared_ptr<const ClassicalEvalOp> op_;
  unsigned n_;
};
 
std::shared_ptr<ClassicalTransformOp> ClassicalX();
 
std::shared_ptr<ClassicalTransformOp> ClassicalCX();
 
std::shared_ptr<ExplicitPredicateOp> NotOp();
 
std::shared_ptr<ExplicitPredicateOp> AndOp();
 
std::shared_ptr<ExplicitPredicateOp> OrOp();
 
std::shared_ptr<ExplicitPredicateOp> XorOp();
 
std::shared_ptr<ExplicitModifierOp> AndWithOp();
 
std::shared_ptr<ExplicitModifierOp> OrWithOp();
 
std::shared_ptr<ExplicitModifierOp> XorWithOp();
 
}  // namespace tket