diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td
--- a/mlir/include/mlir/IR/OpBase.td
+++ b/mlir/include/mlir/IR/OpBase.td
@@ -1724,6 +1724,8 @@
 def Idempotent  : NativeOpTrait<"IsIdempotent">;
 // op op X == X
 def Involution  : NativeOpTrait<"IsInvolution">;
+// op op' X = op' op X for all per-element unary op'.
+def ElementPreserving  : NativeOpTrait<"IsElementPreserving">;
 // Op behaves like a constant.
 def ConstantLike : NativeOpTrait<"ConstantLike">;
 // Op behaves like a function.
diff --git a/mlir/include/mlir/IR/OpDefinition.h b/mlir/include/mlir/IR/OpDefinition.h
--- a/mlir/include/mlir/IR/OpDefinition.h
+++ b/mlir/include/mlir/IR/OpDefinition.h
@@ -395,6 +395,7 @@
 LogicalResult verifyNOperands(Operation *op, unsigned numOperands);
 LogicalResult verifyIsIdempotent(Operation *op);
 LogicalResult verifyIsInvolution(Operation *op);
+LogicalResult verifyIsElementPreserving(Operation *op);
 LogicalResult verifyAtLeastNOperands(Operation *op, unsigned numOperands);
 LogicalResult verifyOperandsAreFloatLike(Operation *op);
 LogicalResult verifyOperandsAreSignlessIntegerLike(Operation *op);
@@ -1057,6 +1058,26 @@
   }
 };
 
+/// This class adds property that the operation is element preserving.
+/// This means a unary to unary operation "f" that satisfies
+/// f(g(x)) = g(f(x)) for all per element unary ops g
+template <typename ConcreteType>
+class IsElementPreserving
+    : public TraitBase<ConcreteType, IsElementPreserving> {
+public:
+  static LogicalResult verifyTrait(Operation *op) {
+    static_assert(ConcreteType::template hasTrait<OneResult>(),
+                  "expected operation to produce one result");
+    static_assert(ConcreteType::template hasTrait<OneOperand>(),
+                  "expected operation to take one operand");
+    static_assert(ConcreteType::template hasTrait<SameOperandsAndResultType>(),
+                  "expected operation to preserve type");
+    // ElementPreserving requires the operation to be side effect free as well
+    // but currently this check is under a FIXME and is not actually done.
+    return impl::verifyIsElementPreserving(op);
+  }
+};
+
 /// This class verifies that all operands of the specified op have a float type,
 /// a vector thereof, or a tensor thereof.
 template <typename ConcreteType>
diff --git a/mlir/include/mlir/IR/PatternMatch.h b/mlir/include/mlir/IR/PatternMatch.h
--- a/mlir/include/mlir/IR/PatternMatch.h
+++ b/mlir/include/mlir/IR/PatternMatch.h
@@ -231,6 +231,50 @@
   }
 };
 
