Custom Operator Registry Support

.github/workflows/cmake.yml

@@ -125,7 +125,7 @@ jobs:
       working-directory: ${{github.workspace}}/build
       shell: bash
       # Execute the build.  You can specify a specific target with "--target <NAME>"
-      run: ccache -p && ccache -z && cmake --build . && ccache -s
+      run: ccache -p && ccache -z && cmake --build . -j 2 && ccache -s
 
     - name: Test
       if: ${{ !matrix.valgrind }}

CMakeLists.txt

@@ -359,6 +359,7 @@ set(SeQuant_src
         SeQuant/core/utility/tensor.hpp
         SeQuant/core/utility/timer.hpp
         SeQuant/core/utility/tuple.hpp
+        SeQuant/core/reserved.hpp
         SeQuant/core/wick.hpp
         SeQuant/core/wick.impl.hpp
         SeQuant/core/wolfram.hpp
@@ -373,6 +374,8 @@ set(SeQuant_src
         SeQuant/domain/mbpt/convention.hpp
         SeQuant/domain/mbpt/models/cc.cpp
         SeQuant/domain/mbpt/models/cc.hpp
+        SeQuant/domain/mbpt/op_registry.hpp
+        SeQuant/domain/mbpt/op_registry.cpp
         SeQuant/domain/mbpt/op.cpp
         SeQuant/domain/mbpt/op.hpp
         SeQuant/domain/mbpt/op.ipp

SeQuant/core/expressions/tensor.hpp

@@ -14,6 +14,7 @@
 #include <SeQuant/core/hash.hpp>
 #include <SeQuant/core/index.hpp>
 #include <SeQuant/core/latex.hpp>
+#include <SeQuant/core/reserved.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 #include <SeQuant/core/utility/strong.hpp>
 
@@ -516,8 +517,10 @@ class Tensor : public Expr, public AbstractTensor, public MutatableLabeled {
     const auto bkst = ctx.braket_slot_typesetting();
 
     // either rank > 1 or sum of bra and ket ranks > 1
-    const bool add_bar =
-        bra_rank() == ket_rank() ? rank() > 1 : bra_rank() + ket_rank() > 1;
+    // and label is not antisymmetrizer label, since it is already implied
+    bool add_bar =
+        (bra_rank() == ket_rank() ? rank() > 1 : bra_rank() + ket_rank() > 1) &&
+        this->label() != reserved::antisymm_label();
 
     std::wstring core_label;
     if ((this->symmetry() == Symmetry::Antisymm) && add_bar)
@@ -809,22 +812,14 @@ static_assert(is_tensor_v<Tensor>,
 
 using TensorPtr = std::shared_ptr<Tensor>;
 
-/// overlap/metric tensor label is reserved since it is used by low-level
-/// SeQuant machinery. Users can create overlap Tensor using make_overlap()
-inline std::wstring overlap_label() { return L"s"; }
-
 inline ExprPtr make_overlap(const Index &bra_index, const Index &ket_index) {
-  return ex<Tensor>(Tensor(overlap_label(), bra{bra_index}, ket{ket_index},
-                           aux{}, Tensor::reserved_tag{}));
+  return ex<Tensor>(Tensor(reserved::overlap_label(), bra{bra_index},
+                           ket{ket_index}, aux{}, Tensor::reserved_tag{}));
 }
 
-/// kronecker tensor label is reserved since it is used by low-level
-/// SeQuant machinery. Users can create Kronecker Tensor using make_kronecker()
-inline std::wstring kronecker_label() { return L"δ"; }
-
 inline ExprPtr make_kronecker(const Index &bra_index, const Index &ket_index) {
-  return ex<Tensor>(Tensor(kronecker_label(), bra{bra_index}, ket{ket_index},
-                           aux{}, Tensor::reserved_tag{}));
+  return ex<Tensor>(Tensor(reserved::kronecker_label(), bra{bra_index},
+                           ket{ket_index}, aux{}, Tensor::reserved_tag{}));
 }
 
 }  // namespace sequant

SeQuant/core/latex.ipp

@@ -165,6 +165,11 @@ std::basic_string<Char, Traits, Alloc> diactrics_to_latex_impl(
         case 0x30C:
           append_latex(SQ_STRLIT(Char, "\\check{"));
           continue;
+
+        // hat/circumflex
+        case 0x302:
+          append_latex(SQ_STRLIT(Char, "\\hat{"));
+          continue;
       }
     }
 
@@ -196,6 +201,30 @@ std::basic_string<Char, Traits, Alloc> diactrics_to_latex_impl(
           }
         }
       }  // tilde
