diff --git a/paddle/cinn/adt/CMakeLists.txt b/paddle/cinn/adt/CMakeLists.txt
index 0997562ca548b1..64ab23cd9d638c 100644
--- a/paddle/cinn/adt/CMakeLists.txt
+++ b/paddle/cinn/adt/CMakeLists.txt
@@ -1,45 +1,56 @@
-core_gather_headers()
+if(NOT CINN_ONLY)
+  core_gather_headers()
 
-gather_srcs(
-  cinnapi_src
-  SRCS
-  anchor_sd_equation_context.cc
-  equation_function.cc
-  equation_solver.cc
-  equation_value.cc
-  generate_map_expr.cc
-  get_sub_reshape_dim_ranges.cc
-  graph_symbolic_dim_infer_ctx.cc
-  igroup.cc
-  index_expr_infer_context.cc
-  kgroup.cc
-  m_ir.cc
-  naive_bidirection_equation_generator.cc
-  naive_op_equation_context.cc
-  partition_op_stmts.cc
-  print_equations.cc
-  print_map_expr.cc
-  print_schedule_descriptor.cc
-  print_schedule_dim.cc
-  print_schedule_mesh.cc
-  print_value.cc
-  schedule_descriptor.cc
-  schedule_dim.cc
-  schedule_mesh.cc
-  dim_expr.cc
-  dim_expr_test.cc
-  dim_expr_simplifier.cc
-  symbolic_dim_infer_util.cc
-  simplify_value.cc
-  write_broadcast_disabled_bidirection_equation_generator.cc
-  print_dim_expr.cc)
+  gather_srcs(
+    cinnapi_src
+    SRCS
+    adapter_tensor.cc
+    anchor_sd_equation_context.cc
+    equation_function.cc
+    equation_solver.cc
+    equation_value.cc
+    generate_map_expr.cc
+    get_sub_reshape_dim_ranges.cc
+    graph_symbolic_dim_infer_ctx.cc
+    igroup.cc
+    index_expr_infer_context.cc
+    kgroup.cc
+    m_ir.cc
+    naive_bidirection_equation_generator.cc
+    naive_op_equation_context.cc
+    partition_op_stmts.cc
+    print_equations.cc
+    print_map_expr.cc
+    print_schedule_descriptor.cc
+    print_schedule_dim.cc
+    print_schedule_mesh.cc
+    print_value.cc
+    schedule_descriptor.cc
+    schedule_dim.cc
+    schedule_mesh.cc
+    dim_expr.cc
+    dim_expr_simplifier.cc
+    simplify_value.cc
+    write_broadcast_disabled_bidirection_equation_generator.cc
+    print_dim_expr.cc)
 
-cinn_cc_test(equation_value_match_trait_test SRCS
-             equation_value_match_trait_test.cc DEPS gtest glog)
+  cinn_cc_test(equation_value_match_trait_test SRCS
+               equation_value_match_trait_test.cc DEPS gtest glog)
 
-cinn_cc_test(tree_test SRCS tree_test.cc DEPS gtest glog)
+  cinn_cc_test(tree_test SRCS tree_test.cc DEPS gtest glog)
 
-cinn_cc_test(inline_translator_test SRCS inline_translator_test.cc DEPS gtest
-             glog)
+  cinn_cc_test(inline_translator_test SRCS inline_translator_test.cc DEPS gtest
+               glog)
 
-message(STATUS "ADT srcs: ${cinnapi_src}")
+  cinn_cc_test(
+    dim_expr_test
+    SRCS
+    dim_expr_test.cc
+    DEPS
+    gtest
+    glog
+    cinncore)
+
+  message(STATUS "ADT srcs: ${cinnapi_src}")
+
+endif()
diff --git a/paddle/cinn/adt/adapter_dynamic_tensor.h b/paddle/cinn/adt/adapter_dynamic_tensor.h
index b5408a95401e50..a36c64b19fc449 100644
--- a/paddle/cinn/adt/adapter_dynamic_tensor.h
+++ b/paddle/cinn/adt/adapter_dynamic_tensor.h
@@ -17,37 +17,30 @@
 
 #include "paddle/cinn/adt/adt.h"
 #include "paddle/cinn/adt/symbolic_dim.h"
-#include "paddle/cinn/hlir/framework/graph.h"
-#include "paddle/cinn/hlir/framework/node.h"
+#include "paddle/cinn/hlir/framework/pir/group.h"
 
 namespace cinn::adt::adapter {
 
 struct DynamicTensor final {
-  const hlir::framework::NodeData* node_data;
-  const hlir::framework::Graph* graph;
+  ::pir::Value node_data;
+  const hlir::framework::pir::Group* group;
 
   bool operator==(const DynamicTensor& other) const {
-    return this->node_data == other.node_data && this->graph == other.graph;
+    return this->node_data == other.node_data;
   }
 
   std::size_t GetRank() const {
-    const auto& shape_dict =
-        graph->GetAttrs<absl::flat_hash_map<std::string, utils::ShapeType>>(
-            "infershape");
-    CHECK(shape_dict.count(node_data->id()))
-        << "Can't find " << node_data->id() << " 's shape!";
-    return shape_dict.at(node_data->id()).size();
+    return cinn::hlir::framework::pir::CompatibleInfo::ValueShape(node_data)
+        .size();
   }
 
   const std::vector<std::optional<DimExpr>>& GetShape() const {
-    return graph->graph_ctx()->GetTensorDimExprs(node_data);
+    return group->graph_symbolic_dim_infer_ctx()->GetTensorDimExprs(node_data);
   }
 };
 
 inline std::size_t GetHashValueImpl(const DynamicTensor& tensor) {
-  return hash_combine(
-      std::hash<const hlir::framework::NodeData*>()(tensor.node_data),
-      std::hash<const hlir::framework::Graph*>()(tensor.graph));
+  return std::hash<::pir::Value>()(tensor.node_data);
 }
 
 }  // namespace cinn::adt::adapter
diff --git a/paddle/cinn/adt/adapter_tensor.cc b/paddle/cinn/adt/adapter_tensor.cc
new file mode 100644
index 00000000000000..464c45780dbecd
--- /dev/null
+++ b/paddle/cinn/adt/adapter_tensor.cc
@@ -0,0 +1,44 @@
+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/cinn/adt/adapter_tensor.h"
+#include "glog/logging.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
+
+namespace cinn::adt::adapter {
+
+std::size_t Tensor::GetRank() const {
+  return cinn::hlir::framework::pir::CompatibleInfo::ValueShape(node_data)
+      .size();
+}
+
+std::vector<int32_t> Tensor::GetShape() const {
+  std::vector<int32_t> ret{};
+  for (int dim_size :
+       cinn::hlir::framework::pir::CompatibleInfo::ValueShape(node_data)) {
+    ret.emplace_back(dim_size);
+  }
+  return ret;
+}
+
+std::size_t Tensor::GetNumel() const {
+  std::size_t ret = 1;
+  for (int dim_size :
+       cinn::hlir::framework::pir::CompatibleInfo::ValueShape(node_data)) {
+    ret = ret * dim_size;
+  }
+  return ret;
+}
+
+}  // namespace cinn::adt::adapter
diff --git a/paddle/cinn/adt/adapter_tensor.h b/paddle/cinn/adt/adapter_tensor.h
index 2a6cc941afb89e..dbd2c2dcecfdbb 100644
--- a/paddle/cinn/adt/adapter_tensor.h
+++ b/paddle/cinn/adt/adapter_tensor.h
@@ -13,59 +13,28 @@
 // limitations under the License.
 
 #pragma once
-#include "glog/logging.h"
 
 #include "paddle/cinn/adt/adt.h"
-#include "paddle/cinn/hlir/framework/graph.h"
-#include "paddle/cinn/hlir/framework/node.h"
+#include "paddle/pir/core/value.h"
 
 namespace cinn::adt::adapter {
 
 struct Tensor final {
-  const hlir::framework::NodeData* node_data;
-  const hlir::framework::Graph* graph;
+  ::pir::Value node_data;
 
   bool operator==(const Tensor& other) const {
-    return this->node_data == other.node_data && this->graph == other.graph;
+    return this->node_data == other.node_data;
   }
 
-  std::size_t GetRank() const {
-    const auto& shape_dict =
-        graph->GetAttrs<absl::flat_hash_map<std::string, utils::ShapeType>>(
-            "infershape");
-    CHECK(shape_dict.count(node_data->id()))
-        << "Can't find " << node_data->id() << " 's shape!";
-    return shape_dict.at(node_data->id()).size();
-  }
+  std::size_t GetRank() const;
 
-  const std::vector<int32_t>& GetShape() const {
-    const auto& shape_dict =
-        graph->GetAttrs<absl::flat_hash_map<std::string, utils::ShapeType>>(
-            "infershape");
-    CHECK(shape_dict.count(node_data->id()))
-        << "Can't find " << node_data->id() << " 's shape!";
-    return shape_dict.at(node_data->id());
-  }
+  std::vector<int32_t> GetShape() const;
 
-  std::size_t GetNumel() const {
-    const auto& shape_dict =
-        graph->GetAttrs<absl::flat_hash_map<std::string, utils::ShapeType>>(
-            "infershape");
-    CHECK(shape_dict.count(node_data->id()))
-        << "Can't find " << node_data->id() << " 's shape!";
-    std::vector<int32_t> shape = shape_dict.at(node_data->id());
-    std::size_t ret = 1;
-    for (int32_t dim_size : shape) {
-      ret = ret * dim_size;
-    }
-    return ret;
-  }
+  std::size_t GetNumel() const;
 };
 
 inline std::size_t GetHashValueImpl(const Tensor& tensor) {
-  return hash_combine(
-      std::hash<const hlir::framework::NodeData*>()(tensor.node_data),
-      std::hash<const hlir::framework::Graph*>()(tensor.graph));
+  return std::hash<::pir::Value>()(tensor.node_data);
 }
 
 }  // namespace cinn::adt::adapter
diff --git a/paddle/cinn/adt/equation_value.h b/paddle/cinn/adt/equation_value.h
index a876ffef1bf6d4..1d0c2a134423a5 100644
--- a/paddle/cinn/adt/equation_value.h
+++ b/paddle/cinn/adt/equation_value.h
@@ -20,11 +20,6 @@
 #include "paddle/cinn/adt/equation.h"
 #include "paddle/cinn/adt/match.h"
 