+/// TraitRewritePattern is a wrapper around RewritePattern that allows for
+/// matching and rewriting against an op that matches a trait
+template <template <typename> class Trait, typename TraitPattern>
+struct TraitRewritePattern : public RewritePattern {
+  /// Patterns can specify the benefit of the pattern matching.
+  TraitRewritePattern(MLIRContext *context, PatternBenefit benefit = 1)
+      : RewritePattern({}, benefit, context, MatchAnyOpTypeTag{}) {}
+
+  /// Wrappers around the RewritePattern methods that pass the op if it
+  /// matches the trait.
+  void rewrite(Operation *op, PatternRewriter &rewriter) const final {
+    static_cast<const TraitPattern *>(this)->rewriteTrait(op, rewriter);
+  }
+  LogicalResult match(Operation *op) const final {
+    if (op->hasTrait<Trait>())
+      return static_cast<const TraitPattern *>(this)->matchTrait(op);
+    return failure();
+  }
+  LogicalResult matchAndRewrite(Operation *op,
+                                PatternRewriter &rewriter) const final {
+    if (op->hasTrait<Trait>())
+      return static_cast<const TraitPattern *>(this)->matchAndRewriteTrait(
+          op, rewriter);
+    return failure();
+  }
+
+  /// Rewrite and Match methods that operate on the op with the given
+  /// trait. These must be overridden by the derived pattern class.
+  void rewriteTrait(Operation *op, PatternRewriter &rewriter) const {
+    llvm_unreachable("must override rewrite or matchAndRewrite");
+  }
+  LogicalResult matchTrait(Operation *op) const {
+    llvm_unreachable("must override match or matchAndRewrite");
+  }
+  LogicalResult matchAndRewriteTrait(Operation *op,
+                                     PatternRewriter &rewriter) const {
+    if (succeeded(matchTrait(op))) {
+      rewriteTrait(op, rewriter);
+      return success();
+    }
+    return failure();
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // PatternRewriter class
 //===----------------------------------------------------------------------===//
diff --git a/mlir/include/mlir/Transforms/Trait.h b/mlir/include/mlir/Transforms/Trait.h
new file mode 100644
--- /dev/null
+++ b/mlir/include/mlir/Transforms/Trait.h
@@ -0,0 +1,21 @@
+#ifndef MLIR_TRANSFORMS_TRAIT_H
+#define MLIR_TRANSFORMS_TRAIT_H
+
+#include "mlir/IR/PatternMatch.h"
+
+namespace mlir {
+/// Folds Involution trait labelled ops across ElementPreserving labelled ops.
+class FoldInvolutionsThroughElementPreserving
+    : public TraitRewritePattern<OpTrait::IsInvolution,
+                                 FoldInvolutionsThroughElementPreserving> {
+public:
+  using TraitRewritePattern<
+      OpTrait::IsInvolution,
+      FoldInvolutionsThroughElementPreserving>::TraitRewritePattern;
+  /// Performs the actual rewriting step.
+  LogicalResult matchAndRewriteTrait(Operation *op,
+                                     PatternRewriter &rewriter) const;
+};
+} // namespace mlir
+
+#endif // MLIR_TRANSFORMS_TRAIT_H
\ No newline at end of file
diff --git a/mlir/lib/IR/Operation.cpp b/mlir/lib/IR/Operation.cpp
--- a/mlir/lib/IR/Operation.cpp
+++ b/mlir/lib/IR/Operation.cpp
@@ -756,6 +756,14 @@
   return success();
 }
 
+LogicalResult OpTrait::impl::verifyIsElementPreserving(Operation *op) {
+  // FIXME: Add back check for no side effects on operation.
+  // Currently adding it would cause the shared library build
+  // to fail since there would be a dependency of IR on SideEffectInterfaces
+  // which is cyclical.
+  return success();
+}
+
 LogicalResult
 OpTrait::impl::verifyOperandsAreSignlessIntegerLike(Operation *op) {
   for (auto opType : op->getOperandTypes()) {
diff --git a/mlir/lib/Transforms/CMakeLists.txt b/mlir/lib/Transforms/CMakeLists.txt
--- a/mlir/lib/Transforms/CMakeLists.txt
+++ b/mlir/lib/Transforms/CMakeLists.txt
@@ -20,6 +20,7 @@
   SCCP.cpp
   StripDebugInfo.cpp
   SymbolDCE.cpp
+  Trait.cpp
   ViewOpGraph.cpp
   ViewRegionGraph.cpp
 
diff --git a/mlir/lib/Transforms/Trait.cpp b/mlir/lib/Transforms/Trait.cpp
new file mode 100644
--- /dev/null
+++ b/mlir/lib/Transforms/Trait.cpp
@@ -0,0 +1,33 @@
+#include "mlir/Transforms/Trait.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// FoldInvolutionsThroughElement
+//===----------------------------------------------------------------------===//
+
+LogicalResult FoldInvolutionsThroughElementPreserving::matchAndRewriteTrait(
+    Operation *op, PatternRewriter &rewriter) const {
+
+  auto *argumentOp = op->getOperand(0).getDefiningOp();
+
+  if (argumentOp && op->getName() == argumentOp->getName())
+    return failure();
+
+  while (argumentOp && op->getName() != argumentOp->getName() &&
+         argumentOp->hasTrait<OpTrait::IsElementPreserving>() &&
+         argumentOp->hasOneUse()) {
+    // Involution and value preserving ops all have one arg.
+    assert(argumentOp->getNumOperands() == 1);
+    argumentOp = argumentOp->getOperand(0).getDefiningOp();
+  }
+
+  if (argumentOp && op->getName() == argumentOp->getName() &&
+      argumentOp->hasOneUse()) {
+    rewriter.replaceOp(argumentOp, {argumentOp->getOperand(0)});
+    rewriter.replaceOp(op, {op->getOperand(0)});
+    return success();
+  }
+
+  return failure();
+}
\ No newline at end of file
diff --git a/mlir/test/lib/Dialect/Test/TestOps.td b/mlir/test/lib/Dialect/Test/TestOps.td
--- a/mlir/test/lib/Dialect/Test/TestOps.td
+++ b/mlir/test/lib/Dialect/Test/TestOps.td
@@ -870,6 +870,20 @@
   let hasFolder = 1;
 }
 
+def TestElementPreservingTraitOp
+ : TEST_Op<"op_element_preserving_trait",
+           [SameOperandsAndResultType, NoSideEffect, ElementPreserving]> {
+  let arguments = (ins I32:$op1);
+  let results = (outs I32);
+}
+
+def TestNoElementPreservingTraitOp
+ : TEST_Op<"op_no_element_preserving_trait",
+           [SameOperandsAndResultType, NoSideEffect]> {
+  let arguments = (ins I32:$op1);
+  let results = (outs I32);
+}
+
 def TestOpInPlaceFoldAnchor : TEST_Op<"op_in_place_fold_anchor"> {
   let arguments = (ins I32);
   let results = (outs I32);
diff --git a/mlir/test/lib/Dialect/Test/TestTraits.cpp b/mlir/test/lib/Dialect/Test/TestTraits.cpp
--- a/mlir/test/lib/Dialect/Test/TestTraits.cpp
+++ b/mlir/test/lib/Dialect/Test/TestTraits.cpp
@@ -10,6 +10,7 @@
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/FoldUtils.h"
+#include "mlir/Transforms/Trait.h"
 
 using namespace mlir;
 
@@ -33,7 +34,9 @@
 namespace {
 struct TestTraitFolder : public PassWrapper<TestTraitFolder, FunctionPass> {
   void runOnFunction() override {
-    applyPatternsAndFoldGreedily(getFunction(), {});
+    OwningRewritePatternList patterns;
+    patterns.insert<FoldInvolutionsThroughElementPreserving>(&getContext());
+    applyPatternsAndFoldGreedily(getFunction(), patterns);
   }
 };
 } // end anonymous namespace
diff --git a/mlir/test/mlir-tblgen/trait.mlir b/mlir/test/mlir-tblgen/trait.mlir
--- a/mlir/test/mlir-tblgen/trait.mlir
+++ b/mlir/test/mlir-tblgen/trait.mlir
@@ -93,3 +93,64 @@
   // CHECK: return [[IDEMPOTENT]]
   return %2: i32
 }
+
+//===----------------------------------------------------------------------===//
+// Test that folding involution ops mixed with element preserving ops
+// works correctly
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: func @testSingleElementPreserving
+// CHECK-SAME:  ([[ARG0:%.+]]: i32)
+func @testSingleElementPreserving(%arg0 : i32) -> i32 {
+  %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES:%.+]] = "test.op_element_preserving_trait"([[ARG0]])
+  %1 = "test.op_element_preserving_trait"(%0) : (i32) -> i32
+  %2 = "test.op_involution_trait_no_operation_fold"(%1) : (i32) -> i32
+  // CHECK: return [[ELEMENTPRES]]
+  return %2: i32
+}
+
+// CHECK-LABEL: func @testChainElementPreserving
+// CHECK-SAME:  ([[ARG0:%.+]]: i32)
+func @testChainElementPreserving(%arg0 : i32) -> i32 {
+  %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES1:%.+]] = "test.op_element_preserving_trait"([[ARG0]])
+  %1 = "test.op_element_preserving_trait"(%0) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES2:%.+]] = "test.op_element_preserving_trait"([[ELEMENTPRES1]])
+  %2 = "test.op_element_preserving_trait"(%1) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES3:%.+]] = "test.op_element_preserving_trait"([[ELEMENTPRES2]])
+  %3 = "test.op_element_preserving_trait"(%2) : (i32) -> i32
+  %4 = "test.op_involution_trait_no_operation_fold"(%3) : (i32) -> i32
+  // CHECK: return [[ELEMENTPRES3]]
+  return %4: i32
+}
+
+// CHECK-LABEL: func @testNoElementPreserving
+// CHECK-SAME:  ([[ARG0:%.+]]: i32)
+func @testNoElementPreserving(%arg0 : i32) -> i32 {
+  // CHECK: [[INVOLUTION1:%.+]] = "test.op_involution_trait_no_operation_fold"([[ARG0]])
+  %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES1:%.+]] = "test.op_element_preserving_trait"([[INVOLUTION1]])
+  %1 = "test.op_element_preserving_trait"(%0) : (i32) -> i32
+  // CHECK: [[NOELEMENTPRES:%.+]] = "test.op_no_element_preserving_trait"([[ELEMENTPRES1]])
+  %2 = "test.op_no_element_preserving_trait"(%1) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES2:%.+]] = "test.op_element_preserving_trait"([[NOELEMENTPRES]])
+  %3 = "test.op_element_preserving_trait"(%2) : (i32) -> i32
+  // CHECK: return [[ELEMENTPRES2]]
+  return %3: i32
+}
+
+// CHECK-LABEL: func @testNoOneUse
+// CHECK-SAME:  ([[ARG0:%.+]]: i32)
+func @testNoOneUse(%arg0 : i32) -> (i32, i32) {
+  // CHECK: [[INVOLUTION1:%.+]] = "test.op_involution_trait_no_operation_fold"([[ARG0]])
+  %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES1:%.+]] = "test.op_element_preserving_trait"([[INVOLUTION1]])
+  %1 = "test.op_element_preserving_trait"(%0) : (i32) -> i32
+  // CHECK: [[ELEMENTPRES2:%.+]] = "test.op_element_preserving_trait"([[INVOLUTION1]])
+  %2 = "test.op_element_preserving_trait"(%0) : (i32) -> i32
+  // CHECK: [[INVOLUTION2:%.+]] = "test.op_involution_trait_no_operation_fold"([[ELEMENTPRES1]])
+  %3 = "test.op_involution_trait_no_operation_fold"(%1) : (i32) -> i32
+  // CHECK: return [[ELEMENTPRES2]], [[INVOLUTION2]]
+  return %2, %3 : i32, i32
+}