add xmg & xag optimization

src/commands/balance.hpp

@@ -15,6 +15,8 @@
 
 #include <algorithm>
 #include <mockturtle/algorithms/aig_balancing.hpp>
+#include <mockturtle/algorithms/balancing.hpp>
+#include <mockturtle/algorithms/balancing/sop_balancing.hpp>
 #include <mockturtle/networks/aig.hpp>
 #include <mockturtle/views/depth_view.hpp>
 #include <vector>
@@ -22,6 +24,7 @@
 #include "../core/misc.hpp"
 
 using namespace std;
+using namespace mockturtle;
 
 namespace alice {
 
@@ -30,6 +33,7 @@ class balance_command : public command {
   explicit balance_command(const environment::ptr& env)
       : command(env,
                 "transforms the current network into a well-balanced AIG") {
+    add_flag("--xmg, -x", "Balance for XMG");
     add_flag("--strash, -s", "Balance AND finding structural hashing");
     add_flag("--verbose, -v", "print the information");
   }
@@ -38,7 +42,18 @@ class balance_command : public command {
   void execute() {
     clock_t begin, end;
     double totalTime = 0.0;
+    if (is_set("xmg")) {
+      xmg_network xmg = store<xmg_network>().current();
+      xmg = balancing(
+          xmg,
+          {sop_rebalancing<xmg_network>{}});  // TODO: we need maj-xor balancing
+      xmg = cleanup_dangling(xmg);
+      auto xmg_copy = cleanup_dangling(xmg);
+      phyLS::print_stats(xmg_copy);
 
+      store<xmg_network>().extend();
+      store<xmg_network>().current() = xmg_copy;
+    } else {
       if (store<aig_network>().size() == 0u)
         std::cerr << "Error: Empty AIG network\n";
       else {
@@ -61,6 +76,7 @@ class balance_command : public command {
         store<aig_network>().extend();
         store<aig_network>().current() = aig;
       }
+    }
 
     cout.setf(ios::fixed);
     cout << "[CPU time]   " << setprecision(2) << totalTime << " s" << endl;

src/commands/xag/rm.hpp

@@ -0,0 +1,139 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2022-2023 */
+
+/**
+ * @file rm_multi.hpp
+ *
+ * @brief RM logic optimization
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#ifndef RM_MP_HPP
+#define RM_MP_HPP
+
+#include <time.h>
+
+#include <mockturtle/mockturtle.hpp>
+
+#include "../../core/rm.hpp"
+
+namespace alice {
+
+class xagopt_command : public command {
+ public:
+  explicit xagopt_command(const environment::ptr& env)
+      : command(env, "Performs two-level RM logic optimization") {
+    add_option("strategy, -s", strategy, "cut = 0, mffc = 1");
+    add_flag("--minimum_and_gates, -m",
+             "minimum multiplicative complexity in XAG");
+    add_flag("--xag, -g", "RM logic optimization for xag network");
+    add_flag("--xmg, -x", "RM logic optimization for xmg network");
+    add_flag("--cec,-c", "apply equivalence checking in rewriting");
+  }
+
+  rules validity_rules() const {
+    if (is_set("xmg")) {
+      return {has_store_element<xmg_network>(env),
+              {[this]() { return (strategy <= 1 && strategy >= 0); },
+               "strategy must in [0,1] "}};
+    }
+
+    return {has_store_element<xag_network>(env),
+            {[this]() { return (strategy <= 1 && strategy >= 0); },
+             "strategy must in [0,1] "}};
+  }
+
+ protected:
+  void execute() {
+    if (is_set("xag")) {
+      // clock_t start, end;
+      // start = clock();
+      mockturtle::xag_network xag = store<xag_network>().current();
+      /* parameters */
+      ps_ntk.multiplicative_complexity = is_set("minimum_and_gates");
+
+      if (strategy == 0)
+        ps_ntk.strategy = rm_rewriting_params::cut;
+      else if (strategy == 1)
+        ps_ntk.strategy = rm_rewriting_params::mffc;
+      else
+        assert(false);
+
+      xag_network xag1, xag2;
+      xag1 = xag;
+
+      depth_view depth_xag1(xag);
+      rm_mixed_polarity(depth_xag1, ps_ntk);
+      xag = cleanup_dangling(xag);
+
+      xag2 = xag;
+
+      if (is_set("cec")) {
+        /* equivalence checking */
+        const auto miter_xag = *miter<xag_network>(xag1, xag2);
+        equivalence_checking_stats eq_st;
+        const auto result = equivalence_checking(miter_xag, {}, &eq_st);
+        assert(*result);
+      }
+
+      // end = clock();
+      //  std::cout << "run time: " << (double)(end - start) / CLOCKS_PER_SEC
+      //          << std::endl;
+      std::cout << "[rm_mixed_polarity] ";
+      phyLS::print_stats(xag);
+
+      store<xag_network>().extend();
+      store<xag_network>().current() = xag;
+
+    } else if (is_set("xmg")) {
+      // clock_t start, end;
+      // start = clock();
+      mockturtle::xmg_network xmg = store<xmg_network>().current();
+      /* parameters */
+      if (strategy == 0)
+        ps_ntk.strategy = rm_rewriting_params::cut;
+      else if (strategy == 1)
+        ps_ntk.strategy = rm_rewriting_params::mffc;
+      else
+        assert(false);
+
+      xmg_network xmg1, xmg2;
+      xmg1 = xmg;
+
+      depth_view depth_xmg1(xmg);
+      rm_mixed_polarity(depth_xmg1, ps_ntk);
+      xmg = cleanup_dangling(xmg);
+
+      xmg2 = xmg;
+
+      if (is_set("cec")) {
+        /* equivalence checking */
+        const auto miter_xmg = *miter<xmg_network>(xmg1, xmg2);
+        equivalence_checking_stats eq_st;
+        const auto result = equivalence_checking(miter_xmg, {}, &eq_st);
+        assert(*result);
+      }
+
+      // end = clock();
+      //  std::cout << "run time: " << (double)(end - start) / CLOCKS_PER_SEC
+      //           << std::endl;
+      std::cout << "[rm_mixed_polarity] ";
+      phyLS::print_stats(xmg);
+
+      store<xmg_network>().extend();
+      store<xmg_network>().current() = xmg;
+    }
+  }
+
+ private:
+  int strategy = 0;
+  rm_rewriting_params ps_ntk;
+};
+
+ALICE_ADD_COMMAND(xagopt, "Synthesis")
+
+}  // namespace alice
+
+#endif

src/commands/xag/rm2.hpp

@@ -0,0 +1,151 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2022-2023 */
+
+/**
+ * @file rm_multi.hpp
+ *
+ * @brief Multilevel RM logic optimization
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#ifndef RM_MP2_HPP
+#define RM_MP2_HPP
+
+#include <time.h>
+
+#include <mockturtle/mockturtle.hpp>
+
+#include "../../core/rm_multi.hpp"
+
+namespace alice {
+
+class xagopt2_command : public command {
+ public:
+  explicit xagopt2_command(const environment::ptr& env)
+      : command(env, "Performs multi-level RM logic optimization") {
+    add_option("strategy, -s", strategy, "cut = 0, mffc = 1");
+    add_flag("--minimum_and_gates, -m",
+             "minimum multiplicative complexity in XAG");
+    add_flag("--xag, -g", "RM logic optimization for xag network");
+    add_flag("--xmg, -x", "RM logic optimization for xmg network");
+    add_flag("--cec,-c", "apply equivalence checking in rewriting");
+  }
+
+  rules validity_rules() const {
+    if (is_set("xmg")) {
+      return {has_store_element<xmg_network>(env),
+              {[this]() { return (strategy <= 1 && strategy >= 0); },
+               "strategy must in [0,1] "}};
+    }
+
+    return {has_store_element<xag_network>(env),
+            {[this]() { return (strategy <= 1 && strategy >= 0); },
+             "strategy must in [0,1] "}};
+  }
+
+ protected:
+  void execute() {
+    if (is_set("xag")) {
+      // clock_t start, end;
+      // start = clock();
+      mockturtle::xag_network xag = store<xag_network>().current();
+      /* parameters */
+      ps_ntk.multiplicative_complexity = is_set("minimum_and_gates");
+
+      if (strategy == 0)
+        ps_ntk.strategy = rm_rewriting_params2::cut;
+      else if (strategy == 1)
+        ps_ntk.strategy = rm_rewriting_params2::mffc;
+      else
+        assert(false);
+
+      xag_network xag1, xag2;
+      xag1 = xag;
+
+      // depth_view<mockturtle::xag_network,unit_cost<mockturtle::xag_network>>
+      // depth_xag1(xag);
+      cut_rewriting_params ps;
+      ps.cut_enumeration_ps.cut_size = 6;
+      ps.cut_enumeration_ps.cut_limit = 12;
+      ps.min_cand_cut_size = 2;
+      ps.allow_zero_gain = true;
+      ps.progress = true;
+      rm_mixed_polarity2(xag, ps_ntk, ps);
+      xag = cleanup_dangling(xag);
+
+      xag2 = xag;
+
+      if (is_set("cec")) {
+        /* equivalence checking */
+        const auto miter_xag = *miter<xag_network>(xag1, xag2);
+        equivalence_checking_stats eq_st;
+        const auto result = equivalence_checking(miter_xag, {}, &eq_st);
+        assert(*result);
+      }
+
+      // end = clock();
+      //  std::cout << "run time: " << (double)(end - start) / CLOCKS_PER_SEC
+      //          << std::endl;
+      std::cout << "[rm_mixed_polarity] ";
+      phyLS::print_stats(xag);
+
+      store<xag_network>().extend();
+      store<xag_network>().current() = xag;
+
+    } else if (is_set("xmg")) {
+      // clock_t start, end;
+      // start = clock();
+      mockturtle::xmg_network xmg = store<xmg_network>().current();
+      /* parameters */
+      if (strategy == 0)
+        ps_ntk.strategy = rm_rewriting_params2::cut;
+      else if (strategy == 1)
+        ps_ntk.strategy = rm_rewriting_params2::mffc;
+      else
+        assert(false);
+
+      xmg_network xmg1, xmg2;
+      xmg1 = xmg;
+
+      cut_rewriting_params ps;
+      ps.cut_enumeration_ps.cut_size = 6;
+      ps.cut_enumeration_ps.cut_limit = 12;
+      ps.min_cand_cut_size = 2;
+      ps.allow_zero_gain = true;
+      ps.progress = true;
+      rm_mixed_polarity2(xmg, ps_ntk, ps);
+      xmg = cleanup_dangling(xmg);
+
+      xmg2 = xmg;
+
+      if (is_set("cec")) {
+        /* equivalence checking */
+        const auto miter_xmg = *miter<xmg_network>(xmg1, xmg2);
+        equivalence_checking_stats eq_st;
+        const auto result = equivalence_checking(miter_xmg, {}, &eq_st);
+        assert(*result);
+      }
+
+      // end = clock();
+      //  std::cout << "run time: " << (double)(end - start) / CLOCKS_PER_SEC
+      //           << std::endl;
+      std::cout << "[rm_mixed_polarity] ";
+      phyLS::print_stats(xmg);
+
+      store<xmg_network>().extend();
+      store<xmg_network>().current() = xmg;
+    }
+  }
+
+ private:
+  int strategy = 0;
+  rm_rewriting_params2 ps_ntk;
+};
+
+ALICE_ADD_COMMAND(xagopt2, "Synthesis")
+
+}  // namespace alice
+
+#endif

src/commands/xag/xagrs.hpp

@@ -0,0 +1,64 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2023 */
+
+/**
+ * @file xagrs.hpp
+ *
+ * @brief XAG resubsitution
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#ifndef XAGRS_HPP
+#define XAGRS_HPP
+
+#include <mockturtle/mockturtle.hpp>
+#include <mockturtle/algorithms/resubstitution.hpp>
+#include <mockturtle/networks/xag.hpp>
+
+#include "../../core/misc.hpp"
+
+namespace alice
+{
+
+  class xagrs_command : public command
+  {
+    public:
+      explicit xagrs_command( const environment::ptr& env ) : command( env, "Performs XAG resubsitution" )
+      {
+        add_flag( "-v,--verbose", ps.verbose, "show statistics" );
+      }
+      
+      rules validity_rules() const
+      {
+        return { has_store_element<xag_network>( env ) };
+      }
+
+    protected:
+      void execute()
+      {
+        /* derive some XAG */
+         xag_network xag = store<xag_network>().current();
+
+         default_resubstitution( xag, ps, &st );
+         xag = cleanup_dangling( xag );
+         
+         std::cout << "[xagrs] "; 
+         phyLS::print_stats( xag ); 
+
+         store<xag_network>().extend(); 
+         store<xag_network>().current() = xag;
+      }
+    
+    private:
+      resubstitution_params ps;
+      resubstitution_stats  st;
+  };
+  
+  ALICE_ADD_COMMAND( xagrs, "Synthesis" )
+
+
+}
+
+#endif