+      {  // circumflex/hat
+         // lower-case characters with circumflex
+        const container::map<str_t, str_t> lc = {
+            {SQ_STRLIT(Char, "â"), SQ_STRLIT(Char, "\\hat{a}")},
+            {SQ_STRLIT(Char, "ê"), SQ_STRLIT(Char, "\\hat{e}")},
+            {SQ_STRLIT(Char, "î"), SQ_STRLIT(Char, "\\hat{i}")},
+            {SQ_STRLIT(Char, "ô"), SQ_STRLIT(Char, "\\hat{o}")}};
+        auto lc_it = lc.find(str_t{ch});
+        if (lc_it != lc.end()) {
+          append(lc_it->second);
+        } else {
+          // upper-case characters with circumflex
+          const container::map<str_t, str_t> uc = {
+              {SQ_STRLIT(Char, "Â"), SQ_STRLIT(Char, "\\hat{A}")},
+              {SQ_STRLIT(Char, "Ê"), SQ_STRLIT(Char, "\\hat{E}")},
+              {SQ_STRLIT(Char, "Î"), SQ_STRLIT(Char, "\\hat{I}")},
+              {SQ_STRLIT(Char, "Ô"), SQ_STRLIT(Char, "\\hat{O}")},
+              {SQ_STRLIT(Char, "Ŝ"), SQ_STRLIT(Char, "\\hat{S}")}};
+          auto uc_it = uc.find(str_t{ch});
+          if (uc_it != uc.end()) {
+            append(uc_it->second);
+          }
+        }
+      }  // circumflex/hat
     }
   }
 

SeQuant/core/reserved.hpp

@@ -0,0 +1,59 @@
+//
+// Created by Ajay Melekamburath on 12/24/25.
+//
+
+#ifndef SEQUANT_CORE_RESERVED_HPP
+#define SEQUANT_CORE_RESERVED_HPP
+
+#include <range/v3/algorithm/contains.hpp>
+
+#include <array>
+#include <string>
+
+namespace sequant {
+
+namespace reserved {
+/// @brief returns the reserved label for the antisymmetrization operator
+inline const std::wstring& antisymm_label() {
+  static const std::wstring label = L"Â";
+
+  return label;
+}
+
+/// @brief returns the reserved label for the symmetrization operator
+inline const std::wstring& symm_label() {
+  static const std::wstring label = L"Ŝ";
+  return label;
+}
+
+/// @brief overlap/metric tensor label is reserved since it is used by low-level
+/// SeQuant machinery. Users can create overlap Tensor using make_overlap()
+inline const std::wstring& overlap_label() {
+  static const std::wstring label = L"s";
+  return label;
+}
+
+/// @brief kronecker tensor label is reserved since it is used by low-level
+/// SeQuant machinery. Users can create Kronecker Tensor using make_kronecker()
+inline const std::wstring& kronecker_label() {
+  static const std::wstring label = L"δ";
+  return label;
+}
+
+/// @brief returns a list of all reserved operator labels
+inline const auto& labels() {
+  static const std::array reserved{antisymm_label(), symm_label(),
+                                   kronecker_label(), overlap_label()};
+  return reserved;
+}
+
+/// @brief checks if a label is not reserved
+inline bool is_nonreserved(const std::wstring& label) {
+  return !ranges::contains(labels(), label);
+}
+
+}  // namespace reserved
+
+}  // namespace sequant
+
+#endif  // SEQUANT_CORE_RESERVED_HPP

SeQuant/core/tensor_canonicalizer.cpp

@@ -6,6 +6,7 @@
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/index.hpp>
 #include <SeQuant/core/meta.hpp>
+#include <SeQuant/core/reserved.hpp>
 #include <SeQuant/core/tensor_canonicalizer.hpp>
 
 #include <regex>
@@ -169,12 +170,55 @@ TensorCanonicalizer::instance_map_accessor() {
   return std::make_pair(&map_, std::unique_lock<std::recursive_mutex>{mtx_});
 }
 
