diff --git a/include/spblas/views/matrix_view.hpp b/include/spblas/views/matrix_view.hpp
new file mode 100644
index 0000000..cca047b
--- /dev/null
+++ b/include/spblas/views/matrix_view.hpp
@@ -0,0 +1,338 @@
+#pragma once
+#include <spblas/views/view_base.hpp>
+#include <type_traits>
+
+namespace spblas {
+namespace matrix_view {
+namespace diag {
+// always treat the diagonal value as unit
+class implicit_unit {};
+
+// always treat the diagonal value as zero
+class implicit_zero {};
+
+// use the matrix diagonal
+class explicit_diag {};
+
+template <typename d>
+concept diag =
+    std::is_same_v<d, implicit_unit> || std::is_same_v<d, implicit_zero> ||
+    std::is_same_v<d, explicit_diag>;
+} // namespace diag
+
+namespace uplo {
+// full matrix
+class full {};
+
+// take the lower triangular part of the matrix
+class lower {};
+
+// take the upper triangular part of the matrix
+class upper {};
+
+// take the diagonal part of the matrix
+class diag {};
+
+template <typename d>
+concept uplo = std::is_same_v<d, full> || std::is_same_v<d, lower> ||
+               std::is_same_v<d, upper> || std::is_same_v<d, diag>;
+} // namespace uplo
+
+namespace __detail {
+
+// help the diagonal transformation
+// implicit_* will overwite the previous type
+// explicit_diag keeps the type
+template <typename T, typename U>
+struct decide_diag {};
+
+template <typename T>
+struct decide_diag<T, diag::implicit_unit> {
+  using type = diag::implicit_unit;
+};
+
+template <typename T>
+struct decide_diag<T, diag::implicit_zero> {
+  using type = diag::implicit_zero;
+};
+
+template <typename T>
+struct decide_diag<T, diag::explicit_diag> {
+  using type = T;
+};
+
+} // namespace __detail
+
+/**
+ * This is a view contain all possiblitity how kernel can intepret the matrix
+ * with specific order. This will not touch the matrix_opt itself, it will leave
+ * the operation to backend to decide what to do.
+ *
+ * @tparam Conjugate  whether to conjugate the matrix
+ * @tparam Transpose  whether to transpose the matrix
+ * @tparam Diagonal  how to handle diagonal
+ * @tparam UpLo  how to access the part of matrix
+ */
+template <typename matrix_opt, typename Conjugate = std::false_type,
+          typename Transpose = std::false_type,
+          diag::diag Diagonal = diag::explicit_diag,
+          uplo::uplo UpLo = uplo::full>
+class general : public spblas::view_base {
+public:
+  general(matrix_opt&& t) : obj(t) {}
+
+  auto& base() {
+    return obj;
+  }
+
+  auto& base() const {
+    return obj;
+  }
+
+private:
+  matrix_opt& obj;
+};
+
+template <typename matrix_opt>
+auto conjugate(matrix_opt&& matrix) {
+  return general<matrix_opt, std::true_type>(matrix);
+}
+
+template <typename matrix_opt, typename Transpose, typename Diagonal,
+          typename UpLo>
+auto conjugate(
+    general<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename Transpose, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+auto conjugate(
+    general<matrix_opt, std::false_type, Transpose, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, std::true_type, Transpose, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename matrix_opt>
+auto transpose(matrix_opt&& matrix) {
+  return general<matrix_opt, std::false_type, std::true_type>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+  requires(!std::is_same_v<UpLo, uplo::diag>)
+auto transpose(
+    general<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename UpLo,
+          typename matrix_opt>
+  requires(!std::is_same_v<UpLo, uplo::diag>)
+auto transpose(
+    general<matrix_opt, Conjugate, std::true_type, Diagonal, UpLo>&& matrix) {
+  return general<matrix_opt, Conjugate, std::false_type, Diagonal, UpLo>(
+      matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename Transpose,
+          typename matrix_opt>
+auto transpose(
+    general<matrix_opt, Conjugate, Transpose, Diagonal, uplo::diag>&& matrix) {
+  return general<matrix_opt, Conjugate, std::false_type, Diagonal, uplo::diag>(
+      matrix.base());
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto diagonal(matrix_opt&& matrix, TreatDiag = {}) {
+  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                 uplo::diag>(matrix);
+}
+
+template <typename Conjugate, typename Transpose, typename Diagonal,
+          typename UpLo, typename matrix_opt, typename TreatDiag>
+auto diagonal(general<matrix_opt, Conjugate, Transpose,
+                      typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                      UpLo>&& matrix,
+              TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto triangle(matrix_opt&& matrix, uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                 uplo::lower>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::lower, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename matrix_opt, typename TreatDiag = diag::explicit_diag>
+auto triangle(matrix_opt&& matrix, uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, std::false_type, std::false_type, TreatDiag,
+                 uplo::upper>(matrix);
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::upper>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::false_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::full>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::lower>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::true_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::lower>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::upper>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+template <typename Conjugate, typename Diagonal, typename matrix_opt,
+          typename TreatDiag = diag::explicit_diag>
+auto triangle(general<matrix_opt, Conjugate, std::true_type, Diagonal,
+                      uplo::diag>&& matrix,
+              uplo::upper, TreatDiag = {}) {
+  return general<matrix_opt, Conjugate, std::false_type,
+                 typename __detail::decide_diag<Diagonal, TreatDiag>::type,
+                 uplo::diag>(matrix.base());
+}
+
+} // namespace matrix_view
+} // namespace spblas
diff --git a/test/gtest/CMakeLists.txt b/test/gtest/CMakeLists.txt
index b458a17..79ec433 100644
--- a/test/gtest/CMakeLists.txt
+++ b/test/gtest/CMakeLists.txt
@@ -12,7 +12,8 @@ if (SPBLAS_CPU_BACKEND)
        add_test.cpp
        transpose_test.cpp
        triangular_solve_test.cpp
-       mdspan_overlays.cpp)
+       mdspan_overlays.cpp
+       matrix_view_test.cpp)
 
   if (ENABLE_ONEMKL_SYCL OR SPBLAS_REFERENCE_BACKEND)
     list(APPEND TEST_SOURCES conjugate_test.cpp)
diff --git a/test/gtest/matrix_view_test.cpp b/test/gtest/matrix_view_test.cpp
new file mode 100644
index 0000000..81cc994
--- /dev/null
+++ b/test/gtest/matrix_view_test.cpp
@@ -0,0 +1,230 @@
+#include <gtest/gtest.h>
+#include <spblas/views/matrix_view.hpp>
+#include <type_traits>
+
+namespace {
+
+class temp {};
+
+using ::testing::StaticAssertTypeEq;
+// only for the testing
+using namespace spblas::matrix_view;
+
+TEST(Tag, Conjugate) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(conjugate(t)),
+                     general<temp&, std::true_type, std::false_type,
+                             diag::explicit_diag, uplo::full>>();
+  StaticAssertTypeEq<decltype(conjugate(conjugate(t))),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::full>>();
+  EXPECT_EQ(&(conjugate(t).base()), &t);
+  EXPECT_EQ(&(conjugate(conjugate(t)).base()), &t);
+}
+
+TEST(Tag, Tranpose) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(transpose(t)),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::full>>();
+  StaticAssertTypeEq<decltype(transpose(transpose(t))),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::full>>();
+  EXPECT_EQ(&(transpose(t).base()), &t);
+  EXPECT_EQ(&(transpose(transpose(t)).base()), &t);
+}
+
+TEST(Tag, Diagonal) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(diagonal(t)),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::diag>>();
+  EXPECT_EQ(&(diagonal(t).base()), &t);
+}
+
+TEST(Tag, Lower) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(t, uplo::lower())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::lower()),
+                                       uplo::lower())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::lower(),
+                                       diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::lower(),
+                                       diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_unit()),
+                         uplo::lower(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_zero()),
+                         uplo::lower(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_unit()),
+                         uplo::lower(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_zero()),
+                         uplo::lower(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  //   Unit or Zero Diag will overwrite the old one
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_unit()),
+                         uplo::lower(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::lower(), diag::implicit_zero()),
+                         uplo::lower(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::lower>>();
+
+  EXPECT_EQ(&(triangle(t, uplo::lower()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_zero()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::lower(), diag::implicit_unit()).base()), &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_zero()),
+                       uplo::lower(), diag::implicit_unit())
+                  .base()),
+            &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::lower(), diag::implicit_unit()),
+                       uplo::lower(), diag::implicit_zero())
+                  .base()),
+            &t);
+}
+
+TEST(Tag, Upper) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(t, uplo::upper())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::upper()),
+                                       uplo::upper())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::upper(),
+                                       diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(t, uplo::upper(),
+                                       diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_unit()),
+                         uplo::upper(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_zero()),
+                         uplo::upper(), diag::explicit_diag())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_unit()),
+                         uplo::upper(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_zero()),
+                         uplo::upper(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  //   Unit or Zero Diag will overwrite the old one
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_unit()),
+                         uplo::upper(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_zero, uplo::upper>>();
+  StaticAssertTypeEq<decltype(triangle(
+                         triangle(t, uplo::upper(), diag::implicit_zero()),
+                         uplo::upper(), diag::implicit_unit())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::implicit_unit, uplo::upper>>();
+  EXPECT_EQ(&(triangle(t, uplo::upper()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_zero()).base()), &t);
+  EXPECT_EQ(&(triangle(t, uplo::upper(), diag::implicit_unit()).base()), &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_zero()),
+                       uplo::upper(), diag::implicit_unit())
+                  .base()),
+            &t);
+  EXPECT_EQ(&(triangle(triangle(t, uplo::upper(), diag::implicit_unit()),
+                       uplo::upper(), diag::implicit_zero())
+                  .base()),
+            &t);
+}
+
+TEST(Tag, MixUpperAndLower) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::upper()),
+                                       uplo::lower())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::diag>>();
+  StaticAssertTypeEq<decltype(triangle(triangle(t, uplo::lower()),
+                                       uplo::upper())),
+                     general<temp&, std::false_type, std::false_type,
+                             diag::explicit_diag, uplo::diag>>();
+}
+
+TEST(Tag, GetTransposeOfUpper) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(transpose(triangle(t, uplo::upper()))),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::upper>>();
+  // Lower(M^T) = Upper(M)^T
+  StaticAssertTypeEq<decltype(triangle(transpose(t), uplo::lower())),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::upper>>();
+}
+
+TEST(Tag, GetTransposeOfLower) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(transpose(triangle(t, uplo::lower()))),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::lower>>();
+  // Upper(M^T) = Lower(M)^T
+  StaticAssertTypeEq<decltype(triangle(transpose(t), uplo::upper())),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::explicit_diag, uplo::lower>>();
+}
+
+TEST(Tag, LongChain) {
+  temp t;
+
+  StaticAssertTypeEq<decltype(triangle(transpose(triangle(t, uplo::lower())),
+                                       uplo::upper(), diag::implicit_zero())),
+                     general<temp&, std::false_type, std::true_type,
+                             diag::implicit_zero, uplo::lower>>();
+  StaticAssertTypeEq<decltype(conjugate(
+                         triangle(transpose(triangle(t, uplo::lower())),
+                                  uplo::lower(), diag::implicit_zero()))),
+                     general<temp&, std::true_type, std::false_type,
+                             diag::implicit_zero, uplo::diag>>();
+  StaticAssertTypeEq<
+      decltype(transpose(conjugate(
+          triangle(transpose(triangle(t, uplo::lower(), diag::implicit_zero())),
+                   uplo::lower(), diag::implicit_unit())))),
+      general<temp&, std::true_type, std::false_type, diag::implicit_unit,
+              uplo::diag>>();
+}
+
+} // namespace