src/commands/xag/xagrw.hpp

@@ -0,0 +1,95 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2023 */
+
+/**
+ * @file xagrw.hpp
+ *
+ * @brief XAG rewriting
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#ifndef XAGRW_HPP
+#define XAGRW_HPP
+
+#include <mockturtle/algorithms/equivalence_checking.hpp>
+#include <mockturtle/algorithms/xag_optimization.hpp>
+#include <mockturtle/mockturtle.hpp>
+#include <mockturtle/networks/xag.hpp>
+#include <mockturtle/properties/migcost.hpp>
+
+#include "../../core/misc.hpp"
+#include "../../core/xag_rewriting.hpp"
+// #include <kitty/print.hpp>
+
+namespace alice {
+
+class xagrw_command : public command {
+ public:
+  explicit xagrw_command(const environment::ptr& env)
+      : command(env, "Performs XAG rewriting") {
+    add_option("strategy, -s", strategy,
+               "aggressive = 0, selective = 1, dfs = 2");
+    add_flag("--cec, -c,", "apply equivalence checking in rewriting");
+    add_flag("-v,--verbose", "show statistics");
+  }
+
+  rules validity_rules() const {
+    return {has_store_element<xag_network>(env),
+            {[this]() { return (strategy <= 2 && strategy >= 0); },
+             "strategy must in [0,2] "}};
+  }
+
+ protected:
+  void execute() {
+    xag_network xag = store<xag_network>().current();
+    unsigned num_inv_ori = num_inverters(xag);
+
+    if (strategy == 0) {
+      ps_xag.strategy = xag_depth_rewriting_params::aggressive;
+    } else if (strategy == 1) {
+      ps_xag.strategy = xag_depth_rewriting_params::selective;
+    } else if (strategy == 2) {
+      ps_xag.strategy = xag_depth_rewriting_params::dfs;
+    } else {
+      assert(false);
+    }
+
+    xag_network xag1, xag2;
+    xag1 = xag;
+
+    depth_view depth_xag1(xag);
+    xag_depth_rewriting(depth_xag1, ps_xag);
+    xag = cleanup_dangling(xag);
+
+    xag2 = xag;
+
+    if (is_set("cec")) {
+      /* equivalence checking */
+      const auto miter_xag = *miter<xag_network>(xag1, xag2);
+      equivalence_checking_stats eq_st;
+      const auto result = equivalence_checking(miter_xag, {}, &eq_st);
+      assert(*result);
+    }
+
+    unsigned num_inv_opt = num_inverters(xag);
+
+    std::cout << "[xagrw] ";
+    phyLS::print_stats(xag);
+    // std::cout << "num_inv_ori:" << num_inv_ori <<std::endl;
+    // std::cout << "num_inv_opt:" << num_inv_opt << std::endl;
+
+    store<xag_network>().extend();
+    store<xag_network>().current() = xag;
+  }
+
+ private:
+  xag_depth_rewriting_params ps_xag;
+  int strategy = 0;
+};
+
+ALICE_ADD_COMMAND(xagrw, "Synthesis")
+}  // namespace alice
+
+#endif

src/commands/xmg/xmginv.hpp

@@ -16,7 +16,7 @@
 #include <mockturtle/mockturtle.hpp>
 #include <mockturtle/utils/stopwatch.hpp>
 
-#include "../core/xmginv.hpp"
+#include "../../core/xmginv.hpp"
 
 namespace alice {
 

src/commands/xmg/xmgrs.hpp

@@ -0,0 +1,75 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2023 */
+
+/**
+ * @file xmgrs.hpp
+ *
+ * @brief XMG resubsitution
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#ifndef XMGRS_HPP
+#define XMGRS_HPP
+
+#include <mockturtle/algorithms/xmg_resub.hpp>
+#include <mockturtle/mockturtle.hpp>
+#include <mockturtle/networks/xmg.hpp>
+
+#include "../../core/misc.hpp"
+
+namespace alice {
+
+class xmgrs_command : public command {
+ public:
+  explicit xmgrs_command(const environment::ptr& env)
+      : command(env, "Performs XMG resubsitution") {
+    add_flag("-v,--verbose", ps.verbose, "show statistics");
+    add_flag("--cec,-c", "apply equivalence checking in resubstitution");
+  }
+
+  rules validity_rules() const { return {has_store_element<xmg_network>(env)}; }
+
+ protected:
+  void execute() {
+    /* derive some XMG */
+    xmg_network xmg = store<xmg_network>().current();
+
+    xmg_network xmg1, xmg2;
+    xmg1 = xmg;
+    xmg2 = xmg;
+
+    using view_t = depth_view<fanout_view<xmg_network>>;
+    fanout_view<xmg_network> fanout_view{xmg1};
+    view_t resub_view{fanout_view};
+    xmg_resubstitution(resub_view);
+    xmg2 = cleanup_dangling(xmg1);
+
+    std::cout << "[xmgrs] ";
+    auto xmg_copy = cleanup_dangling(xmg2);
+    phyLS::print_stats(xmg_copy);
+
+    if (is_set("cec")) {
+      const auto miter_xmg = *miter<xmg_network>(xmg1, xmg2);
+      equivalence_checking_stats eq_st;
+      const auto result = equivalence_checking(miter_xmg, {}, &eq_st);
+      assert(result);
+      assert(*result);
+      std::cout << "Network is equivalent after resub\n";
+    }
+
+    store<xmg_network>().extend();
+    store<xmg_network>().current() = xmg2;
+  }
+
+ private:
+  resubstitution_params ps;
+  resubstitution_stats st;
+};
+
+ALICE_ADD_COMMAND(xmgrs, "Synthesis")
+
+}  // namespace alice
+
+#endif

src/commands/xmg/xmgrw.hpp

@@ -0,0 +1,145 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2023 */
+
+/**
+ * @file xmgrw.hpp
+ *
+ * @brief algebraic XMG rewriting
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#ifndef XMGRW_COMMAND_HPP
+#define XMGRW_COMMAND_HPP
+
+#include <mockturtle/algorithms/equivalence_checking.hpp>
+#include <mockturtle/algorithms/mig_algebraic_rewriting.hpp>
+#include <mockturtle/networks/xmg.hpp>
+#include <mockturtle/views/depth_view.hpp>
+
+#include "../../core/misc.hpp"
+#include "../../core/xmg_expand.hpp"
+#include "../../core/xmg_extract.hpp"
+#include "../../core/xmg_rewriting.hpp"
+
+namespace alice {
+
+class xmgrw_command : public command {
+ public:
+  explicit xmgrw_command(const environment::ptr& env)
+      : command(env, "Performs algebraic XMG rewriting") {
+    add_option("strategy, -s", strategy,
+               "qca = 0, aggressive = 1, selective = 2, dfs = 3");
+    add_flag("--area_aware, -a", "do not increase area");
+    add_flag("--xor3_flattan", "flattan xor3 to 2 xor2s");
+    add_flag("--only_maj", "apply mig_algebraic_depth_rewriting method");
+    add_flag("--cec,-c", "apply equivalence checking in rewriting");
+    add_flag("--expand,-e", "apply xor expand through maj");
+    add_flag("--hunt_constant_xor,-u", "hunt XOR constant nodes");
+  }
+
+  rules validity_rules() const {
+    return {has_store_element<xmg_network>(env),
+            {[this]() { return (strategy <= 3 && strategy >= 0); },
+             "strategy must in [0,3] "}};
+  }
+
+ protected:
+  void execute() {
+    xmg_network xmg = store<xmg_network>().current();
+
+    if (is_set("only_maj")) {
+      /* parameters */
+      ps_mig.allow_area_increase = !is_set("area_aware");
+
+      if (strategy == 0) {
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::dfs;
+      } else if (strategy == 1) {
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::aggressive;
+      } else if (strategy == 2) {
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::selective;
+      } else {
+        assert(false);
+      }
+
+      depth_view depth_xmg{xmg};
+      mig_algebraic_depth_rewriting(depth_xmg, ps_mig);
+      xmg = cleanup_dangling(xmg);
+    } else if (is_set("hunt_constant_xor")) {
+      auto xors = phyLS::xmg_extract(xmg);
+      ps_expand.strategy = xmg_expand_rewriting_params::constants;
+      ps_expand.xor_index = xors;
+
+      depth_view depth_xmg{xmg};
+      xmg_expand_rewriting(depth_xmg, ps_expand);
+      xmg = cleanup_dangling(xmg);
+    } else if (is_set("expand")) {
+      ps_expand.strategy = xmg_expand_rewriting_params::expand;
+      depth_view depth_xmg{xmg};
+      xmg_expand_rewriting(depth_xmg, ps_expand);
+      xmg = cleanup_dangling(xmg);
+    } else {
+      /* parameters */
+      ps_xmg.allow_area_increase = !is_set("area_aware");
+      ps_xmg.apply_xor3_to_xor2 = is_set("xor3_flattan");
+      ps_mig.allow_area_increase = !is_set("area_aware");
+
+      if (strategy == 0) {
+        ps_xmg.strategy = xmg_depth_rewriting_params::qca;
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::dfs;
+      } else if (strategy == 1) {
+        ps_xmg.strategy = xmg_depth_rewriting_params::aggressive;
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::aggressive;
+      } else if (strategy == 2) {
+        ps_xmg.strategy = xmg_depth_rewriting_params::selective;
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::selective;
+      } else if (strategy == 3) {
+        ps_xmg.strategy = xmg_depth_rewriting_params::dfs;
+        ps_mig.strategy = mig_algebraic_depth_rewriting_params::dfs;
+      } else {
+        assert(false);
+      }
+
+      xmg_network xmg1, xmg2;
+      xmg1 = xmg;
+
+      /* mig_algebraic_depth_rewriting is suitable for ntk that has majority
+       * nodes */
+      depth_view depth_xmg1{xmg};
+      mig_algebraic_depth_rewriting(depth_xmg1, ps_mig);
+      xmg = cleanup_dangling(xmg);
+
+      depth_view depth_xmg2{xmg};
+      xmg_depth_rewriting(depth_xmg2, ps_xmg);
+      xmg = cleanup_dangling(xmg);
+      xmg2 = xmg;
+
+      if (is_set("cec")) {
+        /* equivalence checking */
+        const auto miter_xmg = *miter<xmg_network>(xmg1, xmg2);
+        equivalence_checking_stats eq_st;
+        const auto result = equivalence_checking(miter_xmg, {}, &eq_st);
+        assert(*result);
+      }
+    }
+
+    std::cout << "[xmgrw] ";
+    auto xmg_copy = cleanup_dangling(xmg);
+    phyLS::print_stats(xmg_copy);
+
+    store<xmg_network>().extend();
+    store<xmg_network>().current() = xmg;
+  }
+
+ private:
+  mig_algebraic_depth_rewriting_params ps_mig;
+  xmg_depth_rewriting_params ps_xmg;
+  xmg_expand_rewriting_params ps_expand;
+  int strategy = 0;
+};
+
+ALICE_ADD_COMMAND(xmgrw, "Synthesis")
+}  // namespace alice
+
+#endif

src/core/rm.hpp