+container::vector<std::wstring>&
+TensorCanonicalizer::default_cardinal_tensor_labels_accessor() {
+  // {antisymm_label, symm_label} is the default
+  static container::vector<std::wstring> default_ctlabels_{
+      reserved::antisymm_label(), reserved::symm_label()};
+  return default_ctlabels_;
+}
+
 container::vector<std::wstring>&
 TensorCanonicalizer::cardinal_tensor_labels_accessor() {
-  static container::vector<std::wstring> ctlabels_;
+  static container::vector<std::wstring> ctlabels_ =
+      default_cardinal_tensor_labels_accessor();
   return ctlabels_;
 }
 
+void TensorCanonicalizer::set_cardinal_tensor_labels(
+    const container::vector<std::wstring>& labels) {
+  // check for duplicates
+#ifdef SEQUANT_ASSERT_ENABLED
+  // check for duplicates within user provided labels
+  auto sorted_labels = labels;
+  ranges::sort(sorted_labels);
+  auto duplicate = ranges::adjacent_find(sorted_labels);
+  SEQUANT_ASSERT(duplicate == sorted_labels.end() &&
+                 "cardinal tensor labels must not contain duplicates");
+
+  // check if any label conflicts with existing ones
+  const auto& existing = cardinal_tensor_labels_accessor();
+  for (const auto& label : labels) {
+    auto conflict = ranges::find(existing, label);
+    SEQUANT_ASSERT(conflict == existing.end() &&
+                   "cardinal tensor labels must not contain duplicates");
+  }
+#endif
+  auto& ctlabels = cardinal_tensor_labels_accessor();
+  // get defaults
+  ctlabels = default_cardinal_tensor_labels_accessor();
+  // append
+  ctlabels.insert(ctlabels.end(), labels.begin(), labels.end());
+}
+
+void TensorCanonicalizer::reset_cardinal_tensor_labels() {
+  cardinal_tensor_labels_accessor() = default_cardinal_tensor_labels_accessor();
+}
+
+void TensorCanonicalizer::clear_all_cardinal_tensor_labels() {
+  cardinal_tensor_labels_accessor().clear();
+}
+
 std::shared_ptr<TensorCanonicalizer>
 TensorCanonicalizer::nondefault_instance_ptr(std::wstring_view label) {
   auto&& [map_ptr, lock] = instance_map_accessor();

SeQuant/core/tensor_canonicalizer.hpp

@@ -73,12 +73,20 @@ class TensorCanonicalizer {
     return cardinal_tensor_labels_accessor();
   }
 
-  /// @param labels a list of Tensor labels with lexicographic
+  /// @brief Sets cardinal tensor labels by appending to defaults
+  /// @param labels a list of additional Tensor labels with lexicographic
   /// preference (in order)
+  /// @note The default labels are always prepended to the provided labels
+  /// @note To restore defaults only, use reset_cardinal_tensor_labels()
   static void set_cardinal_tensor_labels(
-      const container::vector<std::wstring>& labels) {
-    cardinal_tensor_labels_accessor() = labels;
-  }
+      const container::vector<std::wstring>& labels);
+
+  /// @brief Resets cardinal tensor labels to default values only
+  static void reset_cardinal_tensor_labels();
+
+  /// @brief Clears all cardinal tensor labels including defaults (sets to empty
+  /// list)
+  static void clear_all_cardinal_tensor_labels();
 
   /// @return a side effect of canonicalization (e.g. phase), or nullptr if none
   /// @internal what should be returned if canonicalization requires
@@ -122,6 +130,8 @@ class TensorCanonicalizer {
       std::unique_lock<std::recursive_mutex>>
   instance_map_accessor();  // map* + locked recursive mutex
   static container::vector<std::wstring>& cardinal_tensor_labels_accessor();
+  static container::vector<std::wstring>&
+  default_cardinal_tensor_labels_accessor();
 };
 
 /// @brief null Tensor canonicalizer does nothing

SeQuant/core/utility/expr.cpp

@@ -1,5 +1,6 @@
 #include <SeQuant/core/container.hpp>
 #include <SeQuant/core/expr.hpp>
+#include <SeQuant/core/reserved.hpp>
 #include <SeQuant/core/utility/expr.hpp>
 #include <SeQuant/core/utility/indices.hpp>
 #include <SeQuant/core/utility/macros.hpp>