-namespace cinn::hlir::framework {
-class Node;
-class NodeData;
-}  // namespace cinn::hlir::framework
-
 namespace cinn::adt {
 
 DEFINE_ADT_TAG(tPointer);
diff --git a/paddle/cinn/adt/generate_map_expr.cc b/paddle/cinn/adt/generate_map_expr.cc
index 5782902c775f35..124786fb2935b3 100644
--- a/paddle/cinn/adt/generate_map_expr.cc
+++ b/paddle/cinn/adt/generate_map_expr.cc
@@ -28,7 +28,12 @@
 #include "paddle/cinn/adt/schedule_descriptor.h"
 #include "paddle/cinn/adt/symbolic_dim_infer_util.h"
 #include "paddle/cinn/adt/tree.h"
+#include "paddle/cinn/hlir/framework/pir/group.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/runtime/flags.h"
+#include "paddle/pir/core/operation.h"
+#include "paddle/pir/core/value.h"
+#include "paddle/pir/dialect/shape/utils/shape_optimization_utils.h"
 
 #include "glog/logging.h"
 
@@ -87,25 +92,24 @@ using LoopDescriptor4IterVarT = std::function<LoopDescriptor(const Iterator&)>;
 using AnchorTensor = Variable;
 using FakeOpPlaceHolders = List<FakeOpPlaceHolder>;
 
-Op MakeOp(const hlir::framework::Node* op) { return {op}; }
+Op MakeOp(const ::pir::Operation* op) { return {op}; }
 
 template <typename DoEachT>
-void VisitEachInputTensor(const hlir::framework::Node* op,
-                          const DoEachT& DoEach) {
-  for (const auto& graph_edge : op->inlinks_in_order()) {
-    DoEach(graph_edge->source()->safe_as<hlir::framework::NodeData>());
+void VisitEachInputTensor(const ::pir::Operation* op, const DoEachT& DoEach) {
+  for (std::size_t i = 0; i < op->num_operands(); ++i) {
+    DoEach(op->operand_source(i));
   }
 }
 
-List<Arg> MakeOpStmtInputList(const hlir::framework::Node* op,
-                              const hlir::framework::Graph* graph) {
+List<Arg> MakeOpStmtInputList(const ::pir::Operation* op,
+                              const hlir::framework::pir::Group* group) {
   List<Arg> ret{};
 
-  VisitEachInputTensor(op, [&](const auto* tensor) {
+  VisitEachInputTensor(op, [&](const ::pir::Value& tensor) {
     if (FLAGS_cinn_map_expr_enable_dynamic_shape) {
-      ret->emplace_back(adapter::DynamicTensor{tensor, graph});
+      ret->emplace_back(adapter::DynamicTensor{tensor, group});
     } else {
-      ret->emplace_back(adapter::Tensor{tensor, graph});
+      ret->emplace_back(adapter::Tensor{tensor});
     }
   });
 
@@ -113,22 +117,21 @@ List<Arg> MakeOpStmtInputList(const hlir::framework::Node* op,
 }
 
 template <typename DoEachT>
-void VisitEachOutputTensor(const hlir::framework::Node* op,
-                           const DoEachT& DoEach) {
-  for (const auto& graph_edge : op->outlinks_in_order()) {
-    DoEach(graph_edge->sink()->safe_as<hlir::framework::NodeData>());
+void VisitEachOutputTensor(const ::pir::Operation* op, const DoEachT& DoEach) {
+  for (std::size_t i = 0; i < op->num_results(); ++i) {
+    DoEach(const_cast<::pir::Operation*>(op)->result(i));
   }
 }
 
-List<Arg> MakeOpStmtOutputList(const hlir::framework::Node* op,
-                               const hlir::framework::Graph* graph) {
+List<Arg> MakeOpStmtOutputList(const ::pir::Operation* op,
+                               const hlir::framework::pir::Group* group) {
   List<Arg> ret{};
 
-  VisitEachOutputTensor(op, [&](const auto* tensor) {
+  VisitEachOutputTensor(op, [&](const ::pir::Value& tensor) {
     if (FLAGS_cinn_map_expr_enable_dynamic_shape) {
-      ret->emplace_back(adapter::DynamicTensor{tensor, graph});
+      ret->emplace_back(adapter::DynamicTensor{tensor, group});
     } else {
-      ret->emplace_back(adapter::Tensor{tensor, graph});
+      ret->emplace_back(adapter::Tensor{tensor});
     }
   });
 
@@ -136,38 +139,30 @@ List<Arg> MakeOpStmtOutputList(const hlir::framework::Node* op,
 }
 
 template <typename DoEachT>
-void VisitEachOpStmt(
-    const std::shared_ptr<hlir::framework::Graph::Group>& group,
-    const DoEachT& DoEach) {
-  // Note
-  for (const auto* op : group->CollectNodes()) {
+void VisitEachOpStmt(const std::shared_ptr<hlir::framework::pir::Group>& group,
+                     const DoEachT& DoEach) {
+  for (const auto* op : group->CollectOps()) {
     DoEach(OpStmt{MakeOp(op),
-                  MakeOpStmtInputList(op, group->graph_),
-                  MakeOpStmtOutputList(op, group->graph_)});
+                  MakeOpStmtInputList(op, group.get()),
+                  MakeOpStmtOutputList(op, group.get())});
   }
 }
 
-hlir::framework::OpPatternKind GetOpPatternKind(
-    const hlir::framework::Node* node) {
-  static const hlir::framework::OpValueType<hlir::framework::OpPatternKind>&
-      op_pattern_dict =
-          hlir::framework::Operator::GetAttrs<hlir::framework::OpPatternKind>(
-              "OpPattern");
-  auto kind = op_pattern_dict[node->op()];
-  return kind;
+hlir::framework::OpPatternKind GetOpPatternKind(const ::pir::Operation* node) {
+  return hlir::framework::pir::CompatibleInfo::OpKind(*node);
 }
 
 bool CollectRewritedReductionOpStmts(const OpStmt& op_stmt, List<OpStmt>* ret) {
   const auto& [op, inputs, outputs] = op_stmt.tuple();
-  CHECK(op.Has<const hlir::framework::Node*>());
-  if (GetOpPatternKind(op.Get<const hlir::framework::Node*>()) ==
+  CHECK(op.Has<const ::pir::Operation*>());
+  if (GetOpPatternKind(op.Get<const ::pir::Operation*>()) ==
       hlir::framework::OpPatternKind::kReduction) {
-    tReduceInit<const hlir::framework::Node*> init_op{
-        op.Get<const hlir::framework::Node*>()};
+    tReduceInit<const ::pir::Operation*> init_op{
+        op.Get<const ::pir::Operation*>()};
     (*ret)->emplace_back(OpStmt{init_op, List<Arg>{}, outputs});
 
-    tReduceAcc<const hlir::framework::Node*> acc_op{
-        op.Get<const hlir::framework::Node*>()};
+    tReduceAcc<const ::pir::Operation*> acc_op{
+        op.Get<const ::pir::Operation*>()};
     (*ret)->emplace_back(OpStmt{acc_op, inputs, outputs});
     return true;
   } else {
@@ -183,7 +178,7 @@ void CollectRewritedOpStmts(const OpStmt& op_stmt, List<OpStmt>* ret) {
 }
 
 List<OpStmt> MakeOpStmts(
-    const std::shared_ptr<hlir::framework::Graph::Group>& group) {
+    const std::shared_ptr<hlir::framework::pir::Group>& group) {
   List<OpStmt> ret{};
 
   VisitEachOpStmt(group, [&](const auto& op_stmt) {
@@ -212,15 +207,14 @@ std::shared_ptr<IGroup> MakeIGroup(const AnchorGroup& igroup_spec) {
   std::shared_ptr<DirectionEquationGenerator> direction_equation_generator{
       new NaiveBidirectionEquationGenerator{igroup_spec.op_stmts,
                                             igroup_spec.EquationCtx4OpStmt}};
-  CheckEquationSolvable(
-      igroup_spec, direction_equation_generator);
+  CheckEquationSolvable(igroup_spec, direction_equation_generator);
   return std::make_shared<IGroup>(igroup_spec.op_stmts,
                                   igroup_spec.anchor_index,
                                   igroup_spec.EquationCtx4OpStmt);
 }
 
 std::vector<std::shared_ptr<IGroup>> GenerateIGroups(
-    const std::shared_ptr<hlir::framework::Graph::Group>& group) {
+    const std::shared_ptr<hlir::framework::pir::Group>& group) {
   std::vector<std::shared_ptr<IGroup>> ret{};
 
   List<OpStmt> op_stmts = MakeOpStmts(group);
@@ -234,7 +228,7 @@ std::vector<std::shared_ptr<IGroup>> GenerateIGroups(
 }
 
 std::shared_ptr<KGroup> GenerateKGroups(
-    const std::shared_ptr<hlir::framework::Graph::Group>& group,
+    const std::shared_ptr<hlir::framework::pir::Group>& group,
     const std::vector<std::shared_ptr<IGroup>>& igroups) {
   CHECK_EQ(igroups.size(), 1);
   return std::make_shared<KGroup>(group, igroups);
@@ -274,8 +268,7 @@ std::shared_ptr<IndexExprInferContext> SolveEquationsThenReturnCtx(
   GraphView merged_view = igroup_view.Merge(sd_equation_graph_view);
 
   const auto& init_var2value = MakeSdIterator2Iterator(*igroup);
-  auto ctx = std::make_shared<IndexExprInferContext>(
-      init_var2value);
+  auto ctx = std::make_shared<IndexExprInferContext>(init_var2value);
 
   std::vector<Variable> starts{};
   for (const auto& loop_iterator : *igroup->loop_iterators()) {
@@ -350,36 +343,34 @@ Tensor GetAnchorTensor(const std::shared_ptr<IGroup>& igroup) {
 }
 
 template <typename DoEachT>
-void VisitInputTensor(const hlir::framework::Graph::Group& group,
+void VisitInputTensor(const hlir::framework::pir::Group& group,
                       const DoEachT& DoEach) {
-  for (const auto* node_data : group.GetInputNodeDatas()) {
-    DoEach(node_data, group.graph_);
+  for (const ::pir::Value& node_data : group.GetInputOpValues()) {
+    DoEach(node_data);
   }
 }
 
 template <typename DoEachT>
-void VisitOutputTensor(const hlir::framework::Graph::Group& group,
+void VisitOutputTensor(const hlir::framework::pir::Group& group,
                        const DoEachT& DoEach) {
-  for (const auto& node_data : group.GetOutputNodeDatas()) {
-    DoEach(node_data, group.graph_);
+  for (const ::pir::Value& node_data : group.GetOutputOpValues()) {
+    DoEach(node_data);
   }
 }
 
 List<Tensor> MakeInputTensors(const std::shared_ptr<KGroup>& kgroup) {
   List<Tensor> ret{};
-  VisitInputTensor(*kgroup->cinn_group(),
-                   [&](const auto* node_data, const auto* graph) {
-                     ret->emplace_back(adapter::Tensor{node_data, graph});
-                   });
+  VisitInputTensor(*kgroup->cinn_group(), [&](const ::pir::Value& node_data) {
+    ret->emplace_back(adapter::Tensor{node_data});
+  });
   return ret;
 }
 
 List<Tensor> MakeOutputTensors(const std::shared_ptr<KGroup>& kgroup) {
   List<Tensor> ret{};
-  VisitOutputTensor(*kgroup->cinn_group(),
-                    [&](const auto* node_data, const auto* graph) {
-                      ret->emplace_back(adapter::Tensor{node_data, graph});
-                    });
+  VisitOutputTensor(*kgroup->cinn_group(), [&](const ::pir::Value& node_data) {
+    ret->emplace_back(adapter::Tensor{node_data});
+  });
   return ret;
 }
 
@@ -444,7 +435,7 @@ MapExpr GenerateMapExpr(const std::shared_ptr<KGroup>& kgroup) {
 }  // namespace
 
 MapExpr GenerateMapExpr(
-    const std::shared_ptr<hlir::framework::Graph::Group>& group) {
+    const std::shared_ptr<hlir::framework::pir::Group>& group) {
   const auto& igroups = GenerateIGroups(group);
 
   const auto& kgroup = GenerateKGroups(group, igroups);
@@ -453,16 +444,35 @@ MapExpr GenerateMapExpr(
 }
 
 void TryGenerateMapExprFromGraph(
-    const std::shared_ptr<cinn::hlir::framework::Graph>& graph) {
+    const hlir::framework::pir::GroupList& groups) {
   if (!FLAGS_cinn_enable_map_expr) {
     return;
   }
-  graph->set_graph_ctx(adt::InferSymbolicDim(graph.get()));
-  for (const auto& fusion_group : graph->fusion_groups) {
+  for (const auto& fusion_group : groups) {
+    // ADT_TODO : Fake pointer here, remove this later
+    ::pir::SymbolicDimMgr* symbolic_dim_mgr;
+    fusion_group->set_graph_symbolic_dim_infer_ctx(
+        std::make_unique<config::GraphSymbolicDimInferCtx>(fusion_group.get(),
+                                                           symbolic_dim_mgr));
     const auto& map_expr = GenerateMapExpr(fusion_group);
     VLOG(1) << ToTxtString(map_expr, fusion_group->group_id);
     fusion_group->set_map_expr_ctx(std::make_shared<MapExprCtx>(map_expr));
   }
 }
 
+void TryGenerateMapExprFromGroup(
+    const std::shared_ptr<hlir::framework::pir::Group>& fusion_group) {
+  if (!FLAGS_cinn_enable_map_expr) {
+    return;
+  }
+  // ADT_TODO : Fake pointer here, remove this later
+  ::pir::SymbolicDimMgr* symbolic_dim_mgr;
+  fusion_group->set_graph_symbolic_dim_infer_ctx(
+      std::make_unique<config::GraphSymbolicDimInferCtx>(fusion_group.get(),
+                                                         symbolic_dim_mgr));
+  const auto& map_expr = GenerateMapExpr(fusion_group);
+  VLOG(1) << ToTxtString(map_expr, fusion_group->group_id);
+  fusion_group->set_map_expr_ctx(std::make_shared<MapExprCtx>(map_expr));
+}
+
 }  // namespace cinn::adt
diff --git a/paddle/cinn/adt/generate_map_expr.h b/paddle/cinn/adt/generate_map_expr.h
index cd2970559cb6b0..e9235dd625270b 100644
--- a/paddle/cinn/adt/generate_map_expr.h
+++ b/paddle/cinn/adt/generate_map_expr.h
@@ -14,19 +14,25 @@
 
 #pragma once
 
-#include "paddle/cinn/adt/m_ir.h"
+#include <vector>
+
 #include "paddle/cinn/adt/map_expr.h"
-#include "paddle/cinn/hlir/framework/graph.h"
 
-namespace cinn::adt {
+namespace cinn::hlir::framework::pir {
+
+struct Group;
+using GroupList = std::vector<std::shared_ptr<Group>>;
 
-class IGroup;
-class KGroup;
+}  // namespace cinn::hlir::framework::pir
+
+namespace cinn::adt {
 
 MapExpr GenerateMapExpr(
-    const std::shared_ptr<cinn::hlir::framework::Graph::Group>& group);
+    const std::shared_ptr<cinn::hlir::framework::pir::Group>& group);
+
+void TryGenerateMapExprFromGraph(const hlir::framework::pir::GroupList& groups);
 
-void TryGenerateMapExprFromGraph(
-    const std::shared_ptr<cinn::hlir::framework::Graph>& graph);
+void TryGenerateMapExprFromGroup(
+    const std::shared_ptr<hlir::framework::pir::Group>& fusion_group);
 
 }  // namespace cinn::adt
diff --git a/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.cc b/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.cc
index 83fc92a203c0f6..0aa0e0d08c8ddb 100644
--- a/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.cc
+++ b/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.cc
@@ -16,57 +16,148 @@
 
 #include "paddle/cinn/adt/dim_expr_simplifier.h"
 #include "paddle/cinn/adt/unique_id.h"
-#include "paddle/cinn/common/graph_utils.h"
-#include "paddle/cinn/hlir/framework/graph.h"
-#include "paddle/cinn/hlir/framework/node.h"
+#include "paddle/cinn/adt/arithmetic.h"
+#include "paddle/cinn/adt/logical.h"
+#include "paddle/cinn/adt/adt.h"
+#include "paddle/cinn/hlir/framework/pir/group.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
+#include "paddle/pir/core/operation.h"
+#include "paddle/pir/core/value.h"
+#include "paddle/pir/dialect/shape/utils/shape_optimization_utils.h"
 
 namespace cinn::adt::config {
 
 namespace {
 
-const std::vector<int32_t>& GetShape(const hlir::framework::Graph* graph,
-                                     const hlir::framework::NodeData* tensor) {
-  const auto& shape_dict =
-      graph->GetAttrs<absl::flat_hash_map<std::string, utils::ShapeType>>(
-          "infershape");
-  CHECK(shape_dict.count(tensor->id()))
-      << "Can't find " << tensor->id() << " 's shape!";
-  return shape_dict.at(tensor->id());
+// clang-format off
+// Dim equations' configuration:
+//
+//     ShapeDialectConstraints = [ShapeDialectConstraint]
+//     ShapeDialectConstraint = Equal ShapeDialectDimExpr ShapeDialectDimExpr
+//
+//     ShapeDialectDimExpr = ShapeDialectAtomicDim
+//                         | Product ShapeDialectAtomicDim
+//
+//     ShapeDialectAtomicDim = int64_t | ShapeDialectSymbolicDim
+//     ShapeDialectSymbolicDim = (::pir::Value, tAxis int)
+//
+//
+// Dim equations' variables:
+//
+//     ShapeDialectSymbolicDim
+//
+// Dim equations' functions:
+// DimFunction = DimIdentity (tOut ShapeDialectSymbolicDim) (tIn ShapeDialectSymbolicDim)
+//             | DimProduct (tOut ShapeDialectSymbolicDim) [tIn ShapeDialectSymbolicDim]
+//             | DimReciprocal (tOut ShapeDialectSymbolicDim) (tIn ShapeDialectSymbolicDim)
+//
+// Dim equations' solutions:
+//
+//     DimExpr
+// clang-format on
+
+// ShapeDialectSymbolicDim = (::pir::Value, tAxis int)
+struct ShapeDialectSymbolicDim {
+ ::pir::Value tensor;
+ int axis;
+
+ bool operator==(const ShapeDialectSymbolicDim& other) const {
+   return this->tensor == other.tensor && this->axis == other.tensor;
+ }
+};
+// ShapeDialectAtomicDim = int64_t | ShapeDialectSymbolicDim
+DEFINE_ADT_UNION(ShapeDialectAtomicDim, std::int64_t, ShapeDialectSymbolicDim);
+// ShapeDialectDimExpr = ShapeDialectAtomicDim
+//                     | Product ShapeDialectAtomicDim
+DEFINE_ADT_UNION(ShapeDialectDimExpr,
+                 ShapeDialectAtomicDim,
+                 Product<ShapeDialectAtomicDim>);
+// ShapeDialectConstraint = Equal ShapeDialectDimExpr ShapeDialectDimExpr
+using ShapeDialectConstraint = Equal<ShapeDialectDimExpr, ShapeDialectDimExpr>;
+// ShapeDialectConstraints = [ShapeDialectConstraint]
+using ShapeDialectConstraints = List<ShapeDialectConstraint>;
+
+template<typename T0, typename T1>
+struct DimIdentity;
+
+// DimIdentity (tOut ShapeDialectSymbolicDim) (tIn ShapeDialectSymbolicDim)
+template<>
+struct DimIdentity<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>>
+    : public Tuple<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>> {
+  using Tuple<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>>::Tuple;
+};
+
+template<typename T0, typename T1>
+struct DimProduct;
+
+// DimProduct (tOut ShapeDialectSymbolicDim) [tIn ShapeDialectSymbolicDim]
+template<>
+struct DimProduct<tOut<ShapeDialectSymbolicDim>, List<tIn<ShapeDialectSymbolicDim>>>
+    : public Tuple<tOut<ShapeDialectSymbolicDim>, List<tIn<ShapeDialectSymbolicDim>>> {
+  using Tuple<tOut<ShapeDialectSymbolicDim>, List<tIn<ShapeDialectSymbolicDim>>>::Tuple;
+};
+
+// DimReciprocal (tOut ShapeDialectSymbolicDim) (tIn ShapeDialectSymbolicDim)
+template<>
+struct DimReciprocal<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>>
+    : public Tuple<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>> {
+  using Tuple<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>>::Tuple;
+};
+
+// DimFunction = DimIdentity (tOut ShapeDialectSymbolicDim) (tIn ShapeDialectSymbolicDim)
+//             | DimProduct (tOut ShapeDialectSymbolicDim) [tIn ShapeDialectSymbolicDim]
+//             | DimReciprocal (tOut ShapeDialectSymbolicDim) (tIn ShapeDialectSymbolicDim)
+
+DEFINE_ADT_UNION(DimFunction,
+                 DimIdentity<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>>,
+                 DimProduct<tOut<ShapeDialectSymbolicDim>, List<tIn<ShapeDialectSymbolicDim>>>,
+                 DimReciprocal<tOut<ShapeDialectSymbolicDim>, tIn<ShapeDialectSymbolicDim>>);
+}
+
 }
 
-std::size_t GetTensorRank(const hlir::framework::Graph* graph,
-                          const hlir::framework::NodeData* tensor) {
-  const auto& shape_dict =
-      graph->GetAttrs<absl::flat_hash_map<std::string, utils::ShapeType>>(
-          "infershape");
-  CHECK(shape_dict.count(tensor->id()))
-      << "Can't find " << tensor->id() << " 's shape!";
-  return shape_dict.at(tensor->id()).size();
+namespace std {
+
+template<>
+struct hash<cinn::adt::config::ShapeDialectSymbolicDim> final {
+  using namespace cinn::adt::config;
+  std::size_t operator()(const ShapeDialectSymbolicDim& dim) const {
+    return hash_combine(std::hash<::pir::Value>()(dim.tensor), dim.axis);
+  }
+};
+
+}
+
+namespace cinn::adt::config {
+
+namespace {
+
+std::vector<int32_t> GetShape(const ::pir::Value& tensor) {
+  std::vector<int> tensor_shape =
+      hlir::framework::pir::CompatibleInfo::ValueShape(tensor);
+  std::vector<int32_t> ret{};
+  for (int32_t dim : tensor_shape) {
+    ret.push_back(dim);
+  }
+  return ret;
 }
 
-std::vector<std::uint64_t> GetOpInputRanks(const hlir::framework::Graph* graph,
-                                           const hlir::framework::Node* node) {
+std::size_t GetTensorRank(const ::pir::Value& tensor) {
+  return hlir::framework::pir::CompatibleInfo::ValueShape(tensor).size();
+}
+
+std::vector<std::uint64_t> GetOpInputRanks(const ::pir::Operation* node) {
   std::vector<std::uint64_t> ret{};
-  for (const auto& graph_edge : node->inlinks_in_order()) {
-    const hlir::framework::NodeData* tensor =
-        graph_edge->source()->safe_as<hlir::framework::NodeData>();
-    ret.emplace_back(GetTensorRank(graph, tensor));
+  for (const ::pir::Value& tensor : node->operands_source()) {
+    ret.emplace_back(GetTensorRank(tensor));
   }
   return ret;
 }
 
-std::vector<const hlir::framework::Node*> GetTopoOrderOpNodes(
-    const hlir::framework::Graph* graph) {
-  std::vector<const hlir::framework::Node*> ret{};
-  std::vector<common::GraphNode*> topo_nodes =
-      std::get<0>(graph->topological_order());
-  for (const common::GraphNode* graph_node : topo_nodes) {
-    const hlir::framework::Node* op_node =
-        graph_node->safe_as<hlir::framework::Node>();
-    // if node is NodeData or not op, continue.
-    if (!op_node || op_node->op() == nullptr) {
-      continue;
-    }
+std::vector<const ::pir::Operation*> GetTopoOrderOpNodes(
+    const hlir::framework::pir::Group* group) {
+  std::vector<const ::pir::Operation*> ret{};
+  for (const ::pir::Operation* op_node : group->ops) {
     ret.emplace_back(op_node);
   }
   return ret;
@@ -74,44 +165,34 @@ std::vector<const hlir::framework::Node*> GetTopoOrderOpNodes(
 
 }  // namespace
 
-void GraphSymbolicDimInferCtx::InitOp2TensorRanks() {
-  for (const hlir::framework::Node* op_node : GetTopoOrderOpNodes(graph_)) {
-    const auto& input_ranks = GetOpInputRanks(graph_, op_node);
-    if (op2input_ranks_.find(op_node) == op2input_ranks_.end()) {
-      op2input_ranks_.emplace(op_node, input_ranks);
-    } else {
-      CHECK(input_ranks == op2input_ranks_.at(op_node));
-    }
-  }
-}
-
 namespace {
 
 std::unordered_set<std::string> GetAllOutputNames(
-    const std::vector<const hlir::framework::Node*>& nodes) {
+    const std::vector<const ::pir::Operation*>& nodes) {
   std::unordered_set<std::string> output_names;
-  for (const auto* node : nodes) {
-    for (const auto& link : node->outlinks()) {
-      const auto* out_node = link->sink()->safe_as<hlir::framework::NodeData>();
-      output_names.emplace(out_node->id());
+  for (const auto* op_node : nodes) {
+    for (const ::pir::Value& out_node :
+         const_cast<::pir::Operation*>(op_node)->results()) {
+      output_names.emplace(
+          hlir::framework::pir::CompatibleInfo::ValueName(out_node));
     }
   }
   return output_names;
 }
 
-std::vector<const hlir::framework::NodeData*> GetFeedList(
-    const std::vector<const hlir::framework::Node*>& nodes,
+std::vector<::pir::Value> GetFeedList(
+    const std::vector<const ::pir::Operation*>& op_nodes,
     const std::unordered_set<std::string>& out_names) {
-  std::vector<const hlir::framework::NodeData*> ret{};
+  std::vector<::pir::Value> ret{};
   // if the op's input var name cannot found in out_names, it is the group's
   // feed var
   std::unordered_set<std::string> feed_names;
-  for (const auto* node : nodes) {
-    for (const auto& link : node->inlinks()) {
-      const auto* in_node =
-          link->source()->safe_as<hlir::framework::NodeData>();
-      if (!out_names.count(in_node->id()) && !feed_names.count(in_node->id())) {
-        feed_names.emplace(in_node->id());
+  for (const auto* op_node : op_nodes) {
+    for (const ::pir::Value in_node : op_node->operands_source()) {
+      const auto& node_id =
+          hlir::framework::pir::CompatibleInfo::ValueName(in_node);
+      if (!out_names.count(node_id) && !feed_names.count(node_id)) {
+        feed_names.emplace(node_id);
         ret.emplace_back(in_node);
       }
     }
@@ -120,15 +201,13 @@ std::vector<const hlir::framework::NodeData*> GetFeedList(
 }
 
 std::vector<std::optional<DimExpr>> MakeDimExprForTensor(
-    const hlir::framework::Graph* graph,
-    const hlir::framework::NodeData* node_data) {
+    const ::pir::Value& node_data) {
   std::vector<std::optional<DimExpr>> ret{};
 
-  const std::vector<int32_t>& shape = GetShape(graph, node_data);
+  std::vector<int32_t> shape = GetShape(node_data);
   for (std::size_t i = 0; i < shape.size(); ++i) {
     if (i == 0) {
-      static DimExpr temp_elementwise_dim_expr{
-          SymbolicDim{UniqueId::New()}};
+      static DimExpr temp_elementwise_dim_expr{SymbolicDim{UniqueId::New()}};
       ret.emplace_back(temp_elementwise_dim_expr);
     } else {
       ret.emplace_back(DimExpr{shape.at(i)});
@@ -139,68 +218,93 @@ std::vector<std::optional<DimExpr>> MakeDimExprForTensor(
 
 }  // namespace
 
-void GraphSymbolicDimInferCtx::InitGraphInputDimExpr() {
-  std::vector<const hlir::framework::Node*> topo_op_nodes =
-      GetTopoOrderOpNodes(graph_);
-  std::vector<const hlir::framework::NodeData*> feed_list =
-      GetFeedList(topo_op_nodes, GetAllOutputNames(topo_op_nodes));
-  for (const hlir::framework::NodeData* node_data : feed_list) {
-    CHECK(
-        tensor2dim_exprs_
-            .emplace(node_data, MakeDimExprForTensor(graph_, node_data))
-            .second);
+namespace {
+
+template <typename DoEachT>
+void VisitEachTensorPair(const ::pir::Operation* op_node,
+                         const DoEachT& DoEach) {
+  std::vector<::pir::Value> all_tensors{};
+  for (const ::pir::Value tensor : op_node->operands_source()) {
+    all_tensors.emplace_back(tensor);
   }
+  for (const ::pir::Value tensor : op_node->results()) {
+    all_tensors.emplace_back(tensor);
+  }
+  for (std::size_t i = 0; i < all_tensors.size(); ++i) {
+    for (std::size_t j = i + 1; j < all_tensors.size(); ++j) {
+      DoEach(all_tensors.at(i), all_tensors.at(j));
+    }
+  }
+}
+
+void BuildTensorShapeDialectConstraints(
+    const ::pir::Value& lhs,
+    const ::pir::Value& rhs,
+    const ::pir::SymbolicDimMgr* symbolic_dim_mgr,
+    ShapeDialectConstraints* ret) {
+  const auto& lhs_symbolic_dim_ops =
+      symbolic_dim_mgr->CreateSymbolicDimsForRankedValue(lhs);
+  ADT_TODO();
 }
 
-const std::vector<std::uint64_t>& GraphSymbolicDimInferCtx::GetInTensorsRanks(
-    const hlir::framework::Node* node) const {
-  const auto& iter = op2input_ranks_.find(node);
-  CHECK(iter != op2input_ranks_.end());
-  return iter->second;
-}
-
-std::uint64_t GraphSymbolicDimInferCtx::GetNumOutTensors(
-    const hlir::framework::Node* node) const {
-  return node->outlinks_in_order().size();
-}
-
-const DimExpr& GraphSymbolicDimInferCtx::GetInputDimExpr(
-    const hlir::framework::Node* node,
-    std::size_t arg_idx,
-    std::size_t dim_idx) const {
-  const auto& edges = node->inlinks_in_order();
-  CHECK_LT(arg_idx, edges.size());
-  const hlir::framework::NodeData* tensor =
-      edges.at(arg_idx)->source()->safe_as<hlir::framework::NodeData>();
-  const auto& iter = tensor2dim_exprs_.find(tensor);
-  CHECK(iter != tensor2dim_exprs_.end());
-  CHECK_LT(dim_idx, iter->second.size());
-  const auto& opt_dim_expr = iter->second.at(dim_idx);
-  CHECK(opt_dim_expr.has_value());
-  return opt_dim_expr.value();
-}
-
-void GraphSymbolicDimInferCtx::SetOutputDimExpr(
-    const hlir::framework::Node* node,
-    std::size_t arg_idx,
-    std::size_t dim_idx,
-    const DimExpr& value) {
-  const auto& edges = node->outlinks_in_order();
-  CHECK_LT(arg_idx, edges.size());
-  const hlir::framework::NodeData* tensor =
-      edges.at(arg_idx)->sink()->safe_as<hlir::framework::NodeData>();
-  std::size_t rank = GetTensorRank(graph_, tensor);
-  CHECK_LT(dim_idx, rank);
-  auto* opt_symbolic_dims = &tensor2dim_exprs_[tensor];
-  if (dim_idx >= opt_symbolic_dims->size()) {
-    opt_symbolic_dims->resize(dim_idx + 1);
+void BuildOpShapeDialectConstraints(
+    const ::pir::Operation* op_node,
+    const ::pir::SymbolicDimMgr* symbolic_dim_mgr,
+    ShapeDialectConstraints* ret) {
+  VisitEachTensorPair(
+      op_node, [&](const ::pir::Value& lhs, const ::pir::Value& rhs) {
+        BuildTensorShapeDialectConstraints(lhs, rhs, symbolic_dim_mgr, ret);
+      });
+}
+
+ShapeDialectConstraints BuildGraphShapeDialectConstraints(
+    const cinn::hlir::framework::pir::Group* group,
+    const ::pir::SymbolicDimMgr* symbolic_dim_mgr) {
+  ShapeDialectConstraints ret{};
+  for (const ::pir::Operation* op_node : group->ops) {
+    BuildOpShapeDialectConstraints(op_node, symbolic_dim_mgr, &ret);
   }
-  opt_symbolic_dims->at(dim_idx) = SimplifyDimExpr(value);
+  return ret;
+}
+
+// ADT_TODO();
+using GraphView =
+    EquationGraphTopoWalker<ShapeDialectSymbolicDim, const DimFunction*>;
+
+GraphView MakeEquationGraphView(const ShapeDialectConstraints& constraints,
+                                const cinn::hlir::framework::pir::Group* group,
+                                const ::pir::SymbolicDimMgr* symbolic_dim_mgr) {
+  ADT_TODO();
+}
+
+std::unordered_map<ShapeDialectSymbolicDim, DimExpr> MakeEquationStartExpr(
+    const GraphView& graph_view,
+    const cinn::hlir::framework::pir::Group* group,
+    const ::pir::SymbolicDimMgr* symbolic_dim_mgr) {
+  ADT_TODO();
 }
 
-const hlir::framework::AttrMapType& GraphSymbolicDimInferCtx::GetAttributeMap(
-    const hlir::framework::Node* op_node) const {
-  return op_node->attrs.attr_store;
+std::unordered_map<::pir::Value, std::vector<std::optional<DimExpr>>>
+SolveShapeDialectConstraints(
+    const GraphView& graph_view,
+    const std::unordered_map<ShapeDialectSymbolicDim, DimExpr>&
+        equation_start) {
+  ADT_TODO();
+}
+
+}  // namespace
+
+void GraphSymbolicDimInferCtx::InitTensorDimExpr() {
+  ShapeDialectConstraints constraints =
+      BuildGraphShapeDialectConstraints(group_, symbolic_dim_mgr_);
+
+  const auto& graph_view =
+      MakeEquationGraphView(constraints, group_, symbolic_dim_mgr_);
+
+  const auto& equation_start =
+      MakeEquationStartExpr(graph_view, group_, symbolic_dim_mgr_);
+
+  tensor2dim_exprs_ = SolveShapeDialectConstraints(graph_view, equation_start);
 }
 
 }  // namespace cinn::adt::config
diff --git a/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.h b/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.h
index 58bda1f4e9b2eb..24d866d35a383c 100644
--- a/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.h
+++ b/paddle/cinn/adt/graph_symbolic_dim_infer_ctx.h
@@ -19,13 +19,16 @@
 #include <vector>
 
 #include "paddle/cinn/adt/dim_expr.h"
-#include "paddle/cinn/hlir/framework/node.h"
+#include "paddle/cinn/utils/type_defs.h"
+#include "paddle/pir/core/value.h"
+namespace pir {
+class Operation;
+class SymbolicDimMgr;
+}  // namespace pir
 
-namespace cinn::hlir::framework {
-class Graph;
-class NodeData;
-class Node;
-}  // namespace cinn::hlir::framework
+namespace cinn::hlir::framework::pir {
+struct Group;
+}  // namespace cinn::hlir::framework::pir
 
 namespace cinn::adt::config {
 
@@ -34,48 +37,29 @@ class GraphSymbolicDimInferCtx {
   GraphSymbolicDimInferCtx(const GraphSymbolicDimInferCtx&) = delete;
   GraphSymbolicDimInferCtx(GraphSymbolicDimInferCtx&&) = delete;
 
-  explicit GraphSymbolicDimInferCtx(const hlir::framework::Graph* graph)
-      : graph_(graph) {
-    InitOp2TensorRanks();
-    InitGraphInputDimExpr();
+  explicit GraphSymbolicDimInferCtx(
+      const cinn::hlir::framework::pir::Group* group,
+      const ::pir::SymbolicDimMgr* symbolic_dim_mgr)
+      : group_(group), symbolic_dim_mgr_(symbolic_dim_mgr) {
+    InitTensorDimExpr();
   }
 
-  const hlir::framework::Graph* graph() const { return graph_; }
-
-  const std::vector<std::uint64_t>& GetInTensorsRanks(
-      const hlir::framework::Node* node) const;
-
-  std::uint64_t GetNumOutTensors(const hlir::framework::Node* node) const;
-
-  const DimExpr& GetInputDimExpr(const hlir::framework::Node* node,
-                                         std::size_t arg_idx,
-                                         std::size_t dim_idx) const;
+  const cinn::hlir::framework::pir::Group* group() const { return group_; }
 
   const std::vector<std::optional<DimExpr>>& GetTensorDimExprs(
-      const hlir::framework::NodeData* tensor) const {
+      const ::pir::Value tensor) const {
     const auto& iter = tensor2dim_exprs_.find(tensor);
     CHECK(iter != tensor2dim_exprs_.end());
     return iter->second;
   }
 
-  void SetOutputDimExpr(const hlir::framework::Node* node,
-                        std::size_t arg_idx,
-                        std::size_t dim_idx,
-                        const DimExpr& value);
-
-  const hlir::framework::AttrMapType& GetAttributeMap(
-      const hlir::framework::Node* node) const;
-
  private:
-  void InitOp2TensorRanks();
-  void InitGraphInputDimExpr();
+  void InitTensorDimExpr();
 
-  const hlir::framework::Graph* graph_;
-  std::unordered_map<const hlir::framework::NodeData*,
-                     std::vector<std::optional<DimExpr>>>
+  const cinn::hlir::framework::pir::Group* group_;
+  const ::pir::SymbolicDimMgr* symbolic_dim_mgr_;
+  std::unordered_map<::pir::Value, std::vector<std::optional<DimExpr>>>
       tensor2dim_exprs_;
-  std::unordered_map<const hlir::framework::Node*, std::vector<std::uint64_t>>
-      op2input_ranks_;
 };
 
 }  // namespace cinn::adt::config
diff --git a/paddle/cinn/adt/inline_translator.h b/paddle/cinn/adt/inline_translator.h
index 9560750bd2882e..d3910791f32b04 100644
--- a/paddle/cinn/adt/inline_translator.h
+++ b/paddle/cinn/adt/inline_translator.h
@@ -15,47 +15,12 @@
 #pragma once
 
 #include "paddle/cinn/adt/adt.h"
+#include "paddle/cinn/adt/inline_translator_trait.h"
 #include "paddle/cinn/adt/map_expr.h"
 #include "paddle/cinn/adt/tree.h"
 
 namespace cinn::adt {
 
-template <template <typename> class MapT>
-struct InlineTranslatorTrait;
-
-template <>
-struct InlineTranslatorTrait<MapStmt> final {
-  template <typename T>
-  static List<T> GetTreeInnerNodeChildren(const MapStmt<T>& map_stmt) {
-    const auto& [iterators, stmts] = map_stmt.tuple();
-    return stmts;
-  }
-
-  template <typename SrcTreeT, typename DstTreeT>
-  static MapStmt<DstTreeT> ConvertMap(const MapStmt<SrcTreeT>& src_map,
-                                      const List<DstTreeT>& dst_children) {
-    const auto& [iterators, src_children] = src_map.tuple();
-    return MapStmt<DstTreeT>{iterators, dst_children};
-  }
-};
-
-// OpCall T = (Op, [T])
-template <>
-struct InlineTranslatorTrait<OpCall> final {
-  template <typename T>
-  static List<T> GetTreeInnerNodeChildren(const OpCall<T>& op_call) {
-    const auto& [op, tensors] = op_call.tuple();
-    return tensors;
-  }
-
-  template <typename SrcTreeT, typename DstTreeT>
-  static OpCall<DstTreeT> ConvertMap(const OpCall<SrcTreeT>& src_map,
-                                     const List<DstTreeT>& dst_children) {
-    const auto& [op, _] = src_map.tuple();
-    return OpCall<DstTreeT>{op, dst_children};
-  }
-};
-
 template <template <typename> class MapT,
           template <typename>
           class OpCallT,
diff --git a/paddle/cinn/adt/inline_translator_trait.h b/paddle/cinn/adt/inline_translator_trait.h
new file mode 100644
index 00000000000000..3116415dcba05c
--- /dev/null
+++ b/paddle/cinn/adt/inline_translator_trait.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/cinn/adt/adt.h"
+#include "paddle/cinn/adt/map_expr.h"
+
+namespace cinn::adt {
+
+template <template <typename> class MapT>
+struct InlineTranslatorTrait;
+
+template <>
+struct InlineTranslatorTrait<MapStmt> final {
+  template <typename T>
+  static List<T> GetTreeInnerNodeChildren(const MapStmt<T>& map_stmt) {
+    const auto& [iterators, stmts] = map_stmt.tuple();
+    return stmts;
+  }
+
+  template <typename SrcTreeT, typename DstTreeT>
+  static MapStmt<DstTreeT> ConvertMap(const MapStmt<SrcTreeT>& src_map,
+                                      const List<DstTreeT>& dst_children) {
+    const auto& [iterators, src_children] = src_map.tuple();
+    return MapStmt<DstTreeT>{iterators, dst_children};
+  }
+};
+
+// OpCall T = (Op, [T])
+template <>
+struct InlineTranslatorTrait<OpCall> final {
+  template <typename T>
+  static List<T> GetTreeInnerNodeChildren(const OpCall<T>& op_call) {
+    const auto& [op, tensors] = op_call.tuple();
+    return tensors;
+  }
+
+  template <typename SrcTreeT, typename DstTreeT>
+  static OpCall<DstTreeT> ConvertMap(const OpCall<SrcTreeT>& src_map,
+                                     const List<DstTreeT>& dst_children) {
+    const auto& [op, _] = src_map.tuple();
+    return OpCall<DstTreeT>{op, dst_children};
+  }
+};
+
+}  // namespace cinn::adt
diff --git a/paddle/cinn/adt/kgroup.h b/paddle/cinn/adt/kgroup.h
index 9227e5500cb9ae..ba071ed86f242f 100644
--- a/paddle/cinn/adt/kgroup.h
+++ b/paddle/cinn/adt/kgroup.h
@@ -19,6 +19,12 @@
 
 #include "paddle/cinn/adt/map_expr.h"
 
+namespace cinn::hlir::framework::pir {
+
+struct Group;
+
+}  // namespace cinn::hlir::framework::pir
+
 namespace cinn::adt {
 
 class IGroup;
@@ -27,11 +33,11 @@ using cinn::adt::LoopDescriptors;
 class KGroup final {
  public:
   explicit KGroup(
-      const std::shared_ptr<hlir::framework::Graph::Group>& cinn_group,
+      const std::shared_ptr<hlir::framework::pir::Group>& cinn_group,
       const std::vector<std::shared_ptr<IGroup>>& igroups)
       : cinn_group_(cinn_group), igroups_(igroups) {}
 
-  std::shared_ptr<hlir::framework::Graph::Group> cinn_group() const {
+  std::shared_ptr<hlir::framework::pir::Group> cinn_group() const {
     return CHECK_NOTNULL(cinn_group_.lock());
   }
 
@@ -46,7 +52,7 @@ class KGroup final {
       const std::shared_ptr<IGroup>& igroup) const;
 
  private:
-  std::weak_ptr<hlir::framework::Graph::Group> cinn_group_;
+  std::weak_ptr<hlir::framework::pir::Group> cinn_group_;
   // NOTE: Use single igroup temporarily. Actually KGroup contains
   // multiple IGroups
   std::vector<std::shared_ptr<IGroup>> igroups_;
diff --git a/paddle/cinn/adt/logical.h b/paddle/cinn/adt/logical.h
index 2ab13f0214874b..24c5accc2fe605 100644
--- a/paddle/cinn/adt/logical.h
+++ b/paddle/cinn/adt/logical.h
@@ -29,6 +29,9 @@ DEFINE_ADT_BINARY(And);
 DEFINE_ADT_BINARY(Or);
 DEFINE_ADT_UNARY(Not);
 
+template<typename T0, typename T1>
+using Equal = EQ;
+
 template <typename ValueT>
 DEFINE_ADT_UNION(Compare,
                  EQ<ValueT, ValueT>,
diff --git a/paddle/cinn/adt/map_expr.h b/paddle/cinn/adt/map_expr.h
index de7ebe39acbdb6..05cfd7ef277e8f 100644
--- a/paddle/cinn/adt/map_expr.h
+++ b/paddle/cinn/adt/map_expr.h
@@ -27,14 +27,9 @@
 #include "paddle/cinn/adt/tags.h"
 #include "paddle/cinn/adt/tree.h"
 
-namespace cinn {
-namespace hlir {
-namespace framework {
-class Node;
-class NodeData;
-}  // namespace framework
-}  // namespace hlir
-}  // namespace cinn
+namespace pir {
+class Operation;
+}
 
 namespace cinn {
 namespace adt {
@@ -90,11 +85,13 @@ DEFINE_ADT_UNION(Tensor, adapter::Tensor, adapter::DynamicTensor, TempStorage);
 OVERRIDE_UNION_GET_HASH_VALUE(Tensor);
 OVERLOAD_OPERATOR_EQ_NE(Tensor, UnionEqual);
 
-// Op = const Node*
+// Op = const pir::Operation*
+//    | tReduceInit<const pir::Operation*>
+//    | tReduceAcc<const pir::Operation*>
 DEFINE_ADT_UNION(Op,
-                 const hlir::framework::Node*,
-                 tReduceInit<const hlir::framework::Node*>,
-                 tReduceAcc<const hlir::framework::Node*>);
+                 const ::pir::Operation*,
+                 tReduceInit<const ::pir::Operation*>,
+                 tReduceAcc<const ::pir::Operation*>);
 
 using Arg = Tensor;
 
diff --git a/paddle/cinn/adt/map_expr_ctx.h b/paddle/cinn/adt/map_expr_ctx.h
index 53978129228fa0..75f56155b72a4e 100644
--- a/paddle/cinn/adt/map_expr_ctx.h
+++ b/paddle/cinn/adt/map_expr_ctx.h
@@ -18,16 +18,16 @@
 #include <unordered_map>
 
 #include "paddle/cinn/adt/map_expr.h"
-#include "paddle/cinn/hlir/framework/node.h"
 #include "paddle/cinn/ir/lowered_func.h"
 #include "paddle/cinn/ir/utils/ir_copy.h"
+#include "paddle/pir/core/operation.h"
 
 namespace cinn::adt {
 
 class MapExprCtx final {
  public:
   using Node2LoweredFuncs =
-      std::unordered_map<hlir::framework::Node*, std::vector<ir::LoweredFunc>>;
+      std::unordered_map<::pir::Operation*, std::vector<ir::LoweredFunc>>;
 
   MapExprCtx(const MapExprCtx&) = delete;
   MapExprCtx(MapExprCtx&&) = delete;
@@ -37,7 +37,7 @@ class MapExprCtx final {
   const MapExpr& map_expr() const { return map_expr_; }
 
   void UpdateOpLoweredFuncKey(
-      hlir::framework::Node* node,
+      ::pir::Operation* node,
       const std::vector<ir::LoweredFunc>& lowered_funcs) {
     Node2LoweredFuncs* map = &node2lowered_funcs_;
     CHECK(map->emplace(node, ir::ir_utils::IRCopy(lowered_funcs)).second);
diff --git a/paddle/cinn/adt/naive_op_equation_context.cc b/paddle/cinn/adt/naive_op_equation_context.cc
index 21524a20c54a7c..e0a1565483a169 100644
--- a/paddle/cinn/adt/naive_op_equation_context.cc
+++ b/paddle/cinn/adt/naive_op_equation_context.cc
@@ -19,6 +19,8 @@
 #include "paddle/cinn/adt/naive_op_equation_context.h"
 #include "paddle/cinn/adt/op_arg_pos.h"
 #include "paddle/cinn/adt/print.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
+#include "paddle/cinn/utils/type_defs.h"
 
 #include "glog/logging.h"
 
@@ -55,7 +57,7 @@ std::vector<std::uint64_t> MakeTensorRanks(const List<Arg>& arg_lists) {
   return ret;
 }
 
-void GenerateOpEquationsImpl(const hlir::framework::Node* op_node,
+void GenerateOpEquationsImpl(const ::pir::Operation* op_node,
                              const OpStmt& op_stmt,
                              config::NaiveOpEquationContext* ctx) {
   const auto& [_, inputs, outputs] = op_stmt.tuple();
@@ -66,19 +68,22 @@ void GenerateOpEquationsImpl(const hlir::framework::Node* op_node,
   const auto& generate_equations =
       hlir::framework::Operator::GetAttrs<GenerateEquationFunc>(
           "generate_equations");
-  CHECK(generate_equations.Find(op_node->op()));
-  generate_equations[op_node->op()](ctx);
+  const hlir::framework::Operator* cinn_op = hlir::framework::Operator::Get(
+      hlir::framework::pir::CompatibleInfo::OpName(*op_node));
+  CHECK(generate_equations.Find(cinn_op));
+  generate_equations[cinn_op](ctx);
 }
 
-std::optional<DimExpr> GetArgStaticDimSize(
-    const List<Tensor>& tensors, std::size_t tensor_idx, std::size_t dim_idx) {
+std::optional<DimExpr> GetArgStaticDimSize(const List<Tensor>& tensors,
+                                           std::size_t tensor_idx,
+                                           std::size_t dim_idx) {
   if (!tensors->at(tensor_idx).Has<adapter::Tensor>()) {
     return std::nullopt;
   }
   if (tensor_idx >= tensors->size()) {
     return std::nullopt;
   }
-  const auto& tensor_shape =
+  const std::vector<int32_t> tensor_shape =
       tensors->at(tensor_idx).Get<adapter::Tensor>().GetShape();
   if (dim_idx >= tensor_shape.size()) {
     return std::nullopt;
@@ -86,8 +91,9 @@ std::optional<DimExpr> GetArgStaticDimSize(
   return tensor_shape.at(dim_idx);
 }
 
-std::optional<DimExpr> GetArgDimExpr(
-    const List<Tensor>& tensors, std::size_t tensor_idx, std::size_t dim_idx) {
+std::optional<DimExpr> GetArgDimExpr(const List<Tensor>& tensors,
+                                     std::size_t tensor_idx,
+                                     std::size_t dim_idx) {
   if (!tensors->at(tensor_idx).Has<adapter::DynamicTensor>()) {
     return std::nullopt;
   }
@@ -103,8 +109,9 @@ std::optional<DimExpr> GetArgDimExpr(
   return tensor_shape.at(dim_idx);
 }
 
-std::optional<DimExpr> GetArgDim(
-    const List<Tensor>& tensors, std::size_t tensor_idx, std::size_t dim_idx) {
+std::optional<DimExpr> GetArgDim(const List<Tensor>& tensors,
+                                 std::size_t tensor_idx,
+                                 std::size_t dim_idx) {
   const auto& opt_expr = GetArgDimExpr(tensors, tensor_idx, dim_idx);
   if (opt_expr.has_value()) {
     return opt_expr;
@@ -135,15 +142,14 @@ GetArgSymbolicDimT MakeGetterArgSymbolicDim(const List<Tensor>& tensors) {
   };
 }
 
-void GenerateOpEquationsImpl(
-    const tReduceAcc<const hlir::framework::Node*>& op_node,
-    const OpStmt& op_stmt,
-    config::NaiveOpEquationContext* ctx) {
+void GenerateOpEquationsImpl(const tReduceAcc<const ::pir::Operation*>& op_node,
+                             const OpStmt& op_stmt,
+                             config::NaiveOpEquationContext* ctx) {
   GenerateOpEquationsImpl(op_node.value(), op_stmt, ctx);
 }
 
 void GenerateOpEquationsImpl(
-    const tReduceInit<const hlir::framework::Node*>& op_node,
+    const tReduceInit<const ::pir::Operation*>& op_node,
     const OpStmt& op_stmt,
     config::NaiveOpEquationContext* ctx) {
   // Do nothing
@@ -160,29 +166,25 @@ void GenerateOpEquations(const OpStmt& op_stmt,
       op.variant());
 }
 
-const hlir::framework::AttrMapType* GetOpAttrImpl(
-    const hlir::framework::Node* op_node) {
-  return &op_node->attrs.attr_store;
+cinn::utils::AttributeMap GetOpAttrImpl(const ::pir::Operation* op_node) {
+  return hlir::framework::pir::CompatibleInfo::ConvertAttributes(*op_node);
 }
 
-const hlir::framework::AttrMapType* GetOpAttrImpl(
-    const tReduceInit<const hlir::framework::Node*>&) {
-  static hlir::framework::AttrMapType empty{};
-  return &empty;
+cinn::utils::AttributeMap GetOpAttrImpl(
+    const tReduceInit<const ::pir::Operation*>&) {
+  return cinn::utils::AttributeMap{};
 }
 
-const hlir::framework::AttrMapType* GetOpAttrImpl(
-    const tReduceAcc<const hlir::framework::Node*>& op_node) {
+cinn::utils::AttributeMap GetOpAttrImpl(
+    const tReduceAcc<const ::pir::Operation*>& op_node) {
   return GetOpAttrImpl(op_node.value());
 }
 
-const hlir::framework::AttrMapType* GetOpAttr(const OpStmt& op_stmt) {
+cinn::utils::AttributeMap GetOpAttr(const OpStmt& op_stmt) {
   const auto& [op_node, inputs, outputs] = op_stmt.tuple();
 
-  const auto* attr = std::visit(
-      [&](const auto& impl) { return GetOpAttrImpl(impl); }, op_node.variant());
-
-  return attr;
+  return std::visit([&](const auto& impl) { return GetOpAttrImpl(impl); },
+                    op_node.variant());
 }
 
 std::shared_ptr<config::NaiveOpEquationContext> MakeContextAndGenerateEquations(
diff --git a/paddle/cinn/adt/naive_op_equation_context.h b/paddle/cinn/adt/naive_op_equation_context.h
index 7f2b2bc8fe95ee..ce8018889eb6a9 100644
--- a/paddle/cinn/adt/naive_op_equation_context.h
+++ b/paddle/cinn/adt/naive_op_equation_context.h
@@ -48,7 +48,7 @@ class NaiveOpEquationContext final : public OpEquationContext {
       GetArgStaticDimT GetOutDim,
       GetArgSymbolicDimT GetSymbolicInDim,
       GetArgSymbolicDimT GetSymbolicOutDim,
-      const hlir::framework::AttrMapType* attr_map_type)
+      cinn::utils::AttributeMap attr_map_type)
       : in_tensors_ranks_(in_tensors_ranks),
         out_tensors_ranks_(out_tensors_ranks),
         GetInDim_(GetInDim),
@@ -227,8 +227,8 @@ class NaiveOpEquationContext final : public OpEquationContext {
   }
 
   std::optional<DimExpr> GetSymbolicDimSize(bool is_out,
-                                                    std::size_t arg_idx,
-                                                    std::size_t axis) const {
+                                            std::size_t arg_idx,
+                                            std::size_t axis) const {
     const auto* Get = (is_out ? &GetSymbolicOutDim_ : &GetSymbolicInDim_);
     const auto& opt_dim = (*Get)(arg_idx, axis);
     return opt_dim;
@@ -247,7 +247,8 @@ class NaiveOpEquationContext final : public OpEquationContext {
     }
   }
 
-  void InitInputDimExpr(std::vector<DimTuple>* vec, const std::vector<std::uint64_t>& tensors_ranks) {
+  void InitInputDimExpr(std::vector<DimTuple>* vec,
+                        const std::vector<std::uint64_t>& tensors_ranks) {
     for (std::size_t i = 0; i < tensors_ranks.size(); ++i) {
       vec->push_back(DimTuple{});
       for (std::size_t j = 0; j < tensors_ranks.at(i); ++j) {
@@ -258,7 +259,8 @@ class NaiveOpEquationContext final : public OpEquationContext {
     }
   }
 
-  void InitOutputDimExpr(std::vector<DimTuple>* vec, const std::vector<std::uint64_t>& tensors_ranks) {
+  void InitOutputDimExpr(std::vector<DimTuple>* vec,
+                         const std::vector<std::uint64_t>& tensors_ranks) {
     for (std::size_t i = 0; i < tensors_ranks.size(); ++i) {
       vec->push_back(DimTuple{});
       for (std::size_t j = 0; j < tensors_ranks.at(i); ++j) {
@@ -318,8 +320,8 @@ class NaiveOpEquationContext final : public OpEquationContext {
   }
 
   const utils::Attribute& GetAttribute(const std::string& name) const {
-    const auto& iter = attr_map_type_->find(name);
-    CHECK(iter != attr_map_type_->end())
+    const auto& iter = attr_map_type_.find(name);
+    CHECK(iter != attr_map_type_.end())
         << "Can't find Attribute with this name";
     return iter->second;
   }
@@ -331,7 +333,7 @@ class NaiveOpEquationContext final : public OpEquationContext {
   GetArgSymbolicDimT GetSymbolicInDim_;
   GetArgSymbolicDimT GetSymbolicOutDim_;
   Equations equations_;
-  const hlir::framework::AttrMapType* attr_map_type_;
+  const cinn::utils::AttributeMap attr_map_type_;
   FakeOpPlaceHolder fake_op_placeholder_;
 
   std::vector<IteratorTuple> in_iterator_tuples_;
diff --git a/paddle/cinn/adt/no_inline_translator.h b/paddle/cinn/adt/no_inline_translator.h
new file mode 100644
index 00000000000000..56c0a604fe9407
--- /dev/null
+++ b/paddle/cinn/adt/no_inline_translator.h
@@ -0,0 +1,83 @@
+// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/cinn/adt/adt.h"
+#include "paddle/cinn/adt/inline_translator_trait.h"
+#include "paddle/cinn/adt/map_expr.h"
+#include "paddle/cinn/adt/tree.h"
+
+namespace cinn::adt {
+
+template <template <typename> class MapT,
+          template <typename>
+          class OpCallT,
+          typename TensorT>
+struct NoInlineTranslator final {
+  using SrcLeaf = Store<TensorT, OpCallT<Load<TensorT>>>;
+  using OpExpr = Tree<OpCallT, Load<TensorT>>;
+  using DstLeaf = Store<TensorT, OpExpr>;
+  using SrcTree = Tree<MapT, SrcLeaf>;
+  using DstTree = Tree<MapT, DstLeaf>;
+
+  static DstTree Call(const SrcTree& src_tree) { return Translate(src_tree); }
+
+ private:
+  static DstTree Translate(const SrcTree& src_tree) {
+    return std::visit([&](const auto& impl) { return TranslateImpl(impl); },
+                      src_tree.variant());
+  }
+
+  static DstTree TranslateImpl(const MapT<SrcTree>& src_map) {
+    return DstTree{TranslateMap(src_map)};
+  }
+
+  static MapT<DstTree> TranslateMap(const MapT<SrcTree>& src_map) {
+    const List<SrcTree> src_children =
+        InlineTranslatorTrait<MapT>::GetTreeInnerNodeChildren(src_map);
+    const List<DstTree> dst_children = TranslateList(src_children);
+    return InlineTranslatorTrait<MapT>::ConvertMap(src_map, dst_children);
+  }
+
+  static List<DstTree> TranslateList(const List<SrcTree>& src_children) {
+    List<DstTree> ret{};
+    for (const auto& src_child : *src_children) {
+      ret->emplace_back(Translate(src_child));
+    }
+    return ret;
+  }
+
+  static DstTree TranslateImpl(const SrcLeaf& src_leaf) {
+    return DstTree{TranslateLeaf(src_leaf)};
+  }
+
+  // using SrcLeaf = Store<TensorT, OpCallT<Load<TensorT>>>;
+  // using DstLeaf = Store<TensorT, OpExpr>;
+  static DstLeaf TranslateLeaf(const SrcLeaf& src_leaf) {
+    const auto& [tensor, op_call] = src_leaf.tuple();
+    const List<Load<TensorT>>& src_loads =
+        InlineTranslatorTrait<OpCallT>::GetTreeInnerNodeChildren(op_call);
+    List<OpExpr> dst_loads{};
+    for (const auto& src_load : *src_loads) {
+      dst_loads->emplace_back(src_load);
+    }
+    OpCallT<OpExpr> dst_op_call =
+        InlineTranslatorTrait<OpCallT>::ConvertMap(op_call, dst_loads);
+    OpExpr dst_op_call_tree = dst_op_call;
+    return DstLeaf{tensor, dst_op_call_tree};
+  }
+};
+
+}  // namespace cinn::adt
diff --git a/paddle/cinn/adt/print_equations.cc b/paddle/cinn/adt/print_equations.cc
index 859957b6d755d3..2e3c5ca72bf4bd 100644
--- a/paddle/cinn/adt/print_equations.cc
+++ b/paddle/cinn/adt/print_equations.cc
@@ -13,25 +13,29 @@
 // limitations under the License.
 
 #include "paddle/cinn/adt/print_equations.h"
-#include "paddle/cinn/adt/print_dim_expr.h"
 
 #include <sstream>
 #include <string>
 
 #include "paddle/cinn/adt/equation_function.h"
+#include "paddle/cinn/adt/print_dim_expr.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
+#include "paddle/pir/core/operation.h"
 
 namespace cinn::adt {
 
 namespace {
 
-std::string OpImpl(const hlir::framework::Node* op) { return op->op()->name; }
+std::string OpImpl(const ::pir::Operation* op) {
+  return hlir::framework::pir::CompatibleInfo::OpName(*op);
+}
 
-std::string OpImpl(const tReduceInit<const hlir::framework::Node*>& op) {
-  return op.value()->op()->name + "_init";
+std::string OpImpl(const tReduceInit<const ::pir::Operation*>& op) {
+  return OpImpl(op.value()) + "_init";
 }
 
-std::string OpImpl(const tReduceAcc<const hlir::framework::Node*>& op) {
-  return op.value()->op()->name + "_acc";
+std::string OpImpl(const tReduceAcc<const ::pir::Operation*>& op) {
+  return OpImpl(op.value()) + "_acc";
 }
 
 }  // namespace
@@ -185,8 +189,8 @@ struct ToTxtStringStruct {
   }
 
   std::string operator()(
-      const IndexUnDot<List<DimExpr>, tOut<List<Iterator>>, tIn<Index>>&
-          undot) const {
+      const IndexUnDot<List<DimExpr>, tOut<List<Iterator>>, tIn<Index>>& undot)
+      const {
     std::string ret;
     const auto& [dim_list, out_iterator_list_tag, in_index_tag] = undot.tuple();
     const List<Iterator>& out_iterator_list = out_iterator_list_tag.value();
diff --git a/paddle/cinn/adt/print_map_expr.cc b/paddle/cinn/adt/print_map_expr.cc
index 1e8d82478ad6e4..e25317faf8ba1d 100644
--- a/paddle/cinn/adt/print_map_expr.cc
+++ b/paddle/cinn/adt/print_map_expr.cc
@@ -21,6 +21,7 @@
 #include "paddle/cinn/adt/print_schedule_mesh.h"
 #include "paddle/cinn/adt/print_value.h"
 #include "paddle/cinn/adt/schedule_descriptor.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/runtime/flags.h"
 
 PD_DECLARE_bool(cinn_map_expr_enable_index_detail);
@@ -58,14 +59,14 @@ namespace {
 std::string ToTxtStringImpl(const adapter::Tensor& tensor) {
   std::string ret;
   ret += "t_";
-  ret += tensor.node_data->id();
+  ret += hlir::framework::pir::CompatibleInfo::ValueName(tensor.node_data);
   return ret;
 }
 
 std::string ToTxtStringImpl(const adapter::DynamicTensor& tensor) {
   std::string ret;
   ret += "t_";
-  ret += tensor.node_data->id();
+  ret += hlir::framework::pir::CompatibleInfo::ValueName(tensor.node_data);
   return ret;
 }
 
@@ -109,18 +110,16 @@ std::string ArgsToTxtString(const List<Arg>& out_args,
   return ArgsToTxtString(out_args, in_args, GetEmptyStr, GetEmptyStr);
 }
 
-std::string ToTxtStringOpImpl(const hlir::framework::Node* op) {
-  return op->op()->name;
+std::string ToTxtStringOpImpl(const ::pir::Operation* op) {
+  return hlir::framework::pir::CompatibleInfo::OpName(*op);
 }
 
-std::string ToTxtStringOpImpl(
-    const tReduceInit<const hlir::framework::Node*>& op) {
-  return op.value()->op()->name + "_init";
+std::string ToTxtStringOpImpl(const tReduceInit<const ::pir::Operation*>& op) {
+  return ToTxtStringOpImpl(op.value()) + "_init";
 }
 
-std::string ToTxtStringOpImpl(
-    const tReduceAcc<const hlir::framework::Node*>& op) {
-  return op.value()->op()->name + "_acc";
+std::string ToTxtStringOpImpl(const tReduceAcc<const ::pir::Operation*>& op) {
+  return ToTxtStringOpImpl(op.value()) + "_acc";
 }
 
 std::string ToTxtString(const Op& op) {
diff --git a/paddle/cinn/adt/symbolic_dim_infer_ctx.h b/paddle/cinn/adt/symbolic_dim_infer_ctx.h
deleted file mode 100644
index df704050390e2c..00000000000000
--- a/paddle/cinn/adt/symbolic_dim_infer_ctx.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include "paddle/cinn/adt/graph_symbolic_dim_infer_ctx.h"
-#include "paddle/cinn/adt/dim_expr.h"
-#include "paddle/cinn/hlir/framework/node.h"
-
-namespace cinn::adt::config {
-
-class SymbolicDimInferCtx {
- public:
-  SymbolicDimInferCtx(const SymbolicDimInferCtx&) = delete;
-  SymbolicDimInferCtx(SymbolicDimInferCtx&&) = delete;
-
-  SymbolicDimInferCtx(const hlir::framework::Node* node,
-                      GraphSymbolicDimInferCtx* graph_ctx)
-      : node_(node), graph_ctx_(graph_ctx) {}
-
-  const std::vector<std::uint64_t>& GetInTensorsRanks() const {
-    return graph_ctx_->GetInTensorsRanks(node_);
-  }
-
-  std::uint64_t GetNumOutTensors() const {
-    return graph_ctx_->GetNumOutTensors(node_);
-  }
-
-  const DimExpr& GetInputDimExpr(std::size_t arg_idx,
-                                         std::size_t dim_idx) const {
-    return graph_ctx_->GetInputDimExpr(node_, arg_idx, dim_idx);
-  }
-
-  void SetOutputDimExpr(std::size_t arg_idx,
-                        std::size_t dim_idx,
-                        const DimExpr& value) {
-    return graph_ctx_->SetOutputDimExpr(node_, arg_idx, dim_idx, value);
-  }
-
-  const hlir::framework::AttrMapType& GetAttributeMap() const {
-    return graph_ctx_->GetAttributeMap(node_);
-  }
-
-  template <typename T>
-  const T& Attr(const std::string& name) const {
-    return absl::get<T>(GetAttributeMap().at(name));
-  }
-
- private:
-  const hlir::framework::Node* node_;
-  GraphSymbolicDimInferCtx* graph_ctx_;
-};
-
-}  // namespace cinn::adt::config
diff --git a/paddle/cinn/adt/symbolic_dim_infer_util.cc b/paddle/cinn/adt/symbolic_dim_infer_util.cc
deleted file mode 100644
index 6423fab2a2acf6..00000000000000
--- a/paddle/cinn/adt/symbolic_dim_infer_util.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "paddle/cinn/adt/symbolic_dim_infer_util.h"
-
-#include "paddle/cinn/adt/symbolic_dim_infer_ctx.h"
-#include "paddle/cinn/common/graph_utils.h"
-#include "paddle/cinn/hlir/framework/graph.h"
-#include "paddle/cinn/hlir/framework/node.h"
-
-namespace cinn::adt {
-
-std::unique_ptr<config::GraphSymbolicDimInferCtx> InferSymbolicDim(
-    const hlir::framework::Graph* graph) {
-  using InferSymbolicDimFunc =
-      std::function<void(adt::config::SymbolicDimInferCtx * ctx)>;
-  auto infer_ctx_ptr =
-      std::make_unique<config::GraphSymbolicDimInferCtx>(graph);
-
-  std::vector<common::GraphNode*> topo_nodes =
-      std::get<0>(graph->topological_order());
-  for (const common::GraphNode* graph_node : topo_nodes) {
-    const hlir::framework::Node* op_node =
-        graph_node->safe_as<hlir::framework::Node>();
-    // if node is NodeData or not op, continue.
-    if (!op_node || op_node->op() == nullptr) {
-      continue;
-    }
-
-    VLOG(1) << "op_name : " << op_node->op()->name;
-    const auto& infer_symbolic_dim =
-        hlir::framework::Operator::GetAttrs<InferSymbolicDimFunc>(
-            "infer_symbolic_dim");
-    CHECK(infer_symbolic_dim.Find(op_node->op()));
-
-    adt::config::SymbolicDimInferCtx ctx{op_node, infer_ctx_ptr.get()};
-    infer_symbolic_dim[op_node->op()](&ctx);
-  }
-  return infer_ctx_ptr;
-}
-
-}  // namespace cinn::adt
diff --git a/paddle/cinn/adt/symbolic_dim_infer_util.h b/paddle/cinn/adt/symbolic_dim_infer_util.h
deleted file mode 100644
index 30593b2fa06b35..00000000000000
--- a/paddle/cinn/adt/symbolic_dim_infer_util.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#pragma once
-
-#include <memory>
-
-namespace cinn::hlir::framework {
-class Graph;
-}
-
-namespace cinn::adt {
-
-namespace config {
-class GraphSymbolicDimInferCtx;
-}
-
-std::unique_ptr<config::GraphSymbolicDimInferCtx> InferSymbolicDim(
-    const hlir::framework::Graph* graph);
-
-}  // namespace cinn::adt
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_lowering_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_lowering_pass.cc
index ba5c946ff31643..9c959c3878e092 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_lowering_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_lowering_pass.cc
@@ -18,6 +18,7 @@
 
 #include <unordered_map>
 
+#include "paddle/cinn/adt/generate_map_expr.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/op_attribute.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/op_dialect.h"
@@ -25,9 +26,12 @@
 #include "paddle/cinn/hlir/dialect/runtime/ir/jit_kernel_op.h"
 #include "paddle/cinn/hlir/dialect/runtime/ir/runtime_dialect.h"
 #include "paddle/cinn/hlir/framework/pir_compiler.h"
+#include "paddle/cinn/runtime/flags.h"
 #include "paddle/fluid/pir/dialect/kernel/ir/kernel_dialect.h"
 #include "paddle/pir/dialect/control_flow/ir/cf_op.h"
 
+PD_DECLARE_bool(cinn_enable_map_expr);
+
 namespace cinn {
 namespace dialect {
 namespace ir {
@@ -147,8 +151,12 @@ std::unique_ptr<pir::Program> CINNGroupLoweringPass(::pir::Program* program) {
         auto ir_compiler = std::make_shared<cinn::hlir::framework::PirCompiler>(
             *program, target, scope);
         hlir::framework::PirCompilerManager::Instance().insert(ir_compiler);
+        adt::TryGenerateMapExprFromGroup(group);
         auto group1 =
             std::make_shared<cinn::hlir::framework::pir::Group>(group->ops);
+        if (FLAGS_cinn_enable_map_expr) {
+          group1->set_map_expr_ctx(group->mut_map_expr_ctx());
+        }
         auto fn_ptr_res = ir_compiler->BuildCUDAJITInfo({group1});
         std::unordered_map<std::string, ::pir::Attribute> op_attrs{
             {cinn::dialect::JitKernelOp::kAttrName,
diff --git a/paddle/cinn/hlir/framework/graph.h b/paddle/cinn/hlir/framework/graph.h
index 7b360b1ddc2b04..e1d63d9f06f5a8 100644
--- a/paddle/cinn/hlir/framework/graph.h
+++ b/paddle/cinn/hlir/framework/graph.h
@@ -28,15 +28,6 @@
 
 namespace cinn {
 
-namespace adt {
-class MapExprCtx;
-
-namespace config {
-class GraphSymbolicDimInferCtx;
-}
-
-}  // namespace adt
-
 namespace hlir {
 namespace framework {
 
@@ -67,20 +58,6 @@ class Graph : public cinn::common::Graph {
   /** \brief attributes of a graph */
   absl::flat_hash_map<std::string, std::shared_ptr<absl::any>> attrs;
 
-  void set_graph_ctx(
-      std::unique_ptr<adt::config::GraphSymbolicDimInferCtx>&& graph_ctx) {
-    CHECK_EQ(this, graph_ctx->graph());
-    graph_ctx_ = std::move(graph_ctx);
-  }
-
-  const adt::config::GraphSymbolicDimInferCtx* graph_ctx() const {
-    return graph_ctx_.get();
-  }
-
-  adt::config::GraphSymbolicDimInferCtx* mut_graph_ctx() {
-    return graph_ctx_.get();
-  }
-
   std::vector<std::vector<Node*>> groups;
   struct Group {
     Group() = default;
@@ -207,17 +184,6 @@ class Graph : public cinn::common::Graph {
 
     hlir::framework::OpPatternKind kind() const { return op_pattern_kind; }
 
-    adt::MapExprCtx* mut_map_expr_ctx() { return map_expr_ctx_.get(); }
-
-    const adt::MapExprCtx& map_expr_ctx() const {
-      return *CHECK_NOTNULL(map_expr_ctx_);
-    }
-
-    void set_map_expr_ctx(
-        const std::shared_ptr<adt::MapExprCtx>& map_expr_ctx) {
-      map_expr_ctx_ = map_expr_ctx;
-    }
-
    private:
     // input groups
     std::unordered_set<std::shared_ptr<Group>,
@@ -229,7 +195,6 @@ class Graph : public cinn::common::Graph {
                        SharedGroupHasher,
                        SharedGroupComparator>
         consumer_groups_;
-    std::shared_ptr<adt::MapExprCtx> map_expr_ctx_;
   };
   std::vector<std::shared_ptr<Group>> fusion_groups;
 
@@ -337,8 +302,6 @@ class Graph : public cinn::common::Graph {
 
   std::vector<std::vector<Node*>> FusionGroupsToGroups();
 
-  std::unique_ptr<adt::config::GraphSymbolicDimInferCtx> graph_ctx_;
-
   CINN_DISALLOW_COPY_AND_ASSIGN(Graph);
 };
 
diff --git a/paddle/cinn/hlir/framework/op_lowering_impl.cc b/paddle/cinn/hlir/framework/op_lowering_impl.cc
index d321b94f212a16..e041633b0748bf 100644
--- a/paddle/cinn/hlir/framework/op_lowering_impl.cc
+++ b/paddle/cinn/hlir/framework/op_lowering_impl.cc
@@ -14,21 +14,17 @@
 
 #include "paddle/cinn/hlir/framework/op_lowering_impl.h"
 
-#include "paddle/cinn/adt/map_expr_ctx.h"
 #include "paddle/cinn/ast_gen_ius/tensor_group.h"
 #include "paddle/cinn/hlir/framework/compile_error.h"
 #include "paddle/cinn/hlir/framework/graph_compiler_util.h"
 #include "paddle/cinn/hlir/framework/op_lowering_util.h"
 #include "paddle/cinn/hlir/op/external_api_registry.h"
-#include "paddle/cinn/hlir/pe/map_expr_to_ir.h"
 #include "paddle/cinn/ir/group_schedule/st_shape_group_scheduler.h"
 #include "paddle/cinn/ir/schedule/ir_schedule.h"
 #include "paddle/cinn/optim/transform_gpu_forloop.h"
 #include "paddle/cinn/runtime/flags.h"
 
 PD_DECLARE_bool(cinn_use_cuda_vectorize);
-PD_DECLARE_bool(cinn_enable_map_expr);
-PD_DECLARE_bool(cinn_map_expr_enable_schedule);
 PD_DECLARE_bool(cinn_new_group_scheduler);
 
 namespace cinn {
@@ -103,49 +99,6 @@ bool OpLowererImpl::NonFusibleScheduleDetermineFunction(Node* node) {
   return true;
 }
 
-/* Most of below codes copies from `PostProcess` function */
-std::vector<ir::LoweredFunc> OpLowererImpl::LowerMapExpr(
-    const GroupPtr& group,
-    const std::unordered_map<std::string, ir::Tensor>& tensor_map,
-    bool do_op_schedule,
-    bool apply_group_schedule,
-    bool apply_pass,
-    std::vector<ir::Tensor>* group_func_arg_tensors) {
-  if (!FLAGS_cinn_map_expr_enable_schedule) {
-    do_op_schedule = false;
-    apply_group_schedule = false;
-    apply_pass = true;
-  }
-  VLOG(1) << "FLAGS_cinn_map_expr_enable_schedule = "
-          << FLAGS_cinn_map_expr_enable_schedule;
-  VLOG(1) << "do_op_schedule = " << do_op_schedule;
-  VLOG(1) << "apply_group_schedule = " << apply_group_schedule;
-  VLOG(1) << "apply_pass = " << apply_pass;
-
-  ir::Expr func_body = adt::MapExprToIr(group->map_expr_ctx(), target_);
-
-  // 2.Do group schedule.
-  ir::ModuleExpr mod_expr({func_body});
-  ir::IRSchedule ir_sch(mod_expr);
-  ir_sch.MergeExprs();
-  VLOG(3) << "After lower, ir is: \n" << ir_sch.GetModule().GetExprs().at(0);
-  if (apply_group_schedule) {
-    DoGroupSchedule(ir_sch, group, tensor_map);
-    VLOG(3) << "After group schedule, ir is: \n"
-            << ir_sch.GetModule().GetExprs().at(0);
-  }
-
-  // 3.Do post-processing,
-  // including preparing function args and temporary variables,
-  // applying low-level optimization passes, etc.
-  return PostProcess(group,
-                     tensor_map,
-                     do_op_schedule,
-                     apply_pass,
-                     &ir_sch,
-                     group_func_arg_tensors);
-}
-
 std::vector<ir::LoweredFunc> OpLowererImpl::LowerGroup(
     const GroupPtr& group,
     bool apply_op_schedule,
@@ -169,15 +122,6 @@ std::vector<ir::LoweredFunc> OpLowererImpl::LowerGroup(
                                                &group_func_arg_tensors,
                                                &tensor_map);
 
-  if (FLAGS_cinn_enable_map_expr) {
-    return LowerMapExpr(group,
-                        tensor_map,
-                        /*do_op_schedule=*/do_op_schedule,
-                        /*apply_group_schedule=*/apply_group_schedule,
-                        /*apply_pass=*/apply_pass,
-                        &group_func_arg_tensors);
-  }
-
   // 2.Do group schedule.
   ir::ModuleExpr mod_expr(func_bodies);
   ir::IRSchedule ir_sch(mod_expr);
@@ -480,9 +424,6 @@ std::vector<ir::LoweredFunc> OpLowererImpl::DoOpLower(
   for (auto fun : funcs) {
     VLOG(4) << fun;
   }
-  if (FLAGS_cinn_enable_map_expr) {
-    group->mut_map_expr_ctx()->UpdateOpLoweredFuncKey(node, funcs);
-  }
 
   op_func_arg_tensors->clear();
   for (int idx = 0; idx < pack.size() - 1; ++idx) {
diff --git a/paddle/cinn/hlir/framework/op_lowering_impl.h b/paddle/cinn/hlir/framework/op_lowering_impl.h
index 3c458b9ecc11eb..0ff9cce38bf51c 100644
--- a/paddle/cinn/hlir/framework/op_lowering_impl.h
+++ b/paddle/cinn/hlir/framework/op_lowering_impl.h
@@ -102,24 +102,6 @@ class OpLowererImpl : public OpLowererImplBase<GroupPtr> {
       ir::IRSchedule* ir_sch,
       std::vector<ir::Tensor>* group_func_arg_tensors);
 
-  /**
-   * @brief Generate MapExpr and Lower it to std::vector<ir::LoweredFunc>
-   * @param group The group to be lowered.
-   * @param tensor_map All tensors used for calculating the group.
-   * @param done_op_schedule Mark whether the Op level schedule has been
-   * applied.
-   * @param apply_group_schedule Whether to schedule at group level.
-   * @param group_func_arg_tensors Tensors used as the group function arguments.
-   * @return The lowered funcs after the post processing.
-   */
-  std::vector<ir::LoweredFunc> LowerMapExpr(
-      const GroupPtr& group,
-      const std::unordered_map<std::string, ir::Tensor>& tensor_map,
-      bool done_op_schedule,
-      bool apply_group_schedule,
-      bool apply_pass,
-      std::vector<ir::Tensor>* group_func_arg_tensors);
-
   /**
    * @brief Lower an Op set to CINN IR.
    * Compute, Lower and optional Schedule will be performed one by one
diff --git a/paddle/cinn/hlir/framework/pir/group.h b/paddle/cinn/hlir/framework/pir/group.h
index 7b0913525c2545..9990c9499dc548 100644
--- a/paddle/cinn/hlir/framework/pir/group.h
+++ b/paddle/cinn/hlir/framework/pir/group.h
@@ -16,11 +16,17 @@
 #include <string>
 #include <vector>
 
+#include "paddle/cinn/adt/graph_symbolic_dim_infer_ctx.h"
 #include "paddle/cinn/hlir/framework/op.h"
 #include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/pir/core/operation.h"
 
 namespace cinn {
+
+namespace adt {
+class MapExprCtx;
+}  // namespace adt
+
 namespace hlir {
 namespace framework {
 namespace pir {
@@ -30,6 +36,8 @@ using framework::OpPatternKind;
 struct Group {
  public:
   Group() = default;
+  Group(const Group&) = delete;
+  Group(Group&&) = delete;
   explicit Group(const std::vector<::pir::Operation*>& group_ops)
       : ops(group_ops) {}
 
@@ -81,7 +89,7 @@ struct Group {
     }
   };
 
-  std::vector<::pir::Operation*> CollectOps() {
+  std::vector<::pir::Operation*> CollectOps() const {
     if (fused_sub_groups.size()) {
       std::vector<::pir::Operation*> tmp_ops;
       for (auto& group : fused_sub_groups) {
@@ -107,7 +115,7 @@ struct Group {
     }
   }
 
-  std::unordered_set<::pir::Operation*> OpSet() {
+  std::unordered_set<::pir::Operation*> OpSet() const {
     std::unordered_set<::pir::Operation*> op_set;
     for (auto op : CollectOps()) {
       op_set.insert(op);
@@ -115,7 +123,7 @@ struct Group {
     return op_set;
   }
 
-  std::unordered_set<::pir::Value> GetInputOpValues() {
+  std::unordered_set<::pir::Value> GetInputOpValues() const {
     std::unordered_set<::pir::Value> group_inputs;
     auto ops_set = this->OpSet();
     // count all op's input Value
@@ -144,7 +152,7 @@ struct Group {
 
     return group_inputs;
   }
-  std::unordered_set<::pir::Value> GetOutputOpValues() {
+  std::unordered_set<::pir::Value> GetOutputOpValues() const {
     std::unordered_set<::pir::Value> group_outputs;
 
     for (auto op : this->output_ops) {
@@ -161,6 +169,35 @@ struct Group {
 
   std::string GetFuncName() { return "fn_" + group_id + unique_id; }
 
+  std::shared_ptr<adt::MapExprCtx> mut_map_expr_ctx() {
+    CHECK_NOTNULL(map_expr_ctx_);
+    return map_expr_ctx_;
+  }
+
+  const adt::MapExprCtx& map_expr_ctx() const {
+    return *CHECK_NOTNULL(map_expr_ctx_);
+  }
+
+  void set_map_expr_ctx(const std::shared_ptr<adt::MapExprCtx>& map_expr_ctx) {
+    map_expr_ctx_ = map_expr_ctx;
+  }
+
+  void set_graph_symbolic_dim_infer_ctx(
+      std::unique_ptr<adt::config::GraphSymbolicDimInferCtx>&&
+          graph_symbolic_dim_infer_ctx) {
+    CHECK_EQ(this, graph_symbolic_dim_infer_ctx->group());
+    graph_symbolic_dim_infer_ctx_ = std::move(graph_symbolic_dim_infer_ctx);
+  }
+
+  const adt::config::GraphSymbolicDimInferCtx* graph_symbolic_dim_infer_ctx()
+      const {
+    return graph_symbolic_dim_infer_ctx_.get();
+  }
+
+  adt::config::GraphSymbolicDimInferCtx* mut_graph_symbolic_dim_infer_ctx() {
+    return graph_symbolic_dim_infer_ctx_.get();
+  }
+
  public:
   const std::unordered_set<std::shared_ptr<Group>,
                            SharedGroupHasher,
@@ -211,6 +248,9 @@ struct Group {
                      SharedGroupHasher,
                      SharedGroupComparator>
       consumer_groups_;
+  std::shared_ptr<adt::MapExprCtx> map_expr_ctx_;
+  std::unique_ptr<adt::config::GraphSymbolicDimInferCtx>
+      graph_symbolic_dim_infer_ctx_;
 };
 
 }  // namespace pir
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
index 40cd6444a4fed9..fd7baa18a557f8 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
@@ -16,19 +16,23 @@
 
 #include <string>
 
+#include "paddle/cinn/adt/map_expr_ctx.h"
 #include "paddle/cinn/ast_gen_ius/tensor_group.h"
+#include "paddle/cinn/hlir/framework/compile_error.h"
 #include "paddle/cinn/hlir/framework/pir/op_lowering_util.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/hlir/op/external_api_registry.h"
+#include "paddle/cinn/hlir/pe/map_expr_to_ir.h"
+#include "paddle/cinn/ir/group_schedule/st_shape_group_scheduler.h"
 #include "paddle/cinn/ir/schedule/ir_schedule.h"
-#include "paddle/cinn/optim/transform_gpu_forloop.h"
-
-#include "paddle/cinn/hlir/framework/compile_error.h"
-#include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/lang/placeholder.h"
+#include "paddle/cinn/optim/transform_gpu_forloop.h"
 #include "paddle/fluid/pir/dialect/operator/ir/op_type.h"
 #include "paddle/phi/core/ddim.h"
 
 PD_DECLARE_bool(cinn_use_cuda_vectorize);
+PD_DECLARE_bool(cinn_enable_map_expr);
+PD_DECLARE_bool(cinn_enable_map_expr_schedule);
 
 namespace cinn {
 namespace hlir {
@@ -182,11 +186,58 @@ bool OpLowererImpl::NonFusibleScheduleDetermineFunction(::pir::Operation* op) {
   return true;
 }
 
+/* Most of below codes copies from `PostProcess` function */
+std::vector<ir::LoweredFunc> OpLowererImpl::LowerMapExpr(
+    const GroupPtr& group,
+    const std::unordered_map<::pir::Value, ir::Tensor>& tensor_map,
+    const std::unordered_map<std::string, ir::Tensor>& tmp_tensor_info,
+    bool do_op_schedule,
+    bool apply_group_schedule,
+    std::vector<ir::Tensor>* group_func_arg_tensors) {
+  VLOG(1) << "do_op_schedule = " << do_op_schedule;
+  VLOG(1) << "apply_group_schedule = " << apply_group_schedule;
+
+  VLOG(1) << "Begin MapExprToIr";
+  ir::Expr func_body = adt::MapExprToIr(group->map_expr_ctx(), target_);
+
+  // 2.Do group schedule.
+  ir::ModuleExpr mod_expr({func_body});
+  ir::IRSchedule ir_sch(mod_expr);
+  ir_sch.MergeExprs();
+  VLOG(3) << "After lower, ir is: \n" << ir_sch.GetModule().GetExprs().at(0);
+  if (apply_group_schedule) {
+    std::unordered_set<std::string> output_tensor_names;
+    std::transform(
+        group->output_ops.begin(),
+        group->output_ops.end(),
+        std::inserter(output_tensor_names, output_tensor_names.begin()),
+        [](::pir::Operation* node) {
+          ::pir::Value node_data = node->result(0);
+          return hlir::framework::pir::CompatibleInfo::ValueName(node_data);
+        });
+    ir::StaticShapeGroupScheduler group_scheduler(
+        &ir_sch, output_tensor_names, target_);
+    group_scheduler.MapExprSchedule();
+    VLOG(3) << "After group schedule, ir is: \n"
+            << ir_sch.GetModule().GetExprs().at(0);
+  }
+
+  // 3.Do post-processing,
+  // including preparing function args and temporary variables,
+  // applying low-level optimization passes, etc.
+  return PostProcess(
+      group, tensor_map, do_op_schedule, &ir_sch, group_func_arg_tensors);
+}
+
 std::vector<ir::LoweredFunc> OpLowererImpl::LowerGroup(
     const GroupPtr& group,
     bool apply_op_schedule,
     bool apply_group_schedule,
     ScheduleDetermineFunction schedule_determine_func) {
+  if (FLAGS_cinn_enable_map_expr && FLAGS_cinn_enable_map_expr_schedule) {
+    apply_op_schedule = false;
+    apply_group_schedule = false;
+  }
   // 1.Do compute, lower and schedule for each op.
   auto& ops = group->ops;
   if (ops.size() == 1 && ops[0]->name() == "custom_call") {
@@ -198,12 +249,21 @@ std::vector<ir::LoweredFunc> OpLowererImpl::LowerGroup(
   // XX_0, XX_1, so we log them in tmp_tensor_info;
   std::unordered_map<std::string, ir::Tensor> tmp_tensor_info;
   bool do_op_schedule = apply_group_schedule || apply_op_schedule;
-  std::vector<ir::Expr> func_bodies = LowerOps(ops,
+  std::vector<ir::Expr> func_bodies = LowerOps(group,
+                                               ops,
                                                do_op_schedule,
                                                schedule_determine_func,
                                                &group_func_arg_tensors,
                                                &tensor_map,
                                                &tmp_tensor_info);
+  if (FLAGS_cinn_enable_map_expr) {
+    return LowerMapExpr(group,
+                        tensor_map,
+                        tmp_tensor_info,
+                        /*do_op_schedule=*/do_op_schedule,
+                        /*apply_group_schedule=*/apply_group_schedule,
+                        &group_func_arg_tensors);
+  }
 
   // 2.Do group schedule.
   ir::ModuleExpr mod_expr(func_bodies);
@@ -348,6 +408,7 @@ std::vector<ir::LoweredFunc> OpLowererImpl::PostProcess(
 }
 
 std::vector<ir::Expr> OpLowererImpl::LowerOps(
+    const GroupPtr& group,
     const std::vector<::pir::Operation*>& ops,
     bool apply_op_schedule,
     ScheduleDetermineFunction schedule_determine_func,
@@ -374,7 +435,7 @@ std::vector<ir::Expr> OpLowererImpl::LowerOps(
         node_attrs, op_func_arg_tensors, out_types, out_shapes, this->target_));
     // 2.Perform the lower process of Op
     std::vector<ir::LoweredFunc> funcs = DoOpLower(
-        op_impl, op, tensor_map, tmp_tensor_info, &op_func_arg_tensors);
+        group, op_impl, op, tensor_map, tmp_tensor_info, &op_func_arg_tensors);
 
     if (apply_op_schedule && (this->*schedule_determine_func)(op)) {
       // 3.Perform the schedule of Op
@@ -393,6 +454,7 @@ std::vector<ir::Expr> OpLowererImpl::LowerOps(
 }
 
 std::vector<ir::LoweredFunc> OpLowererImpl::DoOpLower(
+    const GroupPtr& group,
     std::shared_ptr<hlir::framework::OpImpl> op_impl,
     ::pir::Operation* op,
     std::unordered_map<::pir::Value, ir::Tensor>* tensor_map,
@@ -460,6 +522,9 @@ std::vector<ir::LoweredFunc> OpLowererImpl::DoOpLower(
       VLOG(4) << fun;
     }
   }
+  if (FLAGS_cinn_enable_map_expr) {
+    group->mut_map_expr_ctx()->UpdateOpLoweredFuncKey(op, funcs);
+  }
 
   op_func_arg_tensors->clear();
   for (int idx = 0; idx < pack.size() - 1; ++idx) {
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_impl.h b/paddle/cinn/hlir/framework/pir/op_lowering_impl.h
index 156e7a399ced51..dd31233591b3d5 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_impl.h
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_impl.h
@@ -102,10 +102,29 @@ class OpLowererImpl : public OpLowererImplBase<GroupPtr> {
       ir::IRSchedule* ir_sch,
       std::vector<ir::Tensor>* group_func_arg_tensors);
 
+  /**
+   * @brief Generate MapExpr and Lower it to std::vector<ir::LoweredFunc>
+   * @param group The group to be lowered.
+   * @param tensor_map All tensors used for calculating the group.
+   * @param done_op_schedule Mark whether the Op level schedule has been
+   * applied.
+   * @param apply_group_schedule Whether to schedule at group level.
+   * @param group_func_arg_tensors Tensors used as the group function arguments.
+   * @return The lowered funcs after the post processing.
+   */
+  std::vector<ir::LoweredFunc> LowerMapExpr(
+      const GroupPtr& group,
+      const std::unordered_map<::pir::Value, ir::Tensor>& tensor_map,
+      const std::unordered_map<std::string, ir::Tensor>& tmp_tensor_info,
+      bool done_op_schedule,
+      bool apply_group_schedule,
+      std::vector<ir::Tensor>* group_func_arg_tensors);
+
   /**
    * @brief Lower an Op set to CINN IR.
    * Compute, Lower and optional Schedule will be performed one by one
    * for each Op.
+   * @param group The group to be lowered.
    * @param ops The Op to be lowered.
    * @param apply_op_schedule Whether to schedule at Op level.
    * @param schedule_determine_func Function used to determine which Ops to
@@ -115,6 +134,7 @@ class OpLowererImpl : public OpLowererImplBase<GroupPtr> {
    * @return The lowered func bodies of Op set.
    */
   std::vector<ir::Expr> LowerOps(
+      const GroupPtr& group,
       const std::vector<::pir::Operation*>& ops,
       bool apply_op_schedule,
       ScheduleDetermineFunction schedule_determine_func,
@@ -125,6 +145,7 @@ class OpLowererImpl : public OpLowererImplBase<GroupPtr> {
   /**
    * @brief Lower an Op to CINN IR. The Compute and Lower processes will be
    * called sequentially.
+   * @param group The group to be lowered.
    * @param op_impl The Op implementation defining Compute and Schedule.
    * @param op The Op to be lowered.
    * @param tensor_map All tensors used for calculating the group.
@@ -132,6 +153,7 @@ class OpLowererImpl : public OpLowererImplBase<GroupPtr> {
    * @return The lowered func of the Op.
    */
   std::vector<ir::LoweredFunc> DoOpLower(
+      const GroupPtr& group,
       std::shared_ptr<hlir::framework::OpImpl> op_impl,
       ::pir::Operation* op,
       std::unordered_map<::pir::Value, ir::Tensor>* tensor_map,
diff --git a/paddle/cinn/hlir/op/broadcast.cc b/paddle/cinn/hlir/op/broadcast.cc
index cdf61186a85e41..2ce71d5198cf97 100644
--- a/paddle/cinn/hlir/op/broadcast.cc
+++ b/paddle/cinn/hlir/op/broadcast.cc
@@ -17,7 +17,6 @@
 #include <iostream>
 
 #include "paddle/cinn/adt/op_equation_context.h"
-#include "paddle/cinn/adt/symbolic_dim_infer_ctx.h"
 #include "paddle/cinn/hlir/framework/node.h"
 #include "paddle/cinn/hlir/framework/op.h"
 #include "paddle/cinn/hlir/framework/op_strategy.h"
@@ -152,34 +151,6 @@ void GenerateEquationsForBroadcast(cinn::adt::config::OpEquationContext *ctx) {
   }
 }
 
-void InferSymbolicDimForBroadcast(cinn::adt::config::SymbolicDimInferCtx *ctx) {
-  VLOG(1) << "Use InferSymbolicDimForBroadcast";
-  CHECK_EQ(ctx->GetInTensorsRanks().size(), 2)
-      << "The inputs is " << ctx->GetInTensorsRanks().size()
-      << "! Please check again.";
-  CHECK_EQ(ctx->GetNumOutTensors(), 1)
-      << "The output is " << ctx->GetNumOutTensors() << "! Please check again.";
-  std::uint64_t in_tensor0_ranks = ctx->GetInTensorsRanks().at(0);
-  std::uint64_t in_tensor1_ranks = ctx->GetInTensorsRanks().at(1);
-  std::uint64_t out_tensor_ranks = std::max(in_tensor0_ranks, in_tensor1_ranks);
-  int offset0 = out_tensor_ranks - in_tensor0_ranks;
-  int offset1 = out_tensor_ranks - in_tensor1_ranks;
-  CHECK(offset0 == 0 || offset1 == 0);
-  CHECK(in_tensor0_ranks == out_tensor_ranks ||
-        in_tensor1_ranks == out_tensor_ranks);
-  int offset = std::max(offset0, offset1);
-  int equal_tensor_index = offset0 > 0 ? 1 : 0;
-  for (std::size_t i = 0; i < offset; ++i) {
-    ctx->SetOutputDimExpr(0, i, ctx->GetInputDimExpr(equal_tensor_index, i));
-  }
-  for (std::size_t i = offset; i < out_tensor_ranks; ++i) {
-    const auto &broadcasted_dim =
-        MakeBroadcastedDim(ctx->GetInputDimExpr(0, i - offset0),
-                           ctx->GetInputDimExpr(1, i - offset1));
-    ctx->SetOutputDimExpr(0, i, broadcasted_dim);
-  }
-}
-
 std::vector<Type> InferDtypeForBroadcastCmp(
     const std::vector<Type> &inputs_type, const framework::AttrMapType &attrs) {
   CHECK(!inputs_type.empty())
@@ -488,8 +459,6 @@ CINN_REGISTER_HELPER(broadcast_ops) {
                 MakeOpFunction(cinn::hlir::op::InferDtypeForBroadcast))        \
       .set_attr("generate_equations",                                          \
                 MakeOpFunction(cinn::hlir::op::GenerateEquationsForBroadcast)) \
-      .set_attr("infer_symbolic_dim",                                          \
-                MakeOpFunction(cinn::hlir::op::InferSymbolicDimForBroadcast))  \
       .set_attr("inferlayout",                                                 \
                 MakeOpFunction(cinn::hlir::op::InferLayoutForBroadcast))       \
       .set_attr<cinn::hlir::framework::OpPatternKind>(                         \
diff --git a/paddle/cinn/hlir/op/elementwise.cc b/paddle/cinn/hlir/op/elementwise.cc
index c09ac0af0c6501..c325a429ec5d8d 100644
--- a/paddle/cinn/hlir/op/elementwise.cc
+++ b/paddle/cinn/hlir/op/elementwise.cc
@@ -18,7 +18,6 @@
 
 #include "absl/types/optional.h"
 #include "paddle/cinn/adt/op_equation_context.h"
-#include "paddle/cinn/adt/symbolic_dim_infer_ctx.h"
 #include "paddle/cinn/hlir/framework/node.h"
 #include "paddle/cinn/hlir/framework/op.h"
 #include "paddle/cinn/hlir/framework/op_strategy.h"
@@ -116,17 +115,6 @@ void GenerateEquationsForElementwise(
   ctx->Equal(ctx->GetInIteratorTuple(0), ctx->GetOutIteratorTuple(0));
 }
 
-void InferSymbolicDimForElementwise(
-    cinn::adt::config::SymbolicDimInferCtx *ctx) {
-  CHECK_EQ(ctx->GetInTensorsRanks().size(), 1)
-      << "The inputs is not 1! Please check again.";
-  CHECK_EQ(ctx->GetNumOutTensors(), 1)
-      << "The outputs is not 1! Please check again.";
-  for (std::size_t i = 0; i < ctx->GetInTensorsRanks().at(0); ++i) {
-    ctx->SetOutputDimExpr(0, i, ctx->GetInputDimExpr(0, i));
-  }
-}
-
 std::vector<Type> InferDtypeForElementwiseBool(
     const std::vector<Type> &inputs_type, const framework::AttrMapType &attrs) {
   CHECK(!inputs_type.empty())
@@ -438,16 +426,6 @@ void GenerateEquationsForFillConstant(
   // Do nothing
 }
 
-void InferSymbolicDimForFillConstant(
-    cinn::adt::config::SymbolicDimInferCtx *ctx) {
-  const framework::AttrMapType &attrs = ctx->GetAttributeMap();
-  CHECK(attrs.count("shape"));
-  const auto &shape = absl::get<std::vector<int>>(attrs.at("shape"));
-  for (std::size_t i = 0; i < shape.size(); ++i) {
-    ctx->SetOutputDimExpr(0, i, cinn::adt::DimExpr{shape.at(i)});
-  }
-}
-
 std::vector<std::vector<std::string>> InferLayoutForFillConstant(
     const std::vector<framework::shape_t> &input_shapes,
     const std::vector<std::string> &input_layouts,
@@ -1025,9 +1003,6 @@ CINN_REGISTER_HELPER(elementwise_ops) {
       .set_attr(                                                           \
           "generate_equations",                                            \
           MakeOpFunction(cinn::hlir::op::GenerateEquationsForElementwise)) \
-      .set_attr(                                                           \
-          "infer_symbolic_dim",                                            \
-          MakeOpFunction(cinn::hlir::op::InferSymbolicDimForElementwise))  \
       .set_attr("inferlayout",                                             \
                 MakeOpFunction(cinn::hlir::op::InferLayoutForElementwise)) \
       .set_attr<cinn::hlir::framework::OpPatternKind>(                     \
@@ -1152,8 +1127,6 @@ CINN_REGISTER_HELPER(elementwise_ops) {
       .set_attr(
           "generate_equations",
           MakeOpFunction(cinn::hlir::op::GenerateEquationsForFillConstant))
-      .set_attr("infer_symbolic_dim",
-                MakeOpFunction(cinn::hlir::op::InferSymbolicDimForFillConstant))
 #ifndef CINN_WITH_CUDA
       .set_attr("inferlayout",
                 MakeOpFunction(cinn::hlir::op::InferLayoutForFillConstant))
diff --git a/paddle/cinn/hlir/op/nn.cc b/paddle/cinn/hlir/op/nn.cc
index b3b25c473425a6..22bd95dcbf0109 100644
--- a/paddle/cinn/hlir/op/nn.cc
+++ b/paddle/cinn/hlir/op/nn.cc
@@ -17,7 +17,6 @@
 #include <functional>
 
 #include "paddle/cinn/adt/op_equation_context.h"
-#include "paddle/cinn/adt/symbolic_dim_infer_ctx.h"
 #include "paddle/cinn/hlir/framework/node.h"
 #include "paddle/cinn/hlir/framework/op.h"
 #include "paddle/cinn/hlir/framework/op_strategy.h"
@@ -86,16 +85,6 @@ void GenerateEquationsForRelu(cinn::adt::config::OpEquationContext *ctx) {
   ctx->Equal(ctx->GetInIteratorTuple(0), ctx->GetOutIteratorTuple(0));
 }
 
-void InferSymbolicDimForRelu(cinn::adt::config::SymbolicDimInferCtx *ctx) {
-  CHECK_EQ(ctx->GetInTensorsRanks().size(), 1)
-      << "The inputs is not 1! Please check again.";
-  CHECK_EQ(ctx->GetNumOutTensors(), 1)
-      << "The outputs is not 1! Please check again.";
-  for (std::size_t i = 0; i < ctx->GetInTensorsRanks().at(0); ++i) {
-    ctx->SetOutputDimExpr(0, i, ctx->GetInputDimExpr(0, i));
-  }
-}
-
 std::vector<Type> InferDtypeForRelu(const std::vector<Type> &inputs_type,
                                     const framework::AttrMapType &attrs) {
   CHECK(!inputs_type.empty())
@@ -2348,8 +2337,6 @@ CINN_REGISTER_HELPER(nn_ops) {
       .set_attr("inferdtype", MakeOpFunction(cinn::hlir::op::InferDtypeForRelu))
       .set_attr("generate_equations",
                 MakeOpFunction(cinn::hlir::op::GenerateEquationsForRelu))
-      .set_attr("infer_symbolic_dim",
-                MakeOpFunction(cinn::hlir::op::InferSymbolicDimForRelu))
 #ifndef CINN_WITH_CUDA
       .set_attr("inferlayout",
                 MakeOpFunction(cinn::hlir::op::InferLayoutForUnary))
diff --git a/paddle/cinn/hlir/op/reduction.cc b/paddle/cinn/hlir/op/reduction.cc
index c1af6d8d2dfc4d..c3125e5b70d6ae 100644
--- a/paddle/cinn/hlir/op/reduction.cc
+++ b/paddle/cinn/hlir/op/reduction.cc
@@ -454,51 +454,6 @@ void GenerateEquationsForReduction(cinn::adt::config::OpEquationContext *ctx) {
   });
 }
 
-void InferSymbolicDimForReduction(cinn::adt::config::SymbolicDimInferCtx *ctx) {
-  CHECK(ctx->GetInTensorsRanks().size() != 0)
-      << "The inputs is empty! Please check again.";
-  const bool keep_dim = ctx->Attr<bool>("keep_dim");
-  const auto &dim = ctx->Attr<std::vector<int>>("dim");
-
-  const auto &IsReduceAxis = [&](const int in_axis) {
-    return std::find(dim.begin(), dim.end(), in_axis) != dim.end();
-  };
-
-  const auto &VisitEachAxisPair = [&](const auto &DoEach) {
-    std::size_t out_axis = 0;
-    for (std::size_t in_axis = 0; in_axis < ctx->GetInTensorsRanks().at(0);
-         ++in_axis) {
-      if (IsReduceAxis(in_axis)) {
-        out_axis += keep_dim;
-      } else {
-        DoEach(in_axis, out_axis);
-        out_axis += 1;
-      }
-    }
-  };
-
-  const auto &GetOutputTensorRank = [&]() -> int {
-    if (keep_dim) {
-      return ctx->GetInTensorsRanks().at(0);
-    } else {
-      return ctx->GetInTensorsRanks().at(0) - dim.size();
-    }
-  };
-
-  std::unordered_set<int> visited_output_axis{};
-  VisitEachAxisPair([&](const int input_axis, const int output_axis) {
-    visited_output_axis.emplace(output_axis);
-    ctx->SetOutputDimExpr(0, output_axis, ctx->GetInputDimExpr(0, input_axis));
-  });
-  for (int axis = 0; axis < GetOutputTensorRank(); ++axis) {
-    if (visited_output_axis.count(axis)) {
-      // Do nothing
-    } else {
-      ctx->SetOutputDimExpr(0, axis, adt::DimExpr{1});
-    }
-  }
-}
-
 std::vector<Type> InferDtypeForReduction(const std::vector<Type> &inputs_type,
                                          const framework::AttrMapType &attrs) {
   CHECK(!inputs_type.empty())
@@ -576,8 +531,6 @@ CINN_REGISTER_HELPER(reduce_ops) {
           MakeOpFunction(cinn::hlir::op::InferDtypeForReduction##dtype__))     \
       .set_attr("generate_equations",                                          \
                 MakeOpFunction(cinn::hlir::op::GenerateEquationsForReduction)) \
-      .set_attr("infer_symbolic_dim",                                          \
-                MakeOpFunction(cinn::hlir::op::InferSymbolicDimForReduction))  \
       .set_attr("inferlayout",                                                 \
                 MakeOpFunction(cinn::hlir::op::InferLayoutForReduction))       \
       .set_attr<cinn::hlir::framework::OpPatternKind>(                         \
diff --git a/paddle/cinn/hlir/pe/map_expr_to_ir.cc b/paddle/cinn/hlir/pe/map_expr_to_ir.cc
index 66921b9d9ee9da..5a5e7bccff0c28 100644
--- a/paddle/cinn/hlir/pe/map_expr_to_ir.cc
+++ b/paddle/cinn/hlir/pe/map_expr_to_ir.cc
@@ -22,11 +22,15 @@
 #include "paddle/cinn/adt/map_expr.h"
 #include "paddle/cinn/adt/map_expr_ctx.h"
 #include "paddle/cinn/adt/match.h"
+#include "paddle/cinn/adt/no_inline_translator.h"
 #include "paddle/cinn/adt/print.h"
 #include "paddle/cinn/common/target.h"
 #include "paddle/cinn/ir/ir.h"
 #include "paddle/cinn/ir/ir_base.h"
 #include "paddle/cinn/ir/ir_printer.h"
+#include "paddle/cinn/runtime/flags.h"
+
+PD_DECLARE_bool(cinn_enable_map_expr_inline);
 
 namespace cinn::adt {
 
@@ -34,7 +38,7 @@ namespace {
 
 using IteratorInt = std::int32_t;
 using Node2LoweredFuncs =
-    std::unordered_map<hlir::framework::Node*, std::vector<ir::LoweredFunc>>;
+    std::unordered_map<::pir::Operation*, std::vector<ir::LoweredFunc>>;
 
 using TensorIteratorExpr4TensorT =
     std::function<adt::List<adt::TensorIteratorExpr>(const adt::Tensor&)>;
@@ -65,9 +69,9 @@ class MapExprToIrTranslator {
   }
 
  private:
-  ir::Expr GetStoreExprForOp(const hlir::framework::Node* op) const {
+  ir::Expr GetStoreExprForOp(const ::pir::Operation* op) const {
     const auto& iter =
-        node2lowered_funcs_->find(const_cast<hlir::framework::Node*>(op));
+        node2lowered_funcs_->find(const_cast<::pir::Operation*>(op));
     CHECK(iter != node2lowered_funcs_->end());
     const auto& lowered_funcs = iter->second;
     CHECK_EQ(lowered_funcs.size(), 1);
@@ -81,9 +85,9 @@ class MapExprToIrTranslator {
   }
 
   ir::Expr GetStoreExprForOp(
-      tReduceInit<const hlir::framework::Node*> op) const {
-    const auto& iter = node2lowered_funcs_->find(
-        const_cast<hlir::framework::Node*>(op.value()));
+      const tReduceInit<const ::pir::Operation*>& op) const {
+    const auto& iter =
+        node2lowered_funcs_->find(const_cast<::pir::Operation*>(op.value()));
     CHECK(iter != node2lowered_funcs_->end());
     const auto& lowered_funcs = iter->second;
     CHECK_EQ(lowered_funcs.size(), 1);
@@ -96,9 +100,9 @@ class MapExprToIrTranslator {
   }
 
   ir::Expr GetStoreExprForOp(
-      tReduceAcc<const hlir::framework::Node*> op) const {
-    const auto& iter = node2lowered_funcs_->find(
-        const_cast<hlir::framework::Node*>(op.value()));
+      const tReduceAcc<const ::pir::Operation*>& op) const {
+    const auto& iter =
+        node2lowered_funcs_->find(const_cast<::pir::Operation*>(op.value()));
     CHECK(iter != node2lowered_funcs_->end());
     const auto& lowered_funcs = iter->second;
     CHECK_EQ(lowered_funcs.size(), 1);
@@ -209,7 +213,12 @@ class MapExprToIrTranslator {
   }
 
   InlineStmt ConvertToInlineStmt(const InternalStmt& internal_stmt) const {
-    return InlineTranslator<MapStmt, OpCall, Tensor>::Call(internal_stmt);
+    if (FLAGS_cinn_enable_map_expr_inline) {
+      return InlineTranslator<MapStmt, OpCall, Tensor>::Call(internal_stmt);
+    } else {
+      return NoInlineTranslator<MapStmt, OpCall, Tensor>::Call(internal_stmt);
+    }
+    LOG(FATAL) << "Dead code";
   }
 
   std::optional<ir::Expr> TranslateOpExprImpl(
@@ -242,8 +251,61 @@ class MapExprToIrTranslator {
         op_expr.variant());
   }
 
+  std::optional<ir::Expr> MakeLoadExpr(
+      const ir::Expr& input_expr,
+      const List<OpExpr>& op_expr_children,
+      const IterExprs4TensorT& IterExprs4Tensor) const {
+    ir::Expr store_rvalue = ir::ir_utils::IRCopy(input_expr);
+    CHECK_EQ(store_rvalue->operands.size(), 0);
+    CHECK_EQ(op_expr_children->size(), 1);
+    store_rvalue.As<ir::Load>()->indices =
+        TranslateTensorIndex(op_expr_children->at(0), IterExprs4Tensor);
+    return store_rvalue;
+  }
+
+  std::optional<ir::Expr> MakeCallExpr(
+      const ir::Expr& input_expr,
+      const List<OpExpr>& op_expr_children,
+      const IterExprs4TensorT& IterExprs4Tensor) const {
+    ir::Expr store_rvalue = ir::ir_utils::IRCopy(input_expr);
+    CHECK_EQ(store_rvalue->operands.size(), 0);
+    CHECK(!op_expr_children->empty());
+    CHECK_EQ((store_rvalue.As<ir::Call>()->read_args.size()),
+             (op_expr_children->size()));
+    for (int i = 0; i < op_expr_children->size(); ++i) {
+      const auto& opt_operant = TranslateOpExpr(
+          op_expr_children->at(i), std::nullopt, IterExprs4Tensor);
+      if (opt_operant.has_value()) {
+        store_rvalue.As<ir::Call>()->read_args.at(i) = opt_operant.value();
+      } else {
+        store_rvalue.As<ir::Call>()->read_args.at(i).As<ir::Load>()->indices =
+            TranslateTensorIndex(op_expr_children->at(i), IterExprs4Tensor);
+      }
+    }
+    return store_rvalue;
+  }
+
+  std::optional<ir::Expr> MakeGeneralExpr(
+      const ir::Expr& input_expr,
+      const List<OpExpr>& op_expr_children,
+      const IterExprs4TensorT& IterExprs4Tensor) const {
+    ir::Expr store_rvalue = ir::ir_utils::IRCopy(input_expr);
+    CHECK_EQ(store_rvalue->operands.size(), op_expr_children->size());
+    for (int i = 0; i < op_expr_children->size(); ++i) {
+      const auto& opt_operant = TranslateOpExpr(
+          op_expr_children->at(i), std::nullopt, IterExprs4Tensor);
+      if (opt_operant.has_value()) {
+        store_rvalue->operands.at(i) = opt_operant.value();
+      } else {
+        store_rvalue->operands.at(i).As<ir::Load>()->indices =
+            TranslateTensorIndex(op_expr_children->at(i), IterExprs4Tensor);
+      }
+    }
+    return store_rvalue;
+  }
+
   std::optional<ir::Expr> TranslateOpCallImpl(
-      const hlir::framework::Node* op,
+      const ::pir::Operation* op,
       const OpCall<OpExpr>& op_expr,
       const std::optional<Tensor>& opt_output_tensor,
       const IterExprs4TensorT& IterExprs4Tensor) const {
@@ -253,23 +315,13 @@ class MapExprToIrTranslator {
     ir::Expr store_rvalue = store_expr.value().As<ir::Store>()->value;
 
     if (store_rvalue.As<ir::Load>()) {
-      CHECK_EQ(store_rvalue->operands.size(), 0);
-      CHECK_EQ(op_expr_children->size(), 1);
-      store_rvalue.As<ir::Load>()->indices =
-          TranslateTensorIndex(op_expr_children->at(0), IterExprs4Tensor);
+      return MakeLoadExpr(store_rvalue, op_expr_children, IterExprs4Tensor);
+    } else if (store_rvalue.As<ir::Call>()) {
+      return MakeCallExpr(store_rvalue, op_expr_children, IterExprs4Tensor);
     } else {
       if (!op_expr_children->empty()) {
-        CHECK_EQ(store_rvalue->operands.size(), op_expr_children->size());
-        for (int i = 0; i < op_expr_children->size(); ++i) {
-          const auto& opt_operant = TranslateOpExpr(
-              op_expr_children->at(i), std::nullopt, IterExprs4Tensor);
-          if (opt_operant.has_value()) {
-            store_rvalue->operands.at(i) = opt_operant.value();
-          } else {
-            store_rvalue->operands.at(i).As<ir::Load>()->indices =
-                TranslateTensorIndex(op_expr_children->at(i), IterExprs4Tensor);
-          }
-        }
+        return MakeGeneralExpr(
+            store_rvalue, op_expr_children, IterExprs4Tensor);
       } else {
         // Do nothing
       }
@@ -278,7 +330,7 @@ class MapExprToIrTranslator {
   }
 
   std::optional<ir::Expr> TranslateOpCallImpl(
-      const tReduceInit<const hlir::framework::Node*>& op,
+      const tReduceInit<const ::pir::Operation*>& op,
       const OpCall<OpExpr>& op_expr,
       const std::optional<Tensor>& opt_output_tensor,
       const IterExprs4TensorT& IterExprs4Tensor) const {
@@ -294,7 +346,7 @@ class MapExprToIrTranslator {
   }
 
   std::optional<ir::Expr> TranslateOpCallImpl(
-      const tReduceAcc<const hlir::framework::Node*>& op,
+      const tReduceAcc<const ::pir::Operation*>& op,
       const OpCall<OpExpr>& op_expr,
       const std::optional<Tensor>& opt_output_tensor,
       const IterExprs4TensorT& IterExprs4Tensor) const {
diff --git a/paddle/cinn/hlir/pe/map_expr_to_ir.h b/paddle/cinn/hlir/pe/map_expr_to_ir.h
index c89faac13d294f..18d954bb34d3d2 100644
--- a/paddle/cinn/hlir/pe/map_expr_to_ir.h
+++ b/paddle/cinn/hlir/pe/map_expr_to_ir.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include "paddle/cinn/adt/map_expr.h"
+#include "paddle/cinn/adt/map_expr_ctx.h"
 #include "paddle/cinn/ir/ir.h"
 
 namespace cinn::common {
diff --git a/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.cc b/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.cc
index 8c2ae6a6799c9e..21ef03bd6d5b36 100644
--- a/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.cc
+++ b/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.cc
@@ -143,6 +143,13 @@ void StaticShapeGroupScheduler::Schedule() {
 #endif
 }
 
+void StaticShapeGroupScheduler::MapExprSchedule() {
+  DoComputeInline();
+#ifdef CINN_WITH_CUDA
+  AllocateStorage();
+#endif
+}
+
 std::vector<std::pair<SymbolicCondition, ir::Expr>>
 StaticShapeGroupScheduler::GetIRs() {
   return {{Expr(1), ir_sch_->GetModule().GetExprs()[0]}};
diff --git a/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.h b/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.h
index b2b89c392bdc05..81d71a853dbfd5 100644
--- a/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.h
+++ b/paddle/cinn/ir/group_schedule/st_shape_group_scheduler.h
@@ -51,6 +51,8 @@ class StaticShapeGroupScheduler : public GroupScheduler {
 
   void Schedule() override;
 
+  void MapExprSchedule();
+
   std::vector<std::pair<SymbolicCondition, ir::Expr>> GetIRs() override;
 
  private:
diff --git a/paddle/cinn/pybind/frontend.cc b/paddle/cinn/pybind/frontend.cc
index 3fa0abc78f8fd2..aafa9bedf40d07 100644
--- a/paddle/cinn/pybind/frontend.cc
+++ b/paddle/cinn/pybind/frontend.cc
@@ -203,8 +203,6 @@ void BindFrontend(pybind11::module *m) {
 
             auto graph = Optimize(&self, fetch_ids, target, passes);
 
-            cinn::adt::TryGenerateMapExprFromGraph(graph);
-
             scope = hlir::framework::BuildScope(target, graph, scope);
             hlir::framework::CompilationContext context(graph, scope, target);
 
diff --git a/paddle/cinn/runtime/flags.cc b/paddle/cinn/runtime/flags.cc
index 3e06ede9b31530..16fabc434b5a10 100644
--- a/paddle/cinn/runtime/flags.cc
+++ b/paddle/cinn/runtime/flags.cc
@@ -79,10 +79,12 @@ PD_DEFINE_bool(cinn_enable_map_expr,
                BoolFromEnv("FLAGS_cinn_enable_map_expr", false),
                "It controls whether to use cinn with map_expr");
 
-PD_DEFINE_bool(
-    cinn_map_expr_enable_schedule,
-    BoolFromEnv("FLAGS_cinn_map_expr_enable_schedule", false),
-    "It controls whether to use schedule and pass when enables map_expr");
+PD_DEFINE_bool(cinn_enable_map_expr_schedule,
+               BoolFromEnv("FLAGS_cinn_enable_map_expr_schedule", true),
+               "It controls whether to schedule by map_expr");
+PD_DEFINE_bool(cinn_enable_map_expr_inline,
+               BoolFromEnv("FLAGS_cinn_enable_map_expr_inline", false),
+               "It controls whether to inline by map_expr");
 
 PD_DEFINE_bool(
     cinn_map_expr_enable_dynamic_shape,
diff --git a/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc b/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc
index 34e43ac5d71ee6..47bc076ca689aa 100644
--- a/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc
+++ b/paddle/fluid/framework/paddle2cinn/cinn_compiler.cc
@@ -321,8 +321,6 @@ std::unique_ptr<CinnCompiledObject> CinnCompiler::CompileGraph(
           << target.arch_str() << "), and its related graph:\n"
           << cinn_graph->Visualize();
 
-  cinn::adt::TryGenerateMapExprFromGraph(cinn_graph);
-
   auto scope = BuildScope(target, cinn_graph);
   CompilationContext context(cinn_graph, scope, target);
   context.with_instantiate_variables = false;
diff --git a/test/cinn/CMakeLists.txt b/test/cinn/CMakeLists.txt
index 3a25d7e1ef182a..3158c4372d8fdb 100644
--- a/test/cinn/CMakeLists.txt
+++ b/test/cinn/CMakeLists.txt
@@ -310,27 +310,4 @@ if(WITH_GPU)
       WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
   endforeach()
 
-  # adt test
-  file(
-    GLOB CINN_ADT_TEST
-    RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
-    "adt/test_*.py")
-  set(EXCLUDE_ADT_TEST test_add_inline)
-
-  foreach(adt_test_name ${EXCLUDE_ADT_TEST})
-    list(REMOVE_ITEM CINN_ADT_TEST adt/${adt_test_name}.py)
-  endforeach()
-
-  foreach(adt_test_name ${CINN_ADT_TEST})
-    string(REGEX REPLACE ".py" "" adt_test_name ${adt_test_name})
-    add_test(
-      NAME ${adt_test_name}
-      COMMAND
-        ${CMAKE_COMMAND} -E env
-        PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/cinn:$ENV{PYTHONPATH}
-        FLAGS_cinn_enable_map_expr=True python3
-        ${CMAKE_CURRENT_SOURCE_DIR}/${adt_test_name}.py
-      WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
-  endforeach()
-
 endif()
diff --git a/test/cinn/adt/test_add_inline.py b/test/cinn/adt/test_add_inline.py
deleted file mode 100755
index df92e86677abcc..00000000000000
--- a/test/cinn/adt/test_add_inline.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprAddFusion(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x": np.random.uniform(-1.0, 1.0, [1024, 1024]).astype("float32"),
-            "y": np.random.uniform(-1.0, 1.0, [1024, 1024]).astype("float32"),
-            "z": np.random.uniform(-1.0, 1.0, [1024, 1024]).astype("float32"),
-        }
-
-    def test_add_fusion(self):
-        builder = NetBuilder("TestMapExprAddFusion")
-        x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
-        y = builder.create_input(Float(32), self.inputs["y"].shape, "y")
-        z = builder.create_input(Float(32), self.inputs["z"].shape, "z")
-
-        a = builder.elementwise_add(x, y)
-        out = builder.elementwise_add(a, z)
-
-        prog = builder.build()
-        target = DefaultNVGPUTarget()
-        result = prog.build_and_get_output(
-            target,
-            [x, y, z],
-            [self.inputs["x"], self.inputs["y"], self.inputs["z"]],
-            [out],
-            passes=[],
-            scope=None,
-        )
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            self.inputs["x"] + self.inputs["y"] + self.inputs["z"],
-            err_msg="TestMapExprAddFusion failed!",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/cinn/adt/test_broadcast_expr.py b/test/cinn/adt/test_broadcast_expr.py
deleted file mode 100755
index a9caea37c6d064..00000000000000
--- a/test/cinn/adt/test_broadcast_expr.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprBroadcast(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x1": np.random.uniform(-1.0, 1.0, [4, 16]).astype("float32"),
-            "x2": np.random.uniform(-1.0, 1.0, [16]).astype("float32"),
-        }
-
-    def test_broadcast(self):
-        builder = NetBuilder("TestMapExprBroadcast")
-        x1 = builder.create_input(Float(32), self.inputs["x1"].shape, "x1")
-        x2 = builder.create_input(Float(32), self.inputs["x2"].shape, "x2")
-        z = builder.elementwise_add(x1, x2)
-        out = builder.relu(z)
-        prog = builder.build()
-
-        target = DefaultNVGPUTarget()
-
-        result = prog.build_and_get_output(
-            target,
-            [x1, x2],
-            [self.inputs["x1"], self.inputs["x2"]],
-            [out],
-            passes=[],
-            scope=None,
-        )
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            np.maximum((self.inputs["x1"] + self.inputs["x2"]), 0),
-            err_msg="TestMapExprBroadcast failed!",
-        )
-        print("Finish Test")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/cinn/adt/test_fusion_ability.py b/test/cinn/adt/test_fusion_ability.py
deleted file mode 100644
index 0bf40af0fc34ff..00000000000000
--- a/test/cinn/adt/test_fusion_ability.py
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprReduceFusion(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x": np.random.uniform(-1.0, 1.0, [2, 1024]).astype("float32"),
-            "y": np.random.uniform(-1.0, 1.0, [2, 1024]).astype("float32"),
-        }
-
-    def test_reduce_fusion(self):
-        builder = NetBuilder("TestMapExprReduceFusion")
-        x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
-        y = builder.create_input(Float(32), self.inputs["y"].shape, "y")
-
-        t = builder.elementwise_add(x, y)
-        t = builder.relu(t)
-        t = builder.elementwise_add(t, y)
-        out = builder.reduce_sum(t, [0], False)
-        prog = builder.build()
-
-        target = DefaultNVGPUTarget()
-        result = prog.build_and_get_output(
-            target,
-            [x, y],
-            [self.inputs["x"], self.inputs["y"]],
-            [out],
-            passes=[],
-            scope=None,
-        )
-
-        np_expect = self.inputs["x"] + self.inputs["y"]
-        np_expect = np.maximum(np_expect, 0)
-        np_expect = np_expect + self.inputs["y"]
-        np_expect = np.sum(np_expect, axis=0)
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            np_expect,
-            err_msg="TestMapExprReduceFusion failed!",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/cinn/adt/test_naive_add.py b/test/cinn/adt/test_naive_add.py
deleted file mode 100755
index 304978ae5ceab5..00000000000000
--- a/test/cinn/adt/test_naive_add.py
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprNaiveAdd(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x": np.random.uniform(-1.0, 1.0, [1024, 1024]).astype("float32"),
-            "y": np.random.uniform(-1.0, 1.0, [1024, 1024]).astype("float32"),
-        }
-
-    def test_naive_add(self):
-        builder = NetBuilder("TestMapExprNaiveAdd")
-        x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
-        y = builder.create_input(Float(32), self.inputs["y"].shape, "y")
-
-        out = builder.elementwise_add(x, y)
-        prog = builder.build()
-        target = DefaultNVGPUTarget()
-
-        result = prog.build_and_get_output(
-            target,
-            [x, y],
-            [self.inputs["x"], self.inputs["y"]],
-            [out],
-            passes=[],
-            scope=None,
-        )
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            self.inputs["x"] + self.inputs["y"],
-            err_msg="TestMapExprNaiveAdd failed!",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/cinn/adt/test_naive_reduce.py b/test/cinn/adt/test_naive_reduce.py
deleted file mode 100644
index 217ef7695f539e..00000000000000
--- a/test/cinn/adt/test_naive_reduce.py
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprNaiveReduce(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x": np.random.uniform(-1.0, 1.0, [2, 1024, 1024]).astype("float32")
-        }
-
-    def test_naive_reduce(self):
-        builder = NetBuilder("TestMapExprNaiveReduce")
-        x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
-
-        out = builder.reduce_sum(x, [0], False)
-        prog = builder.build()
-        target = DefaultNVGPUTarget()
-
-        result = prog.build_and_get_output(
-            target, [x], [self.inputs["x"]], [out], passes=[], scope=None
-        )
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            np.sum(self.inputs["x"], axis=0),
-            err_msg="TestMapExprNaiveReduce failed!",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/cinn/adt/test_reduce_fusion.py b/test/cinn/adt/test_reduce_fusion.py
deleted file mode 100644
index 2432e53e21bcc5..00000000000000
--- a/test/cinn/adt/test_reduce_fusion.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprReduceFusion(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x": np.random.uniform(-1.0, 1.0, [2, 1024, 1024]).astype(
-                "float32"
-            ),
-            "y": np.random.uniform(-1.0, 1.0, [2, 1024, 1024]).astype(
-                "float32"
-            ),
-        }
-
-    def test_reduce_fusion(self):
-        builder = NetBuilder("TestMapExprReduceFusion")
-        x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
-        y = builder.create_input(Float(32), self.inputs["y"].shape, "y")
-
-        t = builder.elementwise_add(x, y)
-        out = builder.reduce_sum(t, [0], False)
-        prog = builder.build()
-
-        target = DefaultNVGPUTarget()
-        result = prog.build_and_get_output(
-            target,
-            [x, y],
-            [self.inputs["x"], self.inputs["y"]],
-            [out],
-            passes=[],
-            scope=None,
-        )
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            np.sum(self.inputs["x"] + self.inputs["y"], axis=0),
-            err_msg="TestMapExprReduceFusion failed!",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/cinn/adt/test_reduce_schedule_mesh.py b/test/cinn/adt/test_reduce_schedule_mesh.py
deleted file mode 100644
index 10bde8159932b5..00000000000000
--- a/test/cinn/adt/test_reduce_schedule_mesh.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2021 CINN Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-import numpy as np
-from cinn.common import DefaultNVGPUTarget, Float
-from cinn.frontend import NetBuilder
-
-
-class TestMapExprReduceScheduleMesh(unittest.TestCase):
-    def setUp(self):
-        self.inputs = {
-            "x": np.random.uniform(-1.0, 1.0, [32, 2048]).astype("float32"),
-            "y": np.random.uniform(-1.0, 1.0, [32, 2048]).astype("float32"),
-        }
-
-    def test_schedule_mesh(self):
-        builder = NetBuilder("TestMapExprReduceScheduleMesh")
-        x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
-        y = builder.create_input(Float(32), self.inputs["y"].shape, "y")
-
-        t = builder.elementwise_add(x, y)
-        out = builder.reduce_sum(t, [0], False)
-        prog = builder.build()
-
-        target = DefaultNVGPUTarget()
-
-        result = prog.build_and_get_output(
-            target,
-            [x, y],
-            [self.inputs["x"], self.inputs["y"]],
-            [out],
-            passes=[],
-            scope=None,
-        )
-
-        np.testing.assert_allclose(
-            result[0].numpy(target),
-            np.sum(self.inputs["x"] + self.inputs["y"], axis=0),
-            err_msg="TestMapExprReduceScheduleMesh failed!",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()