@@ -0,0 +1,824 @@
+/* phyLS: powerful heightened yielded Logic Synthesis
+ * Copyright (C) 2022-2023 */
+
+/**
+ * @file rm_multi.hpp
+ *
+ * @brief RM logic optimization
+ *
+ * @author Homyoung
+ * @since  2023/11/16
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <mockturtle/mockturtle.hpp>
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace mockturtle {
+
+/*! \brief Parameters for rm_logic_optimization.
+ *
+ * The data structure `rm_logic_optimization` holds configurable
+ * parameters with default arguments for `rm_logic_optimization`.
+ */
+struct rm_rewriting_params {
+  /*! \brief Rewriting strategy. */
+  enum strategy_t {
+    /*! \brief Cut is used to divide the network. */
+    cut,
+    /*! \brief mffc is used to divide the network. */
+    mffc,
+  } strategy = cut;
+
+  /*! \brief minimum multiplicative complexity in XAG. */
+  bool multiplicative_complexity{false};
+};
+
+namespace detail {
+
+template <class Ntk>
+class rm_mixed_polarity_impl {
+ public:
+  using node_t = node<Ntk>;
+  using signal_t = signal<Ntk>;
+
+  rm_mixed_polarity_impl(Ntk& ntk, rm_rewriting_params const& ps_ntk)
+      : ntk(ntk), ps_ntk(ps_ntk) {}
+
+  void run() {
+    switch (ps_ntk.strategy) {
+      case rm_rewriting_params::cut:
+        ntk_cut();
+        break;
+      case rm_rewriting_params::mffc:
+        ntk_mffc();
+        break;
+    }
+  }
+
+ private:
+  /**************************************************************************************************************/
+  /* for cost estimation we use reference counters initialized by the fanout
+   * size. */
+  void initialize_refs(Ntk& ntk1) {
+    ntk1.clear_values();
+    ntk1.foreach_node(
+        [&](auto const& n) { ntk1.set_value(n, ntk1.fanout_size(n)); });
+  }
+  /**************************************************************************************************************/
+  /* Count the number of and gates. */
+  int count_node_num(vector<string>& minterm, int variate_num,
+                     string polarity) {
+    int count = 0;
+    if (variate_num > 1) {
+      for (int i = 0; i < minterm.size(); i++) {
+        int count1 = 0;
+        for (int j = 0; j < variate_num; j++) {
+          if (minterm[i][j] == '1' || polarity[j] == '2') count1++;
+        }
+        if (count1 > 0) count = count + count1 - 1;
+      }
+    }
+
+    return count;
+  }
+  /**************************************************************************************************************/
+  /* Convert ternary to decimal. */
+  int atoint(string s, int radix) {
+    int ans = 0;
+    for (int i = 0; i < s.size(); i++) {
+      char t = s[i];
+      if (t >= '0' && t <= '9')
+        ans = ans * radix + t - '0';
+      else
+        ans = ans * radix + t - 'a' + 10;
+    }
+    return ans;
+  }
+  /**************************************************************************************************************/
+  /* Convert decimal to ternary. */
+  string intToA(int n, int radix) {
+    string ans = "";
+    do {
+      int t = n % radix;
+      if (t >= 0 && t <= 9)
+        ans += t + '0';
+      else
+        ans += t - 10 + 'a';
+      n /= radix;
+    } while (n != 0);
+    reverse(ans.begin(), ans.end());
+    return ans;
+  }
+  /**************************************************************************************************************/
+  /* create signal by expression. */
+  signal_t create_ntk_from_str(std::string const& s,
+                               std::vector<node_t> const& leaves) {
+    std::vector<signal_t> pis;
+    pis.clear();
+    for (const auto& l : leaves) {
+      pis.push_back(ntk.make_signal(l));
+    }
+
+    std::stack<signal_t> inputs;
+    int flag = 0;
+    int flag1 = 0;
+
+    for (auto i = 0; i < s.size(); i++) {
+      if (s[i] == '[') {
+        continue;
+      } else if (s[i] == '(') {
+        continue;
+      } else if (s[i] == '1') {
+        flag1 = 1;
+        continue;
+      } else if (s[i] >= 'a') {
+        if (flag == 1) {
+          inputs.push(ntk.create_not(pis[s[i] - 'a']));
+          flag = 0;
+        } else
+          inputs.push(pis[s[i] - 'a']);
+      } else if (s[i] == ')') {
+        auto x1 = inputs.top();
+        inputs.pop();
+
+        auto x2 = inputs.top();
+        inputs.pop();
+
+        inputs.push(ntk.create_and(x1, x2));
+      } else if (s[i] == ']') {
+        if (flag1 == 1) {
+          auto x1 = inputs.top();
+          inputs.pop();
+          inputs.push(ntk.create_not(x1));
+          flag1 = 0;
+        } else {
+          auto x1 = inputs.top();
+          inputs.pop();
+
+          auto x2 = inputs.top();
+          inputs.pop();
+          inputs.push(ntk.create_xor(x1, x2));
+        }
+      } else if (s[i] == '!') {
+        flag = 1;
+      }
+    }
+    return inputs.top();
+  }
+  /**************************************************************************************************************/
+  /* List all possible variable values/List truth table. */
+  vector<string> list_truth_table(int& variate_num) {
+    int a = pow(2, variate_num);
+    vector<int> b;
+    for (int i = 0; i < a; i++) {
+      b.push_back(i);
+    }
+    vector<string> binary;
+    for (int i = 0; i < a; i++) {
+      string binary1;
+      for (int j = variate_num - 1; j >= 0; j--) {
+        int d = ((b[i] >> j) & 1);
+        binary1 += d + 48;
+      }
+      binary.push_back(binary1);
+    }
+    return binary;
+  }
+  /**************************************************************************************************************/
+  /* List all possible polarity values. */
+  vector<string> list_all_polarities(int& variate_num) {
+    int a_1 = pow(2, variate_num);
+    vector<int> c;
+    for (int i = 0; i < a_1; i++) {
+      c.push_back(i);
+    }
+    vector<string> polarity1;
+    for (int i = 0; i < a_1; i++) {
+      string polarity2;
+      for (int j = variate_num - 1; j >= 0; j--) {
+        int d = ((c[i] >> j) & 1);
+        polarity2 += d + 48;
+      }
+      polarity1.push_back(polarity2);
+    }
+
+    /* Store all polarities. */
+    vector<string> polarity;
+    polarity.push_back(polarity1[0]);
+    int a2 = pow(3, variate_num);
+    string str1 = polarity1[0];
+    string str2 = polarity1[1];
+    for (int i = 0; i < a2 - 1; i++) {
+      int num1 = atoint(str1, 3);
+      int num2 = atoint(str2, 3);
+
+      int sum = num1 + num2;
+      string str3 = intToA(sum, 3);
+
+      str1 = "0";
+      if (str3.size() < variate_num) {
+        for (int i = 0; i < variate_num - str3.size() - 1; i++) str1 += '0';
+
+        str1 += str3;
+      } else
+        str1 = str3;
+
+      polarity.push_back(str1);
+    }
+    return polarity;
+  }
+  /**************************************************************************************************************/
+  /* Mixed polarity conversion algorithm based on list technique. */
+  vector<string> polarity_conversion(int& variate_num, vector<string>& minterm,
+                                     string& polarity) {
+    vector<string> RM_product = minterm;
+    string str;
+    for (int i = 0; i < variate_num; i++) {
+      for (int j = 0; j < RM_product.size(); j++) {
+        if (polarity[i] == '0') {
+          if (RM_product[j][i] == '0') {
+            str = RM_product[j];
+            str[i] = '1';
+            RM_product.push_back(str);
+          }
+        } else if (polarity[i] == '1') {
+          if (RM_product[j][i] == '1') {
+            str = RM_product[j];
+            str[i] = '0';
+            RM_product.push_back(str);
+          }
+        }
+      }
+      if (polarity[i] == '0') {
+        /* Delete the minimum number of even items. */
+        if (RM_product.size() > 0) {
+          sort(RM_product.begin(), RM_product.end());
+          for (int m = 0; m < RM_product.size() - 1; m++) {
+            if (RM_product[m] == RM_product[m + 1]) {
+              RM_product[m] = "0";
+              RM_product[m + 1] = "0";
+            }
+          }
+        }
+        /* Delete item with '0' in array. */
+        vector<string> final_term;
+        final_term.clear();
+        for (int m = 0; m < RM_product.size(); m++) {
+          if (RM_product[m] != "0") final_term.push_back(RM_product[m]);
+        }
+        RM_product.clear();
+        RM_product = final_term;
+      } else if (polarity[i] == '1') {
+        /* Delete the minimum number of even items. */
+        if (RM_product.size() > 0) {
+          sort(RM_product.begin(), RM_product.end());
+          for (int m = 0; m < RM_product.size() - 1; m++) {
+            if (RM_product[m] == RM_product[m + 1]) {
+              RM_product[m] = "0";
+              RM_product[m + 1] = "0";
+            }
+          }
+        }
+        /* Delete item with '0' in array. */
+        vector<string> final_term;
+        final_term.clear();
+        for (int m = 0; m < RM_product.size(); m++) {
+          if (RM_product[m] != "0") {
+            if (RM_product[m][i] == '0')
+              RM_product[m][i] = '1';
+            else if (RM_product[m][i] == '1')
+              RM_product[m][i] = '0';
+            final_term.push_back(RM_product[m]);
+          }
+        }
+        RM_product.clear();
+        RM_product = final_term;
+      }
+    }
+    return RM_product;
+  }
+  /**************************************************************************************************************/
+  /* Search for the optimal polarity and the corresponding product term. */
+  void search_for_optimal_polarity(vector<string>& minterm,
+                                   vector<string>& polarity, int& variate_num,
+                                   vector<string>& RM_product,
+                                   string& optimal_polarity) {
+    vector<string> RM_product_initial;
+    for (int l = 0; l < polarity.size(); l++) {
+      RM_product_initial =
+          polarity_conversion(variate_num, minterm, polarity[l]);
+
+      int count1, count2;
+      count1 = count_the_number_of_nodes(variate_num, RM_product_initial,
+                                         polarity[l]);
+      count2 =
+          count_the_number_of_nodes(variate_num, RM_product, optimal_polarity);
+      if (count1 < count2) {
+        optimal_polarity = polarity[l];
+        RM_product.clear();
+        RM_product = RM_product_initial;
+        RM_product_initial.clear();
+      } else {
+        RM_product_initial.clear();
+      }
+    }
+  }
+  /**************************************************************************************************************/
+  /* Count the number of nodes in the new network. */
+  int count_the_number_of_nodes(int& variate_num, vector<string>& RM_product,
+                                string& optimal_polarity) {
+    /* Count the number of nodes. */
+    int node_num = 0;
+    if (RM_product.size() > 1) node_num = RM_product.size() - 1;
+
+    if (variate_num > 1) {
+      for (int i = 0; i < RM_product.size(); i++) {
+        int n = 0;
+        for (int j = variate_num - 1; j >= 0; j--) {
+          if (RM_product[i][j] == '1' || optimal_polarity[j] == '2') n++;
+        }
+        if (n > 0) node_num = node_num + n - 1;
+      }
+    }
+    return node_num;
+  }
+  /**************************************************************************************************************/
+  /* Create expression. */
+  string create_expression(vector<string>& RM_product, int& variate_num,
+                           string& optimal_polarity, vector<string>& binary) {
+    string st = "abcdefghijklmnopqrstuvwxyz";
+    string expression = "";
+    if (RM_product.size() > 1)
+      for (int i = 0; i < RM_product.size() - 1; i++) expression += '[';
+    for (int i = 0; i < RM_product.size(); i++) {
+      int k = 0;
+      int l = 0;
+      int m = 0;
+      for (int j = variate_num - 1; j >= 0; j--) {
+        if (RM_product[i][j] == '1' || optimal_polarity[j] == '2') l++;
+      }
+      for (int j = 0; j < l - 1; j++) expression += '(';
+      for (int j = variate_num - 1; j >= 0; j--) {
+        if (optimal_polarity[j] == '0' && RM_product[i][j] == '1') {
+          expression += st[k];
+          m++;
+        } else if (optimal_polarity[j] == '1' && RM_product[i][j] == '1') {
+          expression += '!';
+          expression += st[k];
+          m++;
+        } else if (optimal_polarity[j] == '2' && RM_product[i][j] == '1') {
+          expression += st[k];
+          m++;
+        } else if (optimal_polarity[j] == '2' && RM_product[i][j] == '0') {
+          expression += '!';
+          expression += st[k];
+          m++;
+        }
+
+        if ((m > 1 && RM_product[i][j] == '1') ||
+            (m > 1 && optimal_polarity[j] == '2'))
+          expression += ')';
+        k++;
+      }
+      if (RM_product[i] == binary[0]) {
+        int flag = 0;
+        for (int m = variate_num - 1; m >= 0; m--) {
+          if (optimal_polarity[m] == '2') flag = 1;
+        }
+        if (flag == 0) expression += '1';
+      }
+      if (i > 0 && RM_product.size() > 1) expression += ']';
+    }
+    return expression;
+  }
+  /**************************************************************************************************************/
+  /* Replace network. */
+  void substitute_network_mffc(string& expression, std::vector<node_t>& leaves,
+                               node_t n) {
+    auto opt = create_ntk_from_str(expression, leaves);
+    ntk.substitute_node(n, opt);
+    ntk.set_value(n, 0);
+    ntk.set_value(ntk.get_node(opt), ntk.fanout_size(ntk.get_node(opt)));
+    for (auto i = 0u; i < leaves.size(); i++) {
+      ntk.set_value(leaves[i], ntk.fanout_size(leaves[i]));
+    }
+    ntk.update_levels();
+  }
+  /**************************************************************************************************************/
+  /* Replace network. */
+  void substitute_network_cut(string& expression, std::vector<node_t>& leaves,
+                              node_t n) {
+    auto opt = create_ntk_from_str(expression, leaves);
+    ntk.substitute_node(n, opt);
+    ntk.update_levels();
+  }
+  /**************************************************************************************************************/
+  /* get children of top node, ordered by node level (ascending). */
+  vector<signal<Ntk>> ordered_children(node<Ntk> const& n) const {
+    vector<signal<Ntk>> children;
+    ntk.foreach_fanin(n, [&children](auto const& f) { children.push_back(f); });
+    std::sort(
+        children.begin(), children.end(),
+        [this](auto const& c1, auto const& c2) {
+          if (ntk.level(ntk.get_node(c1)) == ntk.level(ntk.get_node(c2))) {
+            return c1.index < c2.index;
+          } else {
+            return ntk.level(ntk.get_node(c1)) < ntk.level(ntk.get_node(c2));
+          }
+        });
+    return children;
+  }
+  /**************************************************************************************************************/
+  /* Judge whether the leaf node is reached. */
+  int is_existence(long int root, vector<signal_t> pis) {
+    int flag = 0;
+    for (int i = 0; i < pis.size(); i++) {
+      if (root == ntk.get_node(pis[i])) {
+        flag = 1;
+        break;
+      }
+    }
+    return flag;
+  }
+  /**************************************************************************************************************/
+  /* Hierarchical ergodic statistics AND gates node cost function. */
+  void LevelOrder(long int root, vector<signal_t> pis,
+                  int& optimization_and_nodes) {
+    int a = 0;
+    int b = 0;
+    if (is_existence(root, pis) == 1) return;
+    /* Create a queue container. */
+    queue<long int> deq;
+
+    deq.push(root);
+    while (!deq.empty()) {
+      long int tr = deq.front();
+      deq.pop();
+
+      vector<signal<Ntk>> ocs;
+      ocs.clear();
+      /* get children of top node, ordered by node level (ascending). */
+      ocs = ordered_children(tr);
+
+      if (ocs.size() == 2 && is_existence(ntk.get_node(ocs[0]), pis) != 1) {
+        deq.push(ntk.get_node(ocs[0]));
+        if (ntk.is_and(ntk.get_node(ocs[0])) &&
+            ntk.fanout_size(ntk.get_node(ocs[0])) != 1u && a == 0) {
+          optimization_and_nodes = optimization_and_nodes - 1;
+          a = 1;
+        } else if (ntk.is_and(ntk.get_node(ocs[0])) && a == 1)
+          optimization_and_nodes = optimization_and_nodes - 1;
+      }
+
+      if (ocs.size() == 2 && is_existence(ntk.get_node(ocs[1]), pis) != 1) {
+        deq.push(ntk.get_node(ocs[1]));
+        if (ntk.is_and(ntk.get_node(ocs[1])) &&
+            ntk.fanout_size(ntk.get_node(ocs[1])) != 1u && b == 0) {
+          optimization_and_nodes = optimization_and_nodes - 1;
+          b = 1;
+        } else if (ntk.is_and(ntk.get_node(ocs[1])) && b == 1)
+          optimization_and_nodes = optimization_and_nodes - 1;
+      }
+    }
+  }
+  /**************************************************************************************************************/
+  /* Cut is used to divide the network. */
+  void ntk_cut() {
+    /* for cost estimation we use reference counters initialized by the fanout
+     * size. */
+    initialize_refs(ntk);
+
+    /* enumerate cuts */
+    cut_enumeration_params ps;
+    ps.cut_size = 6;
+    ps.cut_limit = 8;
+    ps.minimize_truth_table = true;
+    /* true enables truth table computation */
+    auto cuts = cut_enumeration<Ntk, true>(ntk, ps);
+
+    /* iterate over all original nodes in the network */
+    const auto size = ntk.size();
+    ntk.foreach_node([&](auto n, auto index) {
+      /* stop once all original nodes were visited */
+      if (index >= size) return false;
+
+      /* do not iterate over constants or PIs */
+      if (ntk.is_constant(n) || ntk.is_pi(n)) return true;
+
+      /* skip cuts with small MFFC */
+      if (mffc_size(ntk, n) == 1) return true;
+
+      /* foreach cut */
+      for (auto& cut : cuts.cuts(ntk.node_to_index(n))) {
+        /* skip trivial cuts */
+        if (cut->size() < 2) continue;
+
+        std::vector<node_t> leaves;
+        for (auto leaf_index : *cut) {
+          leaves.push_back(ntk.index_to_node(leaf_index));
+        }
+        cut_view<Ntk> dcut(ntk, leaves, ntk.make_signal(n));
+
+        if (dcut.num_gates() > 14) continue;
+
+        /* skip cuts with small MFFC */
+        int mffc_num_nodes = mffc_size(dcut, n);
+        if (mffc_num_nodes == 1) continue;
+
+        string tt = to_binary(cuts.truth_table(*cut));
+        string str = "1";
+
+        int index1 = tt.find(str);
+        if (index1 >= tt.length()) continue;
+
+        int len = tt.length();
+        /* Stores the number of input variables. */
+        int variate_num = log(len) / log(2);
+
+        /* List all possible variable values/List truth table. */
+        vector<string> binary = list_truth_table(variate_num);
+
+        /* Stores the output of the truth table. */
+        vector<char> c_out;
+        for (int i = len - 1; i >= 0; i--) {
+          c_out.push_back(tt[i]);
+        }
+
+        vector<char> c_out1;
+        /* Minimum item for storing binary. */
+        vector<string> minterm;
+        for (int i = 0; i < binary.size(); i++) {
+          if (c_out[i] != '0') {
+            minterm.push_back(binary[i]);
+            c_out1.push_back(c_out[i]);
+          }
+        }
+
+        /* Store all polarities. */
+        vector<string> polarity = list_all_polarities(variate_num);
+
+        /* Count the initial cost. */
+        /* Storage optimal polarity. */
+        string optimal_polarity = polarity[0];
+        /* Mixed polarity conversion algorithm based on list technique. */
+        vector<string> RM_product =
+            polarity_conversion(variate_num, minterm, optimal_polarity);
+
+        /* Search for the optimal polarity and the corresponding product term.
+         */
+        search_for_optimal_polarity(minterm, polarity, variate_num, RM_product,
+                                    optimal_polarity);
+
+        /* Count the number of nodes in the new network. */
+        int node_num_new = count_the_number_of_nodes(variate_num, RM_product,
+                                                     optimal_polarity);
+
+        if (ps_ntk.multiplicative_complexity == true) {
+          int optimization_nodes = dcut.num_gates() - node_num_new -
+                                   (dcut.num_gates() - mffc_num_nodes);
+          if (optimization_nodes > 0) {
+            std::vector<signal_t> pis;
+            pis.clear();
+            for (const auto& l : leaves) {
+              pis.push_back(ntk.make_signal(l));
+            }
+
+            int and_num = 0;
+            /* Count the number of and nodes in the new network. */
+            int and_num_new =
+                count_node_num(RM_product, variate_num, optimal_polarity);
+
+            dcut.foreach_gate([&](auto const& n1) {
+              if (ntk.is_and(n1)) and_num++;
+            });
+
+            int optimization_and_nodes = and_num - and_num_new;
+
+            /* Hierarchical ergodic statistics AND gates node cost function. */
+            LevelOrder(n, pis, optimization_and_nodes);
+
+            if (optimization_and_nodes >= 0) {
+              /* Create expression. */
+              string expression = create_expression(RM_product, variate_num,
+                                                    optimal_polarity, binary);
+
+              /* Replace network. */
+              substitute_network_cut(expression, leaves, n);
+            }
+          }
+        } else {
+          int optimization_nodes = dcut.num_gates() - node_num_new -
+                                   (dcut.num_gates() - mffc_num_nodes);
+
+          if (optimization_nodes > 0) {
+            /* Create expression. */
+            string expression = create_expression(RM_product, variate_num,
+                                                  optimal_polarity, binary);
+
+            /* Replace network. */
+            substitute_network_cut(expression, leaves, n);
+          }
+        }
+      }
+
+      return true;
+    });
+  }
+  /**************************************************************************************************************/
+  /* mffc is used to divide the network. */
+  void ntk_mffc() {
+    /* for cost estimation we use reference counters initialized by the fanout
+     * size. */
+    ntk.clear_visited();
+    ntk.clear_values();
+    ntk.foreach_node(
+        [&](auto const& n) { ntk.set_value(n, ntk.fanout_size(n)); });
+
+    /* iterate over all original nodes in the network */
+    const auto size = ntk.size();
+    ntk.foreach_node([&](auto n, auto index) {
+      /* stop once all original nodes were visited */
+      if (index >= size) return false;
+
+      if (ntk.fanout_size(n) == 0u) {
+        return true;
+      }
+
+      /* do not iterate over constants or PIs */
+      if (ntk.is_constant(n) || ntk.is_pi(n)) return true;
+
+      /* skip cuts with small MFFC */
+      if (mffc_size(ntk, n) == 1) return true;
+
+      mffc_view mffc{ntk, n};
+      if (mffc.num_pos() == 0 || mffc.num_pis() > 6) {
+        return true;
+      }
+
+      std::vector<node_t> leaves(mffc.num_pis());
+      mffc.foreach_pi([&](auto const& m, auto j) { leaves[j] = m; });
+
+      default_simulator<kitty::dynamic_truth_table> sim(mffc.num_pis());
+      string tt = to_binary(simulate<kitty::dynamic_truth_table>(mffc, sim)[0]);
+      string str = "1";
+
+      int index1 = tt.find(str);
+      if (index1 >= tt.length()) return true;
+
+      int len = tt.length();
+      /* Stores the number of input variables. */
+      int variate_num = log(len) / log(2);
+
+      /* List all possible variable values/List truth table. */
+      vector<string> binary = list_truth_table(variate_num);
+
+      /* Stores the output of the truth table. */
+      vector<char> c_out;
+      for (int i = len - 1; i >= 0; i--) {
+        c_out.push_back(tt[i]);
+      }
+
+      vector<char> c_out1;
+      /* Minimum item for storing binary. */
+      vector<string> minterm;
+      for (int i = 0; i < binary.size(); i++) {
+        if (c_out[i] != '0') {
+          minterm.push_back(binary[i]);
+          c_out1.push_back(c_out[i]);
+        }
+      }
+
+      /* Store all polarities. */
+      vector<string> polarity = list_all_polarities(variate_num);
+
+      /* Count the initial cost. */
+      /* Storage optimal polarity. */
+      string optimal_polarity = polarity[0];
+      /* Mixed polarity conversion algorithm based on list technique. */
+      vector<string> RM_product =
+          polarity_conversion(variate_num, minterm, optimal_polarity);
+
+      /* Search for the optimal polarity and the corresponding product term. */
+      search_for_optimal_polarity(minterm, polarity, variate_num, RM_product,
+                                  optimal_polarity);
+
+      /* Count the number of nodes in the new network. */
+      int node_num_new =
+          count_the_number_of_nodes(variate_num, RM_product, optimal_polarity);
+
+      if (ps_ntk.multiplicative_complexity == true) {
+        /* Count the number of and nodes in the new network. */
+        int and_num_new =
+            count_node_num(RM_product, variate_num, optimal_polarity);
+        int and_num = 0;
+        mffc.foreach_gate([&](auto const& n1, auto i) {
+          if (ntk.is_and(n1)) and_num++;
+        });
+
+        int optimization_nodes = mffc.num_gates() - node_num_new;
+        int optimization_and_nodes = and_num - and_num_new;
+
+        if (optimization_nodes > 0 && optimization_and_nodes >= 0) {
+          /* Create expression. */
+          string expression = create_expression(RM_product, variate_num,
+                                                optimal_polarity, binary);
+
+          /* Replace network. */
+          substitute_network_mffc(expression, leaves, n);
+        }
+      } else {
+        int optimization_nodes = mffc.num_gates() - node_num_new;
+        if (optimization_nodes > 0) {
+          /* Create expression. */
+          string expression = create_expression(RM_product, variate_num,
+                                                optimal_polarity, binary);
+
+          /* Replace network. */
+          substitute_network_mffc(expression, leaves, n);
+        }
+      }
+
+      return true;
+    });
+  }
+
+  /**************************************************************************************************************/
+ private:
+  Ntk& ntk;
+  rm_rewriting_params const& ps_ntk;
+};
+}  // namespace detail
+
+/*! \brief RM logic optimization.
+ *
+ * This algorithm divides the network and then attempts to rewrite the
+ subnetwork by RM logic
+ * in terms of gates of the same network.  The rewritten structures are added
+ * to the network, and if they lead to area improvement, will be used as new
+ * parts of the logic.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_and`
+ * - `create_not`
+ * - `create_xor`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_and`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+   \endverbatim
+ */
+template <class Ntk>
+void rm_mixed_polarity(Ntk& ntk, rm_rewriting_params const& ps_ntk = {}) {
+  static_assert(is_network_type_v<Ntk>, "Ntk is not a network type");
+  static_assert(has_get_node_v<Ntk>,
+                "Ntk does not implement the get_node method");
+  static_assert(has_level_v<Ntk>, "Ntk does not implement the level method");
+  static_assert(has_create_maj_v<Ntk>,
+                "Ntk does not implement the create_maj method");
+  static_assert(has_create_xor_v<Ntk>,
+                "Ntk does not implement the create_maj method");
+  static_assert(has_substitute_node_v<Ntk>,
+                "Ntk does not implement the substitute_node method");
+  static_assert(has_update_levels_v<Ntk>,
+                "Ntk does not implement the update_levels method");
+  static_assert(has_foreach_node_v<Ntk>,
+                "Ntk does not implement the foreach_node method");
+  static_assert(has_foreach_po_v<Ntk>,
+                "Ntk does not implement the foreach_po method");
+  static_assert(has_foreach_fanin_v<Ntk>,
+                "Ntk does not implement the foreach_fanin method");
+  static_assert(has_is_and_v<Ntk>, "Ntk does not implement the is_and method");
+  static_assert(has_is_xor_v<Ntk>, "Ntk does not implement the is_xor method");
+  static_assert(has_clear_values_v<Ntk>,
+                "Ntk does not implement the clear_values method");
+  static_assert(has_set_value_v<Ntk>,
+                "Ntk does not implement the set_value method");
+  static_assert(has_value_v<Ntk>, "Ntk does not implement the value method");
+  static_assert(has_fanout_size_v<Ntk>,
+                "Ntk does not implement the fanout_size method");
+
+  detail::rm_mixed_polarity_impl p(ntk, ps_ntk);
+  p.run();
+}
+
+} /* namespace mockturtle */