@@ -386,8 +387,8 @@ bool is_valid(const ResultExpr &expr, std::string *msg) {
   // We need to make sure to remove any symmetrizers from the expression in
   // order to not mess up the determination of external indices
   ExprPtr rhs = expr.expression().clone();
-  pop_tensor(rhs, L"A");
-  pop_tensor(rhs, L"S");
+  pop_tensor(rhs, reserved::antisymm_label());
+  pop_tensor(rhs, reserved::symm_label());
 
   IndexGroups<> externals = get_unique_indices(rhs);
 

SeQuant/core/utility/indices.hpp

@@ -5,6 +5,7 @@
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/index.hpp>
 #include <SeQuant/core/op.hpp>
+#include <SeQuant/core/reserved.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 
 #include <range/v3/view.hpp>
@@ -462,8 +463,9 @@ Container external_indices(const Expr& expr) {
   std::optional<Tensor> symmetrizer;
   expr.visit(
       [&](const ExprPtr& expr) {
-        if (expr.is<Tensor>() && (expr.as<Tensor>().label() == L"S" ||
-                                  expr.as<Tensor>().label() == L"A")) {
+        if (expr.is<Tensor>() &&
+            (expr.as<Tensor>().label() == reserved::symm_label() ||
+             expr.as<Tensor>().label() == reserved::antisymm_label())) {
           SEQUANT_ASSERT(!symmetrizer.has_value() ||
                          symmetrizer.value() == expr.as<Tensor>());
           symmetrizer = expr.as<Tensor>();

SeQuant/core/wick.impl.hpp

@@ -7,6 +7,7 @@
 
 #include <SeQuant/core/bliss.hpp>
 #include <SeQuant/core/logger.hpp>
+#include <SeQuant/core/reserved.hpp>
 #include <SeQuant/core/tensor_canonicalizer.hpp>
 #include <SeQuant/core/tensor_network.hpp>
 #include <SeQuant/core/tensor_network/vertex.hpp>
@@ -350,6 +351,9 @@ compute_index_replacement_rules(
     }
   };
 
+  using sequant::reserved::kronecker_label;
+  using sequant::reserved::overlap_label;
+
   /// this makes the list of replacements ... we do not mutate the expressions
   /// to keep the information about which indices are related
   for (auto it = ranges::begin(exrng); it != ranges::end(exrng); ++it) {
@@ -456,6 +460,9 @@ inline bool apply_index_replacement_rules(
   do {
     pass_mutated = false;
 
+    using sequant::reserved::kronecker_label;
+    using sequant::reserved::overlap_label;
+
     for (auto it = ranges::begin(exrng); it != ranges::end(exrng);) {
       const auto &factor = *it;
       if (factor->is<AbstractTensor>()) {
@@ -514,6 +521,9 @@ bool reduce_wick_impl(std::shared_ptr<Product> &expr,
   // every pass
   const auto have_noncovariant_indices = !noncovariant_indices.empty();
 
+  using sequant::reserved::kronecker_label;
+  using sequant::reserved::overlap_label;
+
   if (Logger::instance().wick_reduce) {
     sequant::wprintf(
         "reduce_wick_impl(expr, external_indices):\n input expr = ",

SeQuant/domain/mbpt/biorthogonalization.cpp

@@ -4,6 +4,7 @@
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/index.hpp>
 #include <SeQuant/core/math.hpp>
+#include <SeQuant/core/reserved.hpp>
 #include <SeQuant/core/utility/expr.hpp>
 #include <SeQuant/core/utility/indices.hpp>
 #include <SeQuant/core/utility/macros.hpp>
@@ -314,8 +315,9 @@ void biorthogonal_transform(container::svector<ResultExpr>& result_exprs,
         bool found = false;
         res.expression()->visit(
             [&](const ExprPtr& expr) {
-              if (expr->is<Tensor>() && (expr->as<Tensor>().label() == L"S" ||
-                                         expr->as<Tensor>().label() == L"A")) {
+              if (expr->is<Tensor>() &&
+                  (expr->as<Tensor>().label() == reserved::symm_label() ||
+                   expr->as<Tensor>().label() == reserved::antisymm_label())) {
                 found = true;
               };
             },