src/core/xag_rewriting.hpp

@@ -0,0 +1,678 @@
+#pragma once
+
+#include <iostream>
+#include <optional>
+
+#include <mockturtle/mockturtle.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for xag_depth_rewriting.
+ *
+ * The data structure `xag_depth_rewriting_params` holds configurable
+ * parameters with default arguments for `xag_depth_rewriting`.
+ */
+struct xag_depth_rewriting_params
+{
+  /*! \brief Rewriting strategy. */
+  enum strategy_t
+  {
+    /*! \brief DFS rewriting strategy.
+     *
+     * Applies depth rewriting once to all output cones whose drivers have
+     * maximum levels
+     */
+    dfs,
+    /*! \brief Aggressive rewriting strategy.
+     *
+     * Applies depth reduction multiple times until the number of nodes, which
+     * cannot be rewritten, matches the number of nodes, in the current
+     * network; or the new network size is larger than the initial size w.r.t.
+     * to an `overhead`.
+     */
+    aggressive,
+    /*! \brief Selective rewriting strategy.
+     *
+     * Like `aggressive`, but only applies rewriting to nodes on critical paths
+     * and without `overhead`.
+     */
+    selective,
+  } strategy = dfs;
+
+  /*! \brief Overhead factor in aggressive rewriting strategy.
+   *
+   * When comparing to the initial size in aggressive depth rewriting, phyLS the
+   * number of dangling nodes are taken into account.
+   */
+  float overhead{2.0f};
+
+  bool verbose{false};
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class xag_depth_rewriting_impl
+{
+public:
+  xag_depth_rewriting_impl( Ntk& ntk, xag_depth_rewriting_params const& ps )
+      : ntk( ntk ), ps( ps )
+  {
+  }
+
+  void run()
+  {
+    switch ( ps.strategy )
+    {
+      case xag_depth_rewriting_params::dfs:
+        run_dfs();
+        break;
+      
+      case xag_depth_rewriting_params::selective:
+        run_selective();
+        break;
+      
+      case xag_depth_rewriting_params::aggressive:
+        run_aggressive();
+        break;
+    }
+  }
+/*****************************************Optimization strategies Begin********************************************************************/
+private:
+  void run_dfs()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        reduce_depth_ultimate( n );
+        return true;
+      } );
+    } );
+  }
+/**************************************************************************************************************/
+  void run_selective()
+  {
+    uint32_t counter{0};
+    while ( true )
+    {
+      mark_critical_paths();
+
+      topo_view topo{ntk};
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 || ntk.value( n ) == 0 )
+          return;
+
+        if ( reduce_depth_ultimate( n ) )
+        {
+          mark_critical_paths();
+        }
+        else
+        {
+          ++counter;
+        }
+      } );
+
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+/**************************************************************************************************************/
+  void run_aggressive()
+  {
+    uint32_t counter{0}, init_size{ntk.size()};
+    while ( true )
+    {
+      topo_view topo{ntk};
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 )
+          return;
+
+        if ( !reduce_depth_ultimate( n ) )
+        {
+          ++counter;
+        }
+      } );
+
+      if ( ntk.size() > ps.overhead * init_size )
+        break;
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+/*****************************************Optimization strategies End**********************************************************************/
+
+/*****************************************Optimization Functions Begin*********************************************************************/
+private:
+  bool reduce_depth_ultimate( node<Ntk> const& n )
+  {
+    auto b_1 = xor_inv_transfer( n );
+    auto b2 = xor_inv_remove( n );
+    auto b3 = xor_and_transfer( n );
+    auto b4 = reduce_depth_and_common_fanin( n );
+    auto b5 = reduce_depth_use_constant_fanin( n );
+    auto b6 = reduce_depth_use_xor_or_convert( n );
+    auto b7 = reduce_depth_use_xor_and_convert( n );
+   // auto b8 = reduce_depth_use_xor_or_convert2( n );   
+ 
+    if(!( b_1 | b2 | b3 | b4 | b5 | b6 | b7  )){ return false; }
+
+    return true;
+  }
+/**************************************************************************************************************/
+  /* [!a!b]=[ab], ![!a!b] = ![ab]  */
+  /* Remove the INV of the two children of an node, thie node's type must be XOR.  */	
+  bool xor_inv_remove( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor( n ) )
+      return false;
+    
+    if ( ntk.level( n ) == 0 )
+      return false;
+    
+    /* get children of top node, ordered by node level (ascending) */
+    auto ocs = ordered_children( n );
+
+    /* The two children must both have INV. */
+    if ( ntk.is_complemented(ocs[0]) && ntk.is_complemented(ocs[1]) )
+    {   
+      ocs[0] = !ocs[0];
+      ocs[1] = !ocs[1];
+            
+      auto opt = ntk.create_xor( ocs[0], ocs[1] );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+    }
+
+    return true;
+  }
+/**************************************************************************************************************/
+  /* ![!ab] = ![a!b] = [ab], [!ab] = [a!b] = ![ab]  */
+  /* Transfer the INV of the input to the fanout.  */
+  /* can be used for subsquent optimization such as (a[!ab]) = (a![ab]) = (ab) */
+  bool xor_inv_transfer( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor( n ) )
+      return false;
+    
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    auto ocs = ordered_children( n );
+   
+    if(!ntk.is_complemented(ocs[0]) && !ntk.is_complemented(ocs[1]))
+      return false;
+
+    if( ( ntk.is_complemented(ocs[0]) ^ ntk.is_complemented(ocs[1] ) )  == 1)
+    {
+      if(ntk.is_complemented(ocs[0]))
+      {
+        ocs[0] = !ocs[0];
+      }
+      else
+      {
+        ocs[1] = !ocs[1];
+      }
+    }
+    
+    auto opt = ntk.create_xor(ocs[0], ocs[1]) ^ true;
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+   
+    return true;
+  }
+/**************************************************************************************************************/
+  bool reduce_depth_use_constant_fanin( node<Ntk> const& n )
+  { 
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    auto ocs = ordered_children( n );
+    
+    if(ntk.fanout_size(ntk.get_node(ocs[0])) ==1 && ntk.fanout_size(ntk.get_node(ocs[1])) == 1)
+    {
+      if(ntk.is_xor(n))
+      {
+        if(ocs[0].index == 0 || ocs[1].index == 0)
+        {
+          if(ocs[0].index == 0 )
+          {
+            auto opt = ntk.is_complemented(ocs[0])? !ocs[1] : ocs[1];
+            ntk.substitute_node(n,opt);
+            ntk.update_levels();
+          }
+
+          if (ocs[1].index == 0 )
+          {
+            auto opt = ntk.is_complemented(ocs[1])? !ocs[0] : ocs[0];
+            ntk.substitute_node(n,opt);
+            ntk.update_levels();
+          }
+        }
+
+        if(ocs[0].index == 1 || ocs[1].index == 1 )
+        {
+          if(ocs[0].index == 1 )
+          {
+            auto opt = ntk.is_complemented(ocs[0])? ocs[1] : !ocs[1];
+            ntk.substitute_node(n, opt);
+            ntk.update_levels();	  
+          }
+
+          if(ocs[1].index == 1 )
+          {
+            auto opt = ntk.is_complemented(ocs[1])? ocs[0] : !ocs[0];
+            ntk.substitute_node(n, opt);
+            ntk.update_levels(); 
+          }
+        }
+      }
+
+      if(ntk.is_and(n))
+      {
+        if(ocs[0].index == 1 || ocs[1].index == 1)
+        {
+          if(ocs[0].index == 1 && !ntk.is_complemented(ocs[0]) )
+          {
+            auto opt = ocs[1];
+            ntk.substitute_node(n,opt);
+            ntk.update_levels();
+          }
+          else if(ocs[1].index == 1 && ntk.is_complemented(ocs[1]))
+          {
+            auto opt = ocs[0];
+            ntk.substitute_node(n,opt);
+            ntk.update_levels();
+          }	  
+        }
+      }
+    }
+    /* XOR: [a0] = a, [a1] = !a.*/
+    /* AND: (a1) = a, (a0) = 0.   */
+    return true;
+  }
+  /**************************************************************************************************************/
+  /* Use the Boolean configuration between AND and XOR.
+   * There are main two expression for reference.
+   * (a[!ab]) = (ab),  (!a[ab]) = (!ab). */
+  bool reduce_depth_use_xor_and_convert( node<Ntk> const& n )
+  {
+    if ( !ntk.is_and( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    const auto ocs = ordered_children( n );
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+
+    if( !ntk.is_xor( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    const auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );   
+    /* Judgement */
+    if( ocs[0].index == ocs2[0].index && (ocs[0].complement ^ ocs2[0].complement) == 1)
+    {   
+      if(ntk.fanout_size(ntk.get_node(ocs[1])) == 1)
+      {
+        auto opt = ntk.create_and( ocs[0], ocs2[1] );
+        ntk.substitute_node( n, opt );
+        ntk.update_levels();
+      }
+      return true;
+    }
+    return true;
+  }
+  /**************************************************************************************************************/
+  /* Refer to follow two expressions:
+   * (a(ab)) = (ab), (!a(!a!b)) = (!a!b).
+   */
+  bool reduce_depth_and_common_fanin( node<Ntk> const& n )
+  {
+    if ( !ntk.is_and( n ) )
+      return false;
+    
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    const auto ocs = ordered_children( n );
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+    
+    if( !ntk.is_and( ntk.get_node( ocs[1] ) ) )
+      return false;
+    
+    const auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    if(ocs[0] == ocs2[0]  && ntk.fanout_size(ntk.get_node(ocs[1])) == 1 && ntk.fanout_size(ntk.get_node(ocs[1])) == 1)
+    {
+      auto opt = ocs[1];
+      ntk.substitute_node(n,opt);
+      ntk.update_levels();
+    }
+    /*if( auto cand = find_common_grand_child_two( ocs, ocs2 ); cand)
+    { 
+      auto r = *cand;
+      
+      auto opt = ntk.create_and( r.y, r.a );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+      return true;
+    }*/
+
+    return true;
+  }
+/**************************************************************************************************************/
+ /*  (a[ab]) = [a(ab)] */
+  bool xor_and_transfer( node<Ntk> const& n )
+  {
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    const auto ocs = ordered_children( n );
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+
+    if ( !ntk.is_and( n ) && !ntk.is_xor( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    const auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );
+    
+    /* refer to the expressions above. */
+    if ( !ntk.is_complemented(ocs[0]) && !ntk.is_complemented(ocs[1]) && !ntk.is_complemented(ocs2[0]) && !ntk.is_complemented(ocs2[1]) )
+      return false;
+    
+    if(ntk.fanout_size(ntk.get_node(ocs[1])) == 1)
+    {
+      if(ocs[0] == ocs2[0])
+      {
+        auto opt = ntk.create_xor(ocs[0], ntk.create_and(ocs2[0], ocs2[1]));
+        ntk.substitute_node(n, opt);
+        ntk.update_levels();
+      }
+    /*if ( auto cand = find_common_grand_child_two( ocs, ocs2 ); cand )
+    {
+      auto r = *cand;
+      auto opt = ntk.create_xor( r.a, ntk.create_and( r.a, r.y ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+      return true;
+    }*/
+    }
+    return true; 
+  }
+/**************************************************************************************************************/
+  /* ［a!(!ａ!ｂ)］＝　(!ab)　［!a!(!a!b)]= !(!ab)*/
+  bool reduce_depth_use_xor_or_convert( node<Ntk> const& n )
+  {    
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    auto ocs = ordered_children( n );
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+
+    if ( !ntk.is_xor( n ) && !ntk.is_and( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    auto ocs2 = ordered_children(ntk.get_node(ocs[1]));    
+
+    if (ocs[0].index == ocs2[0].index && ntk.is_complemented(ocs[1]) && ntk.is_complemented(ocs2[0]) && ntk.is_complemented(ocs2[1]) && ntk.fanout_size(ntk.get_node(ocs[1])) == 1 )
+    {
+      if(ntk.is_complemented(ocs[0]))
+      {
+        ocs2[1] = !ocs2[1];
+        auto opt =  ntk.create_nand(ocs2[0], ocs2[1]);
+        ntk.substitute_node(n, opt);
+        ntk.update_levels();
+      }
+      else
+      {
+        ocs2[1] = !ocs2[1];
+        auto opt = ntk.create_and(ocs2[0], ocs2[1]);
+        ntk.substitute_node(n, opt);
+        ntk.update_levels();
+      }
+    }
+    return true;
+  }
+/**************************************************************************************************************/
+  /*{a!b} = {a[!ab]} = !(!a![!ab]))；  !{a!b} = (!ab)*/
+  bool reduce_depth_use_xor_or_convert2( node<Ntk> const& n )
+  {
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending). */
+    const auto ocs = ordered_children( n );
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[1] ) ) <= ntk.level( ntk.get_node( ocs[0] ) ) + 1 )
+      return false;
+
+    if ( !ntk.is_and( n ) && !ntk.is_xor( ntk.get_node( ocs[1] ) ) )
+      return false;
+    
+    auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );
+
+    if(ntk.is_complemented(ocs[0]) && ntk.is_complemented(ocs[1]) && ocs[0] == ocs2[0] )
+    {
+      if(ntk.fanout_size(ntk.get_node(ocs[1])) == 1 && !ntk.is_complemented(ocs2[1]))
+      {
+         auto opt = ntk.create_or(ocs2[0], ocs2[1]);
+         ntk.substitute_node(n, opt);
+         ntk.update_levels();
+      }
+      return true;
+    }
+    return true;
+  }
+/*****************************************Optimization Functions End***********************************************************************/
+
+/*****************************************Other Necessary Parts Begin**********************************************************************/
+
+  bool is_signal_equal( const signal<Ntk>& a, const signal<Ntk>& b )
+  {
+    return ( a == b ?  true : false );
+  }
+/**************************************************************************************************************/
+  /* used for the subsquent judgement of the common child-node. */
+  using children_t = std::array< signal<Ntk>, 2 >; 
+  std::bitset<4> get_pair_pattern( const children_t& c1, const children_t& c2 )
+  {
+    std::bitset<4> equals;
+
+    equals.set( 0u, is_signal_equal( c1[0], c2[0] ) );
+    equals.set( 1u, is_signal_equal( c1[0], c2[1] ) );
+    equals.set( 2u, is_signal_equal( c1[1], c2[0] ) );
+    equals.set( 3u, is_signal_equal( c1[1], c2[1] ) );
+
+    return equals;
+  }
+/**************************************************************************************************************/
+  /* used to judge which two nodes are common. */
+  std::vector<size_t> equal_idx( const std::bitset<4> pattern )
+  {
+    std::vector<size_t> r;
+    for( size_t idx = 0; idx < pattern.size(); idx++ )
+    {
+      if( pattern.test( idx ) )
+      {
+        r.push_back( idx );
+      }
+    }
+
+    return r;
+  }
+/**************************************************************************************************************/	
+  struct grand_children_pair_t
+  {
+    signal<Ntk> x;
+    signal<Ntk> y;
+    signal<Ntk> a; //common grand child a
+  };
+/**************************************************************************************************************/
+  std::optional<grand_children_pair_t> find_common_grand_child_two( const children_t& c1, const children_t& c2 )
+  {
+    grand_children_pair_t r;
+    auto p = get_pair_pattern( c1, c2 );
+
+    std::vector<signal<Ntk>> common;
+
+    for( size_t idx = 0; idx < p.size(); idx++ )
+    {
+      if( p.test(idx) )
+      {
+        assert( c1[idx / 2] == c2[ idx % 2 ] );
+        common.push_back( c1[ idx / 2] );
+      }
+    }
+
+    /* for xor children, require at least one common children */
+    if( common.size() != 1u )
+      return std::nullopt;
+
+    /* save the records */
+    r.a = common[0u];
+
+    for( auto i = 0u; i < 2u; i++ )
+    {
+      if( c1[i] != common[0u] && c1[i] != common[0u] )
+      {
+        r.x = c1[i];
+      }
+
+      if( c2[i] != common[0u] && c2[i] != common[0u] )
+      {
+        r.y = c2[i];
+      }
+    }
+
+    return r;
+  }
+/**************************************************************************************************************/
+
+  std::array<signal<Ntk>, 2> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 2> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) { children[i] = f; } );
+    std::sort( children.begin(), children.end(), [this]( auto const& c1, auto const& c2 ) {
+        if( ntk.level( ntk.get_node( c1 ) ) == ntk.level( ntk.get_node( c2 ) ) )
+        {
+          return c1.index < c2.index;
+        }
+        else
+        {
+          return ntk.level( ntk.get_node( c1 ) ) < ntk.level( ntk.get_node( c2 ) );
+        }
+    } );
+    return children;
+  }
+/**************************************************************************************************************/
+  void mark_critical_path( node<Ntk> const& n )
+  {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) || ntk.value( n ) )
+      return;
+
+    const auto level = ntk.level( n );
+    ntk.set_value( n, 1 );
+    ntk.foreach_fanin( n, [this, level]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == level - 1 )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+/**************************************************************************************************************/
+  void mark_critical_paths()
+  {
+    ntk.clear_values();
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == ntk.depth() )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+/*****************************************Other Necessary Parts End************************************************************************/
+private:
+  Ntk& ntk;
+  xag_depth_rewriting_params const& ps;
+};
+
+} // namespace detail
+
+/*! \brief xag algebraic depth rewriting.
+ *
+ * This algorithm tries to rewrite a network with majority gates for depth
+ * optimization using the associativity and distributivity rule in
+ * majority-of-3 logic.  It can be applied to networks other than xags, but
+ * only considers pairs of nodes which both implement the majority-of-3
+ * function and the XOR function.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_maj`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_maj`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+   \endverbatim
+ */
+template<class Ntk>
+void xag_depth_rewriting( Ntk& ntk, xag_depth_rewriting_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_update_levels_v<Ntk>, "Ntk does not implement the update_levels method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_and_v<Ntk>, "Ntk does not implement the is_and method" );
+  static_assert( has_is_xor_v<Ntk>, "Ntk does not implement the is_xor method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  detail::xag_depth_rewriting_impl<Ntk> p( ntk, ps );
+  p.run();
+}
+
+} /* namespace mockturtle */

src/core/xmg_expand.hpp

@@ -0,0 +1,170 @@
+#pragma once
+
+#include <iostream>
+#include <optional>
+
+#include <mockturtle/mockturtle.hpp>
+
+namespace mockturtle
+{
+  struct xmg_expand_rewriting_params
+  {
+    enum strategy_t
+    {
+      expand,
+      constants
+    } strategy = expand;
+
+    std::vector<unsigned> xor_index;
+  };
+
+namespace detail
+{
+template<class Ntk>
+class xmg_expand_rewriting_impl
+{
+public:
+  xmg_expand_rewriting_impl( Ntk& ntk, xmg_expand_rewriting_params const& ps )
+      : ntk( ntk ), ps( ps )
+  {
+  }
+
+  void run()
+  {
+    switch( ps.strategy )
+    {
+      case xmg_expand_rewriting_params::expand:
+        run_xor_maj_expand();
+        break;
+      case xmg_expand_rewriting_params::constants:
+        run_xor_constants();
+        break;
+    }
+  }
+
+private:
+  void run_xor_maj_expand()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        xor_maj_expand( n );
+        return true;
+      } );
+    } );
+  }
+  
+  void run_xor_constants()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        xor_constants( n, ps.xor_index );
+        return true;
+      } );
+    } );
+  }
+
+private:
+  void print_children( std::array<signal<Ntk>, 3u> const& children )
+  {
+    std::cout << "children 0 : " << ntk.get_node( children[0] ) << std::endl;
+    std::cout << "children 1 : " << ntk.get_node( children[1] ) << std::endl;
+    std::cout << "children 2 : " << ntk.get_node( children[2] ) << std::endl;
+  }
+
+  bool xor_constants( node<Ntk> const& n, std::vector<unsigned> const& xors )
+  {
+    if ( !ntk.is_xor3( n ) )
+      return false;
+
+    auto copy_node_2n = n * 2;
+    auto copy_node_2n_plus_1 = n * 2 + 1;
+
+    if( std::find( xors.begin(), xors.end(), copy_node_2n ) != xors.end() )
+    {
+      //std::cout << "Please assign constants to node " << n << std::endl;
+      auto opt = ntk.get_constant( false );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+    else if( std::find( xors.begin(), xors.end(), copy_node_2n_plus_1 ) != xors.end() )
+    {
+      //std::cout << "Please assign constants to node " << n << std::endl;
+      auto opt = ntk.get_constant( true );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+ 
+  bool xor_maj_expand( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor3( n ) )
+      return false;
+
+    if ( ntk.level( n ) <= 1 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    /* if the first child is not constant, return */
+    if( ocs[0].index != 0 )
+      return false;
+
+    if( !ntk.is_maj( ntk.get_node( ocs[1] ) ) || !ntk.is_maj( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    const auto ogcs = ordered_children( ntk.get_node( ocs[1] ) ); 
+    
+    auto n1 = ntk.create_xor( ogcs[0], ocs[2] );
+    auto n2 = ntk.create_xor( ogcs[1], ocs[2] );
+    auto n3 = ntk.create_xor( ogcs[2], ocs[2] );
+
+    auto opt = ntk.create_maj( n1, n2, n3 );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  std::array<signal<Ntk>, 3> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 3> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) { children[i] = f; } );
+    std::sort( children.begin(), children.end(), [this]( auto const& c1, auto const& c2 ) {
+        if( ntk.level( ntk.get_node( c1 ) ) == ntk.level( ntk.get_node( c2 ) ) )
+        {
+          return c1.index < c2.index;
+        }
+        else
+        {
+          return ntk.level( ntk.get_node( c1 ) ) < ntk.level( ntk.get_node( c2 ) );
+        }
+    } );
+    return children;
+  }
+
+private:
+  Ntk& ntk;
+  xmg_expand_rewriting_params const& ps;
+};
+
+} // namespace detail
+
+template<class Ntk>
+void xmg_expand_rewriting( Ntk& ntk, xmg_expand_rewriting_params const& ps )
+{
+  detail::xmg_expand_rewriting_impl<Ntk> p( ntk, ps );
+  p.run();
+}
+
+} /* namespace mockturtle */

src/core/xmg_extract.hpp

@@ -0,0 +1,66 @@
+#ifndef XMG_EXTRACT_HPP
+#define XMG_EXTRACT_HPP
+
+#include <mockturtle/algorithms/circuit_validator.hpp>
+#include <mockturtle/views/topo_view.hpp>
+
+#include "utils.hpp"
+
+using namespace mockturtle;
+
+namespace phyLS
+{
+  
+  std::vector<unsigned> xmg_extract( xmg_network const& xmg )
+  {
+    std::vector<unsigned> xors;
+    topo_view topo{ xmg };
+    circuit_validator v( xmg );
+
+    int count = 0;
+    
+    topo.foreach_node( [&]( auto n ) {
+    if( xmg.is_xor3( n ) )
+    {
+      auto children = get_children( xmg, n );
+
+      //print_children( children );
+
+      if( xmg.get_node( children[0] ) == 0 
+          && !xmg.is_pi( xmg.get_node( children[1] ) ) 
+          && !xmg.is_pi( xmg.get_node( children[2] ) ) )
+      { 
+        auto result1 = v.validate( children[1], children[2] );
+        auto result2 = v.validate( children[1], !children[2] );
+
+        if( result1 == std::nullopt || result2 == std::nullopt )
+        {
+          //std::cout << "UNKNOWN status\n";
+          return;
+        }
+        
+        if( result1 || result2 )
+        {
+          if( *result1 )
+          {
+            std::cout << "XOR node " << n  << " can be removed as constant 0\n";
+            xors.push_back( n * 2 );
+            count++;
+          }
+          else if( *result2 )
+          {
+            std::cout << "XOR node " << n  << " can be removed as constant 1\n";
+            xors.push_back( n * 2 + 1 );
+            count++;
+          }
+        }
+      }
+    }
+    } );
+
+    std::cout << "[xmgrw -u] Find " << count << " XOR constant nodes\n";
+    return xors;
+  }
+}
+
+#endif

src/core/xmg_rewriting.hpp

@@ -0,0 +1,925 @@
+#pragma once
+
+#include <iostream>
+#include <optional>
+
+#include <mockturtle/mockturtle.hpp>
+
+namespace mockturtle
+{
+
+/*! \brief Parameters for xmg_depth_rewriting.
+ *
+ * The data structure `xmg_depth_rewriting_params` holds configurable
+ * parameters with default arguments for `xmg_depth_rewriting`.
+ */
+struct xmg_depth_rewriting_params
+{
+  /*! \brief Rewriting strategy. */
+  enum strategy_t
+  {
+    /*! \brief DFS rewriting strategy.
+     *
+     * Applies depth rewriting once to all output cones whose drivers have
+     * maximum levels
+     */
+    dfs,
+    /*! \brief Aggressive rewriting strategy.
+     *
+     * Applies depth reduction multiple times until the number of nodes, which
+     * cannot be rewritten, matches the number of nodes, in the current
+     * network; or the new network size is larger than the initial size w.r.t.
+     * to an `overhead`.
+     */
+    aggressive,
+    /*! \brief Selective rewriting strategy.
+     *
+     * Like `aggressive`, but only applies rewriting to nodes on critical paths
+     * and without `overhead`.
+     */
+    selective,
+    /*! \brief Selective rewriting strategy.
+     *
+     * Like `dfs`, rewrite XOR( a, XOR( b, c ) ) as XOR3(a, b, c )
+     */
+    qca
+  } strategy = dfs;
+
+  /*! \brief Overhead factor in aggressive rewriting strategy.
+   *
+   * When comparing to the initial size in aggressive depth rewriting, also the
+   * number of dangling nodes are taken into account.
+   */
+  float overhead{2.0f};
+
+  /*! \brief Allow area increase while optimizing depth. */
+  bool allow_area_increase{true};
+
+  /*! \brief xor3 to two xor2s that compatiable with old cirkit */
+  bool apply_xor3_to_xor2{false};
+};
+
+namespace detail
+{
+
+template<class Ntk>
+class xmg_depth_rewriting_impl
+{
+public:
+  xmg_depth_rewriting_impl( Ntk& ntk, xmg_depth_rewriting_params const& ps )
+      : ntk( ntk ), ps( ps )
+  {
+  }
+
+  void run()
+  {
+    switch ( ps.strategy )
+    {
+    case xmg_depth_rewriting_params::dfs:
+      run_dfs();
+      break;
+    case xmg_depth_rewriting_params::selective:
+      run_selective();
+      break;
+    case xmg_depth_rewriting_params::aggressive:
+      run_aggressive();
+      break;
+    case xmg_depth_rewriting_params::qca:
+      run_qca();
+      break;
+    }
+
+    if( ps.apply_xor3_to_xor2 )
+    {
+      run_xor3_flatten();
+    }
+  }
+
+private:
+  void run_qca()
+  {
+    /* reduce depth */
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        reduce_depth_ultimate( n );
+        return true;
+      } );
+    } );
+
+    /* rewrite xor2 to xor3 */
+    ntk.foreach_po( [this]( auto po ) {
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        reduce_depth_xor2_to_xor3( n );
+        return true;
+      } );
+    } );
+  }
+
+  void run_dfs()
+  {
+    ntk.foreach_po( [this]( auto po ) {
+      const auto driver = ntk.get_node( po );
+      if ( ntk.level( driver ) < ntk.depth() )
+        return;
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        reduce_depth_ultimate( n );
+        return true;
+      } );
+    } );
+  }
+
+  void run_selective()
+  {
+    uint32_t counter{0};
+    while ( true )
+    {
+      mark_critical_paths();
+
+      topo_view topo{ntk};
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 || ntk.value( n ) == 0 )
+          return;
+
+        if ( reduce_depth_ultimate( n ) )
+        {
+          mark_critical_paths();
+        }
+        else
+        {
+          ++counter;
+        }
+      } );
+
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+  void run_aggressive()
+  {
+    uint32_t counter{0}, init_size{ntk.size()};
+    while ( true )
+    {
+      topo_view topo{ntk};
+      topo.foreach_node( [this, &counter]( auto n ) {
+        if ( ntk.fanout_size( n ) == 0 )
+          return;
+
+        if ( !reduce_depth_ultimate( n ) )
+        {
+          ++counter;
+        }
+      } );
+
+      if ( ntk.size() > ps.overhead * init_size )
+        break;
+      if ( counter > ntk.size() )
+        break;
+    }
+  }
+
+  void run_xor3_flatten()
+  {
+    /* rewrite xor3 to xor2 */
+    ntk.foreach_po( [this]( auto po ) {
+      topo_view topo{ntk, po};
+      topo.foreach_node( [this]( auto n ) {
+        xor3_to_xor2( n );
+        return true;
+      } );
+    } );
+  }
+
+private:
+  bool reduce_depth_ultimate( node<Ntk> const& n )
+  {
+    auto b_1 = reduce_depth( n );
+    auto b2 = reduce_depth_xor_associativity( n );
+    auto b3 = reduce_depth_xor_complementary_associativity( n );
+    auto b4 = reduce_depth_xor_distribute( n );
+
+    if( !( b_1 | b2 | b3 | b4 ) ) { return false; }
+
+    return true;
+  }
+
+  bool xor3_to_xor2( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor3( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    /* if the first child is constant, return */
+    if( ocs[0].index == 0 )
+      return false;
+
+    auto opt = ntk.create_xor( ocs[2], ntk.create_xor( ocs[0], ocs[1] ) );
+    ntk.substitute_node( n, opt );
+    ntk.update_levels();
+
+    return true;
+  }
+
+  bool reduce_depth_xor2_to_xor3( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor3( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    /* if the first child is not constant, return */
+    if( ocs[0].index != 0 )
+      return false;
+
+    /* if there are no XOR children, return */
+    if ( !ntk.is_xor3( ntk.get_node( ocs[2] ) ) && !ntk.is_xor3( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    if( ntk.is_xor3( ntk.get_node( ocs[2] ) ) )
+    {
+      /* size optimization, do not allow area increase */
+      if( ntk.fanout_size( ntk.get_node( ocs[2] ) ) == 1 )
+      {
+        /* get children of last child */
+        auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+        /* propagate inverter if necessary */
+        if ( ntk.is_complemented( ocs[2] ) )
+        {
+          /* complement the constants */
+          ocs2[0] = !ocs2[0];
+        }
+
+        if( ocs2[0].index == 0 )
+        {
+          auto opt = ntk.create_xor3( ocs[1], ocs2[1], ocs2[2] );
+          ntk.substitute_node( n, opt );
+          ntk.update_levels();
+        }
+
+        return true;
+      }
+
+    }
+
+    if( ntk.is_xor3( ntk.get_node( ocs[1] ) ) )
+    {
+      /* size optimization, do not allow area increase */
+      if( ntk.fanout_size( ntk.get_node( ocs[1] ) ) == 1 )
+      {
+        /* get children of second child */
+        auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );
+
+        /* propagate inverter if necessary */
+        if ( ntk.is_complemented( ocs[1] ) )
+        {
+          /* complement the constants */
+          ocs2[0] = !ocs2[0];
+        }
+
+        if( ocs2[0].index == 0 )
+        {
+          auto opt = ntk.create_xor3( ocs[2], ocs2[1], ocs2[2] );
+          ntk.substitute_node( n, opt );
+          ntk.update_levels();
+        }
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  bool reduce_depth( node<Ntk> const& n )
+  {
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_maj( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      ocs2[0] = !ocs2[0];
+      ocs2[1] = !ocs2[1];
+      ocs2[2] = !ocs2[2];
+    }
+
+    if ( auto cand = associativity_candidate( ocs[0], ocs[1], ocs2[0], ocs2[1], ocs2[2] ); cand )
+    {
+      const auto& [x, y, z, u, assoc] = *cand;
+      auto opt = ntk.create_maj( z, assoc ? u : x, ntk.create_maj( x, y, u ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+
+    /* distributivity */
+    if ( ps.allow_area_increase )
+    {
+      auto opt = ntk.create_maj( ocs2[2],
+                                 ntk.create_maj( ocs[0], ocs[1], ocs2[0] ),
+                                 ntk.create_maj( ocs[0], ocs[1], ocs2[1] ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+      return true;
+    }
+    return false;
+  }
+
+  using candidate_t = std::tuple<signal<Ntk>, signal<Ntk>, signal<Ntk>, signal<Ntk>, bool>;
+  std::optional<candidate_t> associativity_candidate( signal<Ntk> const& v, signal<Ntk> const& w, signal<Ntk> const& x, signal<Ntk> const& y, signal<Ntk> const& z ) const
+  {
+    if ( v.index == x.index )
+    {
+      return candidate_t{w, y, z, v, v.complement == x.complement};
+    }
+    if ( v.index == y.index )
+    {
+      return candidate_t{w, x, z, v, v.complement == y.complement};
+    }
+    if ( w.index == x.index )
+    {
+      return candidate_t{v, y, z, w, w.complement == x.complement};
+    }
+    if ( w.index == y.index )
+    {
+      return candidate_t{v, x, z, w, w.complement == y.complement};
+    }
+
+    return std::nullopt;
+  }
+
+  bool reduce_depth_xor_associativity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_xor3( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_xor3( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) + 1 <= ntk.level( ntk.get_node( ocs[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      ocs2[2] = !ocs2[2];
+    }
+
+    if( ocs[0] == ocs2[0] && ocs[0].index == 0 && ntk.fanout_size( ntk.get_node( ocs[2] ) ) == 1)
+    {
+      auto opt = ntk.create_xor3( ocs[0], ocs2[2],
+                                  ntk.create_xor3( ocs2[0], ocs2[1], ocs[1] ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+      return true;
+    }
+
+    return false;
+  }
+
+  /* XOR complementary associativity <xy[!yz]> = <xy[xz]> */
+  bool reduce_depth_xor_complementary_associativity( node<Ntk> const& n )
+  {
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    if ( !ntk.is_xor3( ntk.get_node( ocs[2] ) ) )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    /* depth of last child must be higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) < ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+      return false;
+
+    /* multiple child fanout is allowable */
+    if ( !ps.allow_area_increase && ntk.fanout_size( ntk.get_node( ocs[2] ) ) != 1 )
+      return false;
+
+    /* get children of last child */
+    auto ocs2 = ordered_children( ntk.get_node( ocs[2] ) );
+
+    /* depth of last grand-child must be higher than depth of second grand-child */
+    if ( ntk.level( ntk.get_node( ocs2[2] ) ) == ntk.level( ntk.get_node( ocs2[1] ) ) )
+      return false;
+
+    /* propagate inverter if necessary */
+    if ( ntk.is_complemented( ocs[2] ) )
+    {
+      if ( ntk.is_complemented( ocs2[0] ) )
+      {
+        ocs2[0] = !ocs2[0];
+      }
+      else if ( ntk.is_complemented( ocs2[1] ) )
+      {
+        ocs2[1] = !ocs2[1];
+      }
+      else if ( ntk.is_complemented( ocs2[2] ) )
+      {
+        ocs2[2] = !ocs2[2];
+      }
+      else
+      {
+        ocs2[0] = !ocs2[0];
+      }
+    }
+
+    if ( auto cand = xor_compl_associativity_candidate( ocs[0], ocs[1], ocs2[0], ocs2[1], ocs2[2] ); cand )
+    {
+      const auto& [x, y, z, u, assoc] = *cand;
+      auto opt = ntk.create_maj( x, u, ntk.create_xor3( assoc ? !x : x, y, z ) );
+      ntk.substitute_node( n, opt );
+      ntk.update_levels();
+
+      return true;
+    }
+
+    return false;
+  }
+
+  std::optional<candidate_t> xor_compl_associativity_candidate( signal<Ntk> const& v, signal<Ntk> const& w, signal<Ntk> const& x, signal<Ntk> const& y, signal<Ntk> const& z ) const
+  {
+    if ( v.index == x.index )
+    {
+      return candidate_t{w, y, z, v, v.complement == x.complement};
+    }
+    if ( v.index == y.index )
+    {
+      return candidate_t{w, x, z, v, v.complement == y.complement};
+    }
+    if ( v.index == z.index )
+    {
+      return candidate_t{w, x, y, v, v.complement == z.complement};
+    }
+    if ( w.index == x.index )
+    {
+      return candidate_t{v, y, z, w, w.complement == x.complement};
+    }
+    if ( w.index == y.index )
+    {
+      return candidate_t{v, x, z, w, w.complement == y.complement};
+    }
+    if ( w.index == z.index )
+    {
+      return candidate_t{v, x, y, w, w.complement == z.complement};
+    }
+
+    return std::nullopt;
+  }
+
+  /* XOR distribute over MAJ */
+  bool reduce_depth_xor_distribute( node<Ntk> const& n )
+  {
+    if ( !ntk.is_maj( n ) )
+      return false;
+
+    if ( ntk.level( n ) == 0 )
+      return false;
+
+    /* get children of top node, ordered by node level (ascending) */
+    const auto ocs = ordered_children( n );
+
+    std::vector<unsigned> xor_index;
+    for( auto i = 0; i <= 2; i++ )
+    {
+      if( ntk.is_xor3( ntk.get_node( ocs[i] ) ) )
+      {
+        xor_index.push_back( i );
+      }
+    }
+
+    /* consider at least two xor child nodes */
+    if ( xor_index.size() < 2 )
+      return false;
+
+    /* depth of last child must be (significantly) higher than depth of second child */
+    if ( ntk.level( ntk.get_node( ocs[2] ) ) <= ntk.level( ntk.get_node( ocs[1] ) ) + 1 )
+        return false;
+
+    /* child must have single fanout, if no area overhead is allowed */
+    if( !ps.allow_area_increase )
+    {
+      for( const auto& index : xor_index )
+      {
+        if( ntk.fanout_size( ntk.get_node( ocs[index] ) ) != 1 )
+        {
+          return false;
+        }
+      }
+    }
+
+    /* propagate inverter if necessary */
+    for( const auto& index : xor_index )
+    {
+      if( ntk.is_complemented( ntk.get_node( ocs[index] ) ) )
+      {
+        auto ocs_next = ordered_children( ntk.get_node( ocs[index] ) );
+        ocs_next[2] = !ocs_next[2];
+      }
+    }
+
+    if( xor_index.size() == 3u )
+    {
+      auto ocs1 = ordered_children( ntk.get_node( ocs[0] ) );
+      auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );
+      auto ocs3 = ordered_children( ntk.get_node( ocs[2] ) );
+
+      if ( auto cand = find_common_grand_child_three( ocs1, ocs2, ocs3 ); cand )
+      {
+        auto r = *cand;
+        auto opt = ntk.create_xor3( r.a, r.b, ntk.create_maj( r.x, r.y, r.z ) );
+        ntk.substitute_node( n, opt );
+        ntk.update_levels();
+
+        return true;
+      }
+
+      return false;
+    }
+    else if( xor_index.size() == 2u )
+    {
+      auto ocs2 = ordered_children( ntk.get_node( ocs[1] ) );
+      auto ocs3 = ordered_children( ntk.get_node( ocs[2] ) );
+
+      if ( auto cand = find_common_grand_child_two( ocs[0], ocs2, ocs3 ); cand )
+      {
+        auto r = *cand;
+        auto opt = ntk.create_xor3( r.a, r.b, ntk.create_maj( r.x, r.y, r.z ) );
+        ntk.substitute_node( n, opt );
+        ntk.update_levels();
+
+        return true;
+      }
+
+      return false;
+    }
+    else
+    {
+      return false;
+    }
+
+    return false;
+  }
+
+  bool is_signal_equal( const signal<Ntk>& a, const signal<Ntk>& b )
+  {
+    return ( a == b ?  true : false );
+  }
+
+  bool is_three_signal_equal( const signal<Ntk>& a, const signal<Ntk>& b, const signal<Ntk>& c )
+  {
+    return ( a == b ?  ( b == c ? true : false ): false );
+  }
+
+  using children_t = std::array< signal<Ntk>, 3 >;
+  std::bitset<9> get_pair_pattern( const children_t& c1, const children_t& c2 )
+  {
+    std::bitset<9> equals;
+
+    equals.set( 0u, is_signal_equal( c1[0], c2[0] ) );
+    equals.set( 1u, is_signal_equal( c1[0], c2[1] ) );
+    equals.set( 2u, is_signal_equal( c1[0], c2[2] ) );
+    equals.set( 3u, is_signal_equal( c1[1], c2[0] ) );
+    equals.set( 4u, is_signal_equal( c1[1], c2[1] ) );
+    equals.set( 5u, is_signal_equal( c1[1], c2[2] ) );
+    equals.set( 6u, is_signal_equal( c1[2], c2[0] ) );
+    equals.set( 7u, is_signal_equal( c1[2], c2[1] ) );
+    equals.set( 8u, is_signal_equal( c1[2], c2[2] ) );
+
+    return equals;
+  }
+
+  /* struct for representing grand chiledren */
+  struct grand_children_pair_t
+  {
+    signal<Ntk> x;
+    signal<Ntk> y;
+    signal<Ntk> z;
+    signal<Ntk> a; //common grand child a
+    signal<Ntk> b; //common grand child b
+  };
+
+  std::vector<size_t> equal_idx( const std::bitset<9> pattern )
+  {
+    std::vector<size_t> r;
+    for( size_t idx = 0; idx < pattern.size(); idx++ )
+    {
+      if( pattern.test( idx ) )
+      {
+        r.push_back( idx );
+      }
+    }
+
+    return r;
+  }
+
+  /* find common grand children in three children */
+  std::optional<grand_children_pair_t> find_common_grand_child_three( const children_t& c1, const children_t& c2, const children_t& c3 )
+  {
+    grand_children_pair_t r;
+
+    auto p1 = get_pair_pattern( c1, c2 );
+    auto p2 = get_pair_pattern( c1, c3 );
+    auto p3 = get_pair_pattern( c2, c3 );
+
+    auto s1 = equal_idx( p1 );
+    auto s2 = equal_idx( p2 );
+    auto s3 = equal_idx( p3 );
+
+    if( s1.size() != 2u || s2.size() != 2u || s3.size() != 2u )
+      return std::nullopt;
+
+    auto c11 = c1[ s1[0u] / 3 ];
+    auto c12 = c1[ s1[1u] / 3 ];
+    auto c21 = c2[ s3[0u] / 3 ];
+    auto c22 = c2[ s3[1u] / 3 ];
+    auto c31 = c3[ s2[0u] % 3 ];
+    auto c32 = c3[ s2[1u] % 3 ];
+
+    std::bitset<8> equals;
+
+    equals.set( 0u, is_three_signal_equal( c11, c21, c31 ) );
+    equals.set( 1u, is_three_signal_equal( c11, c21, c32 ) );
+    equals.set( 2u, is_three_signal_equal( c11, c22, c31 ) );
+    equals.set( 3u, is_three_signal_equal( c11, c22, c32 ) );
+    equals.set( 4u, is_three_signal_equal( c12, c21, c31 ) );
+    equals.set( 5u, is_three_signal_equal( c12, c21, c32 ) );
+    equals.set( 6u, is_three_signal_equal( c12, c22, c31 ) );
+    equals.set( 7u, is_three_signal_equal( c12, c22, c32 ) );
+
+    std::vector<signal<Ntk>> common;
+    for( size_t idx = 0; idx < 8; idx++ )
+    {
+      if( equals.test( idx ) )
+      {
+        if( idx < 4 )
+        {
+          common.push_back( c11 );
+        }
+        else
+        {
+          common.push_back( c12 );
+        }
+      }
+    }
+
+    if( common.size() != 2 )
+      return std::nullopt;
+
+    r.a = common[0u];
+    r.b = common[1u];
+
+    for( auto i = 0u; i < 3u; i++ )
+    {
+      if( c1[i] != common[0u] && c1[i] != common[1u] )
+      {
+        r.x = c1[i];
+      }
+
+      if( c2[i] != common[0u] && c2[i] != common[1u] )
+      {
+        r.y = c2[i];
+      }
+
+      if( c3[i] != common[0u] && c3[i] != common[1u] )
+      {
+        r.z = c3[i];
+      }
+    }
+
+    return r;
+  }
+
+  /* find common grand children in two children */
+  std::optional<grand_children_pair_t> find_common_grand_child_two( const signal<Ntk>& v, const children_t& c1, const children_t& c2 )
+  {
+    grand_children_pair_t r;
+    auto p = get_pair_pattern( c1, c2 );
+
+    std::vector<signal<Ntk>> common;
+
+    for( size_t idx = 0; idx < p.size(); idx++ )
+    {
+      if( p.test(idx) )
+      {
+        assert( c1[idx / 3] == c2[ idx % 3 ] );
+        common.push_back( c1[ idx / 3] );
+      }
+    }
+
+    //std::cout << "common size: " << common.size() << std::endl;
+    //std::cout << "common 0 index: " << common[0].index << std::endl;
+    //std::cout << "common 1 index: " << common[1].index << std::endl;
+    //std::cout << "v index: " << v.index << std::endl;
+    /* for xor children, require at least two common children */
+    if( common.size() != 2u )
+      return std::nullopt;
+
+    /* the signal v index must equal one of the common signal index, and one common signal is
+     * constant 1 or 0 */
+    if( v.index != common[0u].index && v.index != common[1u].index )
+      return std::nullopt;
+
+    if( common[0u].index != 0 && common[1u].index != 0 )
+      return std::nullopt;
+
+    /* save the records */
+    r.a = common[0u];
+    r.b = common[1u];
+
+    for( auto i = 0u; i < 3u; i++ )
+    {
+      if( c1[i] != common[0u] && c1[i] != common[1u] )
+      {
+        r.x = c1[i];
+      }
+
+      if( c2[i] != common[0u] && c2[i] != common[1u] )
+      {
+        r.y = c2[i];
+      }
+    }
+
+    if( v == !common[0u] || v == !common[1u] )
+    {
+      r.z = ntk.get_constant( true );
+    }
+
+    if( v == common[0u] || v == common[1u] )
+    {
+      r.z = ntk.get_constant( false );
+    }
+
+    return r;
+  }
+
+  std::array<signal<Ntk>, 3> ordered_children( node<Ntk> const& n ) const
+  {
+    std::array<signal<Ntk>, 3> children;
+    ntk.foreach_fanin( n, [&children]( auto const& f, auto i ) { children[i] = f; } );
+    std::sort( children.begin(), children.end(), [this]( auto const& c1, auto const& c2 ) {
+        if( ntk.level( ntk.get_node( c1 ) ) == ntk.level( ntk.get_node( c2 ) ) )
+        {
+          return c1.index < c2.index;
+        }
+        else
+        {
+          return ntk.level( ntk.get_node( c1 ) ) < ntk.level( ntk.get_node( c2 ) );
+        }
+    } );
+    return children;
+  }
+
+  void mark_critical_path( node<Ntk> const& n )
+  {
+    if ( ntk.is_pi( n ) || ntk.is_constant( n ) || ntk.value( n ) )
+      return;
+
+    const auto level = ntk.level( n );
+    ntk.set_value( n, 1 );
+    ntk.foreach_fanin( n, [this, level]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == level - 1 )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+  void mark_critical_paths()
+  {
+    ntk.clear_values();
+    ntk.foreach_po( [this]( auto const& f ) {
+      if ( ntk.level( ntk.get_node( f ) ) == ntk.depth() )
+      {
+        mark_critical_path( ntk.get_node( f ) );
+      }
+    } );
+  }
+
+private:
+  Ntk& ntk;
+  xmg_depth_rewriting_params const& ps;
+};
+
+} // namespace detail
+
+/*! \brief XMG algebraic depth rewriting.
+ *
+ * This algorithm tries to rewrite a network with majority gates for depth
+ * optimization using the associativity and distributivity rule in
+ * majority-of-3 logic.  It can be applied to networks other than XMGs, but
+ * only considers pairs of nodes which both implement the majority-of-3
+ * function and the XOR function.
+ *
+ * **Required network functions:**
+ * - `get_node`
+ * - `level`
+ * - `update_levels`
+ * - `create_maj`
+ * - `substitute_node`
+ * - `foreach_node`
+ * - `foreach_po`
+ * - `foreach_fanin`
+ * - `is_maj`
+ * - `clear_values`
+ * - `set_value`
+ * - `value`
+ * - `fanout_size`
+ *
+   \verbatim embed:rst
+
+  .. note::
+
+      The implementation of this algorithm was heavily inspired by an
+      implementation from Luca Amarù.
+   \endverbatim
+ */
+template<class Ntk>
+void xmg_depth_rewriting( Ntk& ntk, xmg_depth_rewriting_params const& ps = {} )
+{
+  static_assert( is_network_type_v<Ntk>, "Ntk is not a network type" );
+  static_assert( has_get_node_v<Ntk>, "Ntk does not implement the get_node method" );
+  static_assert( has_level_v<Ntk>, "Ntk does not implement the level method" );
+  static_assert( has_create_maj_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_create_xor_v<Ntk>, "Ntk does not implement the create_maj method" );
+  static_assert( has_substitute_node_v<Ntk>, "Ntk does not implement the substitute_node method" );
+  static_assert( has_update_levels_v<Ntk>, "Ntk does not implement the update_levels method" );
+  static_assert( has_foreach_node_v<Ntk>, "Ntk does not implement the foreach_node method" );
+  static_assert( has_foreach_po_v<Ntk>, "Ntk does not implement the foreach_po method" );
+  static_assert( has_foreach_fanin_v<Ntk>, "Ntk does not implement the foreach_fanin method" );
+  static_assert( has_is_maj_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_is_xor3_v<Ntk>, "Ntk does not implement the is_maj method" );
+  static_assert( has_clear_values_v<Ntk>, "Ntk does not implement the clear_values method" );
+  static_assert( has_set_value_v<Ntk>, "Ntk does not implement the set_value method" );
+  static_assert( has_value_v<Ntk>, "Ntk does not implement the value method" );
+  static_assert( has_fanout_size_v<Ntk>, "Ntk does not implement the fanout_size method" );
+
+  detail::xmg_depth_rewriting_impl<Ntk> p( ntk, ps );
+  p.run();
+}
+
+} /* namespace mockturtle */

src/phyLS.cpp

@@ -70,5 +70,11 @@
 #include "commands/abc/balance.hpp"
 #include "commands/abc/refactor.hpp"
 #include "commands/abc/rewrite.hpp"
+#include "commands/xag/rm.hpp"
+#include "commands/xag/rm2.hpp"
+#include "commands/xag/xagrw.hpp"
+#include "commands/xag/xagrs.hpp"
+#include "commands/xmg/xmgrs.hpp"
+#include "commands/xmg/xmgrw.hpp"
 
 ALICE_MAIN(phyLS)