diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 79fd5bb6d6..ca46d0a419 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -26,6 +26,7 @@
 set(TILEDARRAY_HEADER_FILES
 tiledarray.h
 tiledarray_fwd.h
+TiledArray/fwd.h
 TiledArray/config.h
 TiledArray/array_impl.h
 TiledArray/bitset.h
@@ -98,6 +99,7 @@ TiledArray/expressions/contraction_helpers.h
 TiledArray/expressions/expr.h
 TiledArray/expressions/expr_engine.h
 TiledArray/expressions/expr_trace.h
+TiledArray/expressions/fwd.h
 TiledArray/expressions/leaf_engine.h
 TiledArray/expressions/mult_engine.h
 TiledArray/expressions/mult_expr.h
@@ -177,7 +179,6 @@ TiledArray/util/random.h
 TiledArray/util/singleton.h
 TiledArray/util/time.h
 TiledArray/util/vector.h
-
 )
 
 if(CUDA_FOUND)
diff --git a/src/TiledArray/dist_array.h b/src/TiledArray/dist_array.h
index 7a1d90393a..7931db27ed 100644
--- a/src/TiledArray/dist_array.h
+++ b/src/TiledArray/dist_array.h
@@ -20,9 +20,7 @@
 #ifndef TILEDARRAY_ARRAY_H__INCLUDED
 #define TILEDARRAY_ARRAY_H__INCLUDED
 
-#include <cstdlib>
-
-#include <madness/world/parallel_archive.h>
+#include "TiledArray/expressions/fwd.h"
 
 #include "TiledArray/array_impl.h"
 #include "TiledArray/conversions/clone.h"
@@ -35,15 +33,14 @@
 #include "TiledArray/util/initializer_list.h"
 #include "TiledArray/util/random.h"
 
+#include <cstdlib>
+#include <madness/world/parallel_archive.h>
+
 namespace TiledArray {
 
 // Forward declarations
 template <typename, typename>
 class Tensor;
-namespace expressions {
-template <typename, bool>
-class TsrExpr;
-}  // namespace expressions
 
 /// A (multidimensional) tiled array
 
@@ -56,7 +53,6 @@ template <typename Tile = Tensor<double, Eigen::aligned_allocator<double>>,
           typename Policy = DensePolicy>
 class DistArray : public madness::archive::ParallelSerializableObject {
  public:
-  typedef DistArray<Tile, Policy> DistArray_;  ///< This object's type
   typedef TiledArray::detail::ArrayImpl<Tile, Policy>
       impl_type;  ///< The type of the PIMPL
   typedef typename impl_type::policy_type policy_type;  ///< Policy type
@@ -107,7 +103,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
   /// used elsewhere too.
   ///
   template <typename OtherTile>
-  using is_my_type = std::is_same<DistArray_, DistArray<OtherTile, Policy>>;
+  using is_my_type = std::is_same<DistArray, DistArray<OtherTile, Policy>>;
 
   template <typename OtherTile>
   using enable_if_not_my_type =
@@ -149,7 +145,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
         try {
           world.gop.lazy_sync(id, [pimpl]() {
             delete pimpl;
-            DistArray_::cleanup_counter_--;
+            DistArray::cleanup_counter_--;
           });
         } catch (madness::MadnessException& e) {
           fprintf(stderr,
@@ -245,7 +241,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
 
   /// This is a shallow copy, that is no data is copied.
   /// \param other The array to be copied
-  DistArray(const DistArray_& other) : pimpl_(other.pimpl_) {}
+  DistArray(const DistArray& other) : pimpl_(other.pimpl_) {}
 
   /// Dense array constructor
 
@@ -301,27 +297,27 @@ class DistArray : public madness::archive::ParallelSerializableObject {
   ///                              raised \p world and \p il are unchanged.
   template <typename T>
   DistArray(World& world, detail::vector_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, il)) {}
+      : DistArray(array_from_il<DistArray>(world, il)) {}
 
   template <typename T>
   DistArray(World& world, detail::matrix_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, il)) {}
+      : DistArray(array_from_il<DistArray>(world, il)) {}
 
   template <typename T>
   DistArray(World& world, detail::tensor3_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, il)) {}
+      : DistArray(array_from_il<DistArray>(world, il)) {}
 
   template <typename T>
   DistArray(World& world, detail::tensor4_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, il)) {}
+      : DistArray(array_from_il<DistArray>(world, il)) {}
 
   template <typename T>
   DistArray(World& world, detail::tensor5_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, il)) {}
+      : DistArray(array_from_il<DistArray>(world, il)) {}
 
   template <typename T>
   DistArray(World& world, detail::tensor6_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, il)) {}
+      : DistArray(array_from_il<DistArray>(world, il)) {}
   ///@}
 
   /// \name Tiling initializer list constructors
@@ -352,27 +348,27 @@ class DistArray : public madness::archive::ParallelSerializableObject {
   ///                              raised \p world and \p il are unchanged.
   template <typename T>
   DistArray(World& world, const trange_type& trange, detail::vector_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, trange, il)) {}
+      : DistArray(array_from_il<DistArray>(world, trange, il)) {}
 
   template <typename T>
   DistArray(World& world, const trange_type& trange, detail::matrix_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, trange, il)) {}
+      : DistArray(array_from_il<DistArray>(world, trange, il)) {}
 
   template <typename T>
   DistArray(World& world, const trange_type& trange, detail::tensor3_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, trange, il)) {}
+      : DistArray(array_from_il<DistArray>(world, trange, il)) {}
 
   template <typename T>
   DistArray(World& world, const trange_type& trange, detail::tensor4_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, trange, il)) {}
+      : DistArray(array_from_il<DistArray>(world, trange, il)) {}
 
   template <typename T>
   DistArray(World& world, const trange_type& trange, detail::tensor5_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, trange, il)) {}
+      : DistArray(array_from_il<DistArray>(world, trange, il)) {}
 
   template <typename T>
   DistArray(World& world, const trange_type& trange, detail::tensor6_il<T> il)
-      : DistArray(array_from_il<DistArray_>(world, trange, il)) {}
+      : DistArray(array_from_il<DistArray>(world, trange, il)) {}
   /// @}
 
   /// converting copy constructor
@@ -410,7 +406,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
   /// Create a deep copy of this array
 
   /// \return An array that is equal to this array
-  DistArray_ clone() const { return TiledArray::clone(*this); }
+  DistArray clone() const { return TiledArray::clone(*this); }
 
   /// Accessor for the (shared_ptr to) implementation object
 
@@ -462,7 +458,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
 
   /// This is a shallow copy, that is no data is copied.
   /// \param other The array to be copied
-  DistArray_& operator=(const DistArray_& other) {
+  DistArray& operator=(const DistArray& other) {
     pimpl_ = other.pimpl_;
 
     return *this;
@@ -977,10 +973,9 @@ class DistArray : public madness::archive::ParallelSerializableObject {
   /// \return A const tensor expression object
   /// \note size and contents of \p vars are validated using
   ///   DistArray::check_str_index()
-  TiledArray::expressions::TsrExpr<const DistArray_, true> operator()(
-      const std::string& vars) const {
+  auto operator()(const std::string& vars) const {
     check_str_index(vars);
-    return TiledArray::expressions::TsrExpr<const DistArray_, true>(*this,
+    return TiledArray::expressions::TsrExpr<const DistArray>(*this,
                                                                     vars);
   }
 
@@ -990,10 +985,9 @@ class DistArray : public madness::archive::ParallelSerializableObject {
   /// \return A non-const tensor expression object
   /// \note size and contents of \p vars are validated using
   ///   DistArray::check_str_index()
-  TiledArray::expressions::TsrExpr<DistArray_, true> operator()(
-      const std::string& vars) {
+  auto operator()(const std::string& vars) {
     check_str_index(vars);
-    return TiledArray::expressions::TsrExpr<DistArray_, true>(*this, vars);
+    return TiledArray::expressions::TsrExpr<DistArray>(*this, vars);
   }
 
   /// \deprecated use DistArray::world()
@@ -1161,7 +1155,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
 
   /// \param other The array to be swapped with this array.
   /// \throw None no throw guarantee.
-  void swap(DistArray_& other) { std::swap(pimpl_, other.pimpl_); }
+  void swap(DistArray& other) { std::swap(pimpl_, other.pimpl_); }
 
   /// Convert a distributed array into a replicated array
   /// \throw TiledArray::Exception if the PIMPL is not initialized. Strong throw
@@ -1170,19 +1164,19 @@ class DistArray : public madness::archive::ParallelSerializableObject {
     if ((!impl_ref().pmap()->is_replicated()) && (world().size() > 1)) {
       // Construct a replicated array
       auto pmap = std::make_shared<detail::ReplicatedPmap>(world(), size());
-      DistArray_ result = DistArray_(world(), trange(), shape(), pmap);
+      DistArray result = DistArray(world(), trange(), shape(), pmap);
 
       // Create the replicator object that will do an all-to-all broadcast of
       // the local tile data.
       auto replicator =
-          std::make_shared<detail::Replicator<DistArray_>>(*this, result);
+          std::make_shared<detail::Replicator<DistArray>>(*this, result);
 
       // Put the replicator pointer in the deferred cleanup object so it will
       // be deleted at the end of the next fence.
       TA_ASSERT(replicator.unique());  // Required for deferred_cleanup
       madness::detail::deferred_cleanup(world(), replicator);
 
-      DistArray_::operator=(result);
+      DistArray::operator=(result);
     }
   }
 
@@ -1264,7 +1258,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
 
     // use default pmap, ensure it's the same pmap used to serialize
     auto volume = trange.tiles_range().volume();
-    auto pmap = detail::policy_t<DistArray_>::default_pmap(world, volume);
+    auto pmap = detail::policy_t<DistArray>::default_pmap(world, volume);
     size_t pmap_hash_code = 0;
     ar& pmap_hash_code;
     if (pmap_hash_code != typeid(pmap.get()).hash_code())
@@ -1337,7 +1331,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
 
       // use default pmap
       auto volume = trange.tiles_range().volume();
-      auto pmap = detail::policy_t<DistArray_>::default_pmap(world, volume);
+      auto pmap = detail::policy_t<DistArray>::default_pmap(world, volume);
       pimpl_.reset(
           new impl_type(world, std::move(trange), std::move(shape), pmap));
 
@@ -1371,7 +1365,7 @@ class DistArray : public madness::archive::ParallelSerializableObject {
 
       // use default pmap
       auto volume = trange.tiles_range().volume();
-      auto pmap = detail::policy_t<DistArray_>::default_pmap(world, volume);
+      auto pmap = detail::policy_t<DistArray>::default_pmap(world, volume);
       pimpl_.reset(
           new impl_type(world, std::move(trange), std::move(shape), pmap));
     }
diff --git a/src/TiledArray/expressions/blk_tsr_engine.h b/src/TiledArray/expressions/blk_tsr_engine.h
index 7393e462a6..5157ccac09 100644
--- a/src/TiledArray/expressions/blk_tsr_engine.h
+++ b/src/TiledArray/expressions/blk_tsr_engine.h
@@ -26,6 +26,7 @@
 #ifndef TILEDARRAY_EXPRESSIONS_BLK_TSR_ENGINE_H__INCLUDED
 #define TILEDARRAY_EXPRESSIONS_BLK_TSR_ENGINE_H__INCLUDED
 
+#include <TiledArray/expressions/fwd.h>
 #include <TiledArray/expressions/leaf_engine.h>
 #include <TiledArray/tile_op/shift.h>
 
@@ -37,16 +38,6 @@ class DistArray;
 
 namespace expressions {
 
-// Forward declaration
-template <typename, bool>
-class BlkTsrExpr;
-template <typename, typename>
-class ScalBlkTsrExpr;
-template <typename, typename, bool>
-class BlkTsrEngine;
-template <typename, typename, typename>
-class ScalBlkTsrEngine;
-
 template <typename Tile, typename Policy, typename Result, bool Alias>
 struct EngineTrait<BlkTsrEngine<DistArray<Tile, Policy>, Result, Alias>> {
   // Argument typedefs
diff --git a/src/TiledArray/expressions/blk_tsr_expr.h b/src/TiledArray/expressions/blk_tsr_expr.h
index a5bf1f4884..e2680559b5 100644
--- a/src/TiledArray/expressions/blk_tsr_expr.h
+++ b/src/TiledArray/expressions/blk_tsr_expr.h
@@ -35,14 +35,6 @@
 namespace TiledArray {
 namespace expressions {
 
-// Forward declaration
-template <typename, bool>
-class TsrExpr;
-template <typename, bool>
-class BlkTsrExpr;
-template <typename, typename>
-class ScalBlkTsrExpr;
-
 template <typename Array>
 using ConjBlkTsrExpr =
     ScalBlkTsrExpr<Array, TiledArray::detail::ComplexConjugate<void>>;
diff --git a/src/TiledArray/expressions/expr.h b/src/TiledArray/expressions/expr.h
index fbe6e314b5..ccb562591c 100644
--- a/src/TiledArray/expressions/expr.h
+++ b/src/TiledArray/expressions/expr.h
@@ -26,6 +26,9 @@
 #ifndef TILEDARRAY_EXPRESSIONS_EXPR_H__INCLUDED
 #define TILEDARRAY_EXPRESSIONS_EXPR_H__INCLUDED
 
+#include "TiledArray/expressions/fwd.h"
+
+
 #include "../reduce_task.h"
 #include "../tile_interface/cast.h"
 #include "../tile_interface/scale.h"
@@ -45,18 +48,7 @@
 
 #include <TiledArray/tensor/type_traits.h>
 
-namespace TiledArray {
-namespace expressions {
-
-// Forward declaration
-template <typename>
-struct ExprTrait;
-template <typename, bool>
-class TsrExpr;
-template <typename, bool>
-class BlkTsrExpr;
-template <typename>
-struct is_aliased;
+namespace TiledArray::expressions {
 
 template <typename Engine>
 struct EngineParamOverride {
@@ -881,7 +873,6 @@ class Expr {
 
 };  // class Expr
 
-}  // namespace expressions
-}  // namespace TiledArray
+}
 
 #endif  // TILEDARRAY_EXPRESSIONS_EXPR_H__INCLUDED
diff --git a/src/TiledArray/expressions/expr_trace.h b/src/TiledArray/expressions/expr_trace.h
index bf337832a0..e9010ea6d7 100644
--- a/src/TiledArray/expressions/expr_trace.h
+++ b/src/TiledArray/expressions/expr_trace.h
@@ -26,17 +26,13 @@
 #ifndef TILEDARRAY_EXPR_TRACE_H__INCLUDED
 #define TILEDARRAY_EXPR_TRACE_H__INCLUDED
 
+#include <TiledArray/expressions/fwd.h>
 #include <TiledArray/expressions/index_list.h>
 #include <iostream>
 
 namespace TiledArray {
 namespace expressions {
 
-template <typename>
-class Expr;
-template <typename, bool>
-class TsrExpr;
-
 /// Expression output stream
 class ExprOStream {
   std::ostream& os_;  ///< output stream
diff --git a/src/TiledArray/expressions/fwd.h b/src/TiledArray/expressions/fwd.h
new file mode 100644
index 0000000000..7960baf648
--- /dev/null
+++ b/src/TiledArray/expressions/fwd.h
@@ -0,0 +1,73 @@
+/*
+ *  This file is a part of TiledArray.
+ *  Copyright (C) 2013  Virginia Tech
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Justus Calvin
+ *  Department of Chemistry, Virginia Tech
+ *
+ *  expr.h
+ *  Apr 1, 2014
+ *
+ */
+
+#ifndef TILEDARRAY_EXPRESSIONS_FWD_H__INCLUDED
+#define TILEDARRAY_EXPRESSIONS_FWD_H__INCLUDED
+
+#include <type_traits>
+
+
+namespace TiledArray::expressions {
+
+template <typename>
+class Expr;
+
+template <typename, bool Alias = true>
+class TsrExpr;
+
+template <typename, bool>
+class BlkTsrExpr;
+
+template <typename, typename>
+class ScalBlkTsrExpr;
+
+template <typename>
+struct is_aliased : std::true_type {};
+
+template <typename Array>
+struct is_aliased<TsrExpr<Array, false>> : std::false_type {};
+
+// Forward declaration
+template <typename>
+struct ExprTrait;
+
+template <typename, typename, bool>
+class TsrEngine;
+
+template <typename, typename, bool>
+class BlkTsrEngine;
+
+template <typename, typename, typename>
+class ScalBlkTsrEngine;
+
+template <typename, typename>
+class ScalTsrExpr;
+
+template <typename, typename, typename>
+class ScalTsrEngine;
+
+}  // namespace TiledArray
+
+#endif  // TILEDARRAY_EXPRESSIONS_FWD_H__INCLUDED
diff --git a/src/TiledArray/expressions/scal_tsr_engine.h b/src/TiledArray/expressions/scal_tsr_engine.h
index 0d9aa66e7f..6bb75204cf 100644
--- a/src/TiledArray/expressions/scal_tsr_engine.h
+++ b/src/TiledArray/expressions/scal_tsr_engine.h
@@ -26,6 +26,7 @@
 #ifndef TILEDARRAY_EXPRESSIONS_SCAL_TSR_ENGINE_H__INCLUDED
 #define TILEDARRAY_EXPRESSIONS_SCAL_TSR_ENGINE_H__INCLUDED
 
+#include <TiledArray/expressions/fwd.h>
 #include <TiledArray/expressions/leaf_engine.h>
 #include <TiledArray/tile_op/scal.h>
 #include <TiledArray/tile_op/unary_wrapper.h>
@@ -33,11 +34,6 @@
 namespace TiledArray {
 namespace expressions {
 
-template <typename, typename>
-class ScalTsrExpr;
-template <typename, typename, typename>
-class ScalTsrEngine;
-
 template <typename Tile, typename Policy, typename Scalar, typename Result>
 struct EngineTrait<ScalTsrEngine<DistArray<Tile, Policy>, Scalar, Result>> {
   // Argument typedefs
diff --git a/src/TiledArray/expressions/scal_tsr_expr.h b/src/TiledArray/expressions/scal_tsr_expr.h
index f1bed83fc0..ba7b96bf3e 100644
--- a/src/TiledArray/expressions/scal_tsr_expr.h
+++ b/src/TiledArray/expressions/scal_tsr_expr.h
@@ -128,7 +128,7 @@ template <typename Array, typename Scalar,
           typename std::enable_if<
               TiledArray::detail::is_numeric_v<Scalar> >::type* = nullptr>
 inline ScalTsrExpr<typename std::remove_const<Array>::type, Scalar> operator*(
-    const TsrExpr<Array, true>& expr, const Scalar& factor) {
+    const TsrExpr<Array>& expr, const Scalar& factor) {
   return ScalTsrExpr<typename std::remove_const<Array>::type, Scalar>(
       expr.array(), expr.annotation(), factor);
 }
@@ -144,7 +144,7 @@ template <typename Array, typename Scalar,
           typename std::enable_if<
               TiledArray::detail::is_numeric_v<Scalar> >::type* = nullptr>
 inline ScalTsrExpr<typename std::remove_const<Array>::type, Scalar> operator*(
-    const Scalar& factor, const TsrExpr<Array, true>& expr) {
+    const Scalar& factor, const TsrExpr<Array>& expr) {
   return ScalTsrExpr<typename std::remove_const<Array>::type, Scalar>(
       expr.array(), expr.annotation(), factor);
 }
@@ -190,10 +190,10 @@ inline ScalTsrExpr<Array, mult_t<Scalar2, Scalar1> > operator*(
 /// \return A scaled-tensor expression object
 template <typename Array>
 inline ScalTsrExpr<typename std::remove_const<Array>::type,
-                   typename ExprTrait<TsrExpr<Array, true> >::numeric_type>
-operator-(const TsrExpr<Array, true>& expr) {
+                   typename ExprTrait<TsrExpr<Array> >::numeric_type>
+operator-(const TsrExpr<Array>& expr) {
   return ScalTsrExpr<typename std::remove_const<Array>::type,
-                     typename ExprTrait<TsrExpr<Array, true> >::numeric_type>(
+                     typename ExprTrait<TsrExpr<Array> >::numeric_type>(
       expr.array(), expr.annotation(), -1);
 }
 
@@ -217,7 +217,7 @@ inline ScalTsrExpr<Array, Scalar> operator-(
 /// \return A conjugated expression object
 template <typename Array>
 inline ConjTsrExpr<typename std::remove_const<Array>::type> conj(
-    const TsrExpr<Array, true>& expr) {
+    const TsrExpr<Array>& expr) {
   return ConjTsrExpr<typename std::remove_const<Array>::type>(
       expr.array(), expr.annotation(), conj_op());
 }
@@ -228,8 +228,8 @@ inline ConjTsrExpr<typename std::remove_const<Array>::type> conj(
 /// \param expr The tensor expression object
 /// \return A tensor expression object
 template <typename Array>
-inline TsrExpr<const Array, true> conj(const ConjTsrExpr<Array>& expr) {
-  return TsrExpr<const Array, true>(expr.array(), expr.annotation());
+inline TsrExpr<const Array> conj(const ConjTsrExpr<Array>& expr) {
+  return TsrExpr<const Array>(expr.array(), expr.annotation());
 }
 
 /// Conjugated-tensor expression factor
diff --git a/src/TiledArray/expressions/tsr_engine.h b/src/TiledArray/expressions/tsr_engine.h
index 1b51b1c9cd..5219af37ca 100644
--- a/src/TiledArray/expressions/tsr_engine.h
+++ b/src/TiledArray/expressions/tsr_engine.h
@@ -38,12 +38,6 @@ class DistArray;
 
 namespace expressions {
 
-// Forward declaration
-template <typename, bool>
-class TsrExpr;
-template <typename, typename, bool>
-class TsrEngine;
-
 template <typename Tile, typename Policy, typename Result, bool Alias>
 struct EngineTrait<TsrEngine<DistArray<Tile, Policy>, Result, Alias>> {
   // Argument typedefs
diff --git a/src/TiledArray/expressions/tsr_expr.h b/src/TiledArray/expressions/tsr_expr.h
index bfc5cf7546..e2b57b6524 100644
--- a/src/TiledArray/expressions/tsr_expr.h
+++ b/src/TiledArray/expressions/tsr_expr.h
@@ -39,13 +39,6 @@ namespace expressions {
 using TiledArray::detail::numeric_t;
 using TiledArray::detail::scalar_t;
 
-template <typename E>
-struct is_aliased : public std::true_type {};
-
-template <typename Array, bool Alias>
-struct is_aliased<TsrExpr<Array, Alias>>
-    : public std::integral_constant<bool, Alias> {};
-
 template <typename Array, bool Alias>
 struct ExprTrait<TsrExpr<Array, Alias>> {
   typedef Array array_type;  ///< The \c Array type
diff --git a/src/TiledArray/fwd.h b/src/TiledArray/fwd.h
new file mode 100644
index 0000000000..3863ad6d7e
--- /dev/null
+++ b/src/TiledArray/fwd.h
@@ -0,0 +1,131 @@
+/*
+ *  This file is a part of TiledArray.
+ *  Copyright (C) 2014  Virginia Tech
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TILEDARRAY_FWD_H__INCLUDED
+#define TILEDARRAY_FWD_H__INCLUDED
+
+#include <TiledArray/config.h>
+
+#include <btas/fwd.h>
+#include <complex>
+
+namespace Eigen {  // fwd define Eigen's aligned allocator for
+                   // TiledArray::Tensor
+template <class>
+class aligned_allocator;
+}  // namespace Eigen
+
+namespace madness {
+  class World;
+}
+
+namespace TiledArray {
+
+using madness::World;
+World& get_default_world();
+
+// Ranges
+class Range;
+class TiledRange1;
+class TiledRange;
+
+// TiledArray Policy
+class DensePolicy;
+class SparsePolicy;
+
+// TiledArray Tensors
+template <typename, typename>
+class Tensor;
+
+typedef Tensor<double, Eigen::aligned_allocator<double> > TensorD;
+typedef Tensor<int, Eigen::aligned_allocator<int> > TensorI;
+typedef Tensor<float, Eigen::aligned_allocator<float> > TensorF;
+typedef Tensor<long, Eigen::aligned_allocator<long> > TensorL;
+typedef Tensor<std::complex<double>,
+               Eigen::aligned_allocator<std::complex<double> > >
+    TensorZ;
+typedef Tensor<std::complex<float>,
+               Eigen::aligned_allocator<std::complex<float> > >
+    TensorC;
+
+// CUDA tensor
+#ifdef TILEDARRAY_HAS_CUDA
+
+template <class T>
+class cuda_um_allocator_impl;
+
+template <typename T, typename A = std::allocator<T>>
+class default_init_allocator;
+
+template <typename T>
+using cuda_um_allocator = default_init_allocator<T, cuda_um_allocator_impl<T>>;
+
+/// \brief a vector that lives in CUDA Unified Memory, with most operations
+/// implemented on the CPU
+template <typename T>
+using cuda_um_btas_varray = ::btas::varray<T, TiledArray::cuda_um_allocator<T>>;
+
+/**
+ * btas::Tensor with UM storage cuda_um_btas_varray
+ */
+template <typename T, typename Range = TiledArray::Range>
+using btasUMTensorVarray =
+    ::btas::Tensor<T, Range, TiledArray::cuda_um_btas_varray<T>>;
+
+#endif
+
+// TiledArray Arrays
+template <typename, typename>
+class DistArray;
+
+// Dense Array Typedefs
+template <typename T>
+using TArray = DistArray<Tensor<T, Eigen::aligned_allocator<T> >, DensePolicy>;
+typedef TArray<double> TArrayD;
+typedef TArray<int> TArrayI;
+typedef TArray<float> TArrayF;
+typedef TArray<long> TArrayL;
+typedef TArray<std::complex<double> > TArrayZ;
+typedef TArray<std::complex<float> > TArrayC;
+
+// Sparse Array Typedefs
+template <typename T>
+using TSpArray =
+    DistArray<Tensor<T, Eigen::aligned_allocator<T> >, SparsePolicy>;
+typedef TSpArray<double> TSpArrayD;
+typedef TSpArray<int> TSpArrayI;
+typedef TSpArray<float> TSpArrayF;
+typedef TSpArray<long> TSpArrayL;
+typedef TSpArray<std::complex<double> > TSpArrayZ;
+typedef TSpArray<std::complex<float> > TSpArrayC;
+
+// type alias for backward compatibility: the old Array has static type,
+// DistArray is rank-polymorphic
+template <typename T, unsigned int = 0,
+          typename Tile = Tensor<T, Eigen::aligned_allocator<T> >,
+          typename Policy = DensePolicy>
+using Array = DistArray<Tile, Policy>;
+
+}  // namespace TiledArray
+
+#ifndef TILEDARRAY_DISABLE_NAMESPACE_TA
+namespace TA = TiledArray;
+#endif  // TILEDARRAY_DISABLE_NAMESPACE_TA
+
+#endif  // TILEDARRAY_FWD_H__INCLUDED
diff --git a/src/tiledarray_fwd.h b/src/tiledarray_fwd.h
index af41f63c6f..2bb10ed659 100644
--- a/src/tiledarray_fwd.h
+++ b/src/tiledarray_fwd.h
@@ -1,125 +1 @@
-/*
- *  This file is a part of TiledArray.
- *  Copyright (C) 2014  Virginia Tech
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef TILEDARRAY_FWD_H__INCLUDED
-#define TILEDARRAY_FWD_H__INCLUDED
-
-#include <complex>
-
-#include <btas/fwd.h>
-
-#include <TiledArray/config.h>
-
-namespace Eigen {  // fwd define Eigen's aligned allocator for
-                   // TiledArray::Tensor
-template <class>
-class aligned_allocator;
-}  // namespace Eigen
-
-namespace TiledArray {
-
-// Ranges
-class Range;
-class TiledRange1;
-class TiledRange;
-
-// TiledArray Policy
-class DensePolicy;
-class SparsePolicy;
-
-// TiledArray Tensors
-template <typename, typename>
-class Tensor;
-
-typedef Tensor<double, Eigen::aligned_allocator<double> > TensorD;
-typedef Tensor<int, Eigen::aligned_allocator<int> > TensorI;
-typedef Tensor<float, Eigen::aligned_allocator<float> > TensorF;
-typedef Tensor<long, Eigen::aligned_allocator<long> > TensorL;
-typedef Tensor<std::complex<double>,
-               Eigen::aligned_allocator<std::complex<double> > >
-    TensorZ;
-typedef Tensor<std::complex<float>,
-               Eigen::aligned_allocator<std::complex<float> > >
-    TensorC;
-
-// CUDA tensor
-#ifdef TILEDARRAY_HAS_CUDA
-
-template <class T>
-class cuda_um_allocator_impl;
-
-template <typename T, typename A = std::allocator<T>>
-class default_init_allocator;
-
-template <typename T>
-using cuda_um_allocator = default_init_allocator<T, cuda_um_allocator_impl<T>>;
-
-/// \brief a vector that lives in CUDA Unified Memory, with most operations
-/// implemented on the CPU
-template <typename T>
-using cuda_um_btas_varray = ::btas::varray<T, TiledArray::cuda_um_allocator<T>>;
-
-/**
- * btas::Tensor with UM storage cuda_um_btas_varray
- */
-template <typename T, typename Range = TiledArray::Range>
-using btasUMTensorVarray =
-    ::btas::Tensor<T, Range, TiledArray::cuda_um_btas_varray<T>>;
-
-#endif
-
-// TiledArray Arrays
-template <typename, typename>
-class DistArray;
-
-// Dense Array Typedefs
-template <typename T>
-using TArray = DistArray<Tensor<T, Eigen::aligned_allocator<T> >, DensePolicy>;
-typedef TArray<double> TArrayD;
-typedef TArray<int> TArrayI;
-typedef TArray<float> TArrayF;
-typedef TArray<long> TArrayL;
-typedef TArray<std::complex<double> > TArrayZ;
-typedef TArray<std::complex<float> > TArrayC;
-
-// Sparse Array Typedefs
-template <typename T>
-using TSpArray =
-    DistArray<Tensor<T, Eigen::aligned_allocator<T> >, SparsePolicy>;
-typedef TSpArray<double> TSpArrayD;
-typedef TSpArray<int> TSpArrayI;
-typedef TSpArray<float> TSpArrayF;
-typedef TSpArray<long> TSpArrayL;
-typedef TSpArray<std::complex<double> > TSpArrayZ;
-typedef TSpArray<std::complex<float> > TSpArrayC;
-
-// type alias for backward compatibility: the old Array has static type,
-// DistArray is rank-polymorphic
-template <typename T, unsigned int = 0,
-          typename Tile = Tensor<T, Eigen::aligned_allocator<T> >,
-          typename Policy = DensePolicy>
-using Array = DistArray<Tile, Policy>;
-
-}  // namespace TiledArray
-
-#ifndef TILEDARRAY_DISABLE_NAMESPACE_TA
-namespace TA = TiledArray;
-#endif  // TILEDARRAY_DISABLE_NAMESPACE_TA
-
-#endif  // TILEDARRAY_FWD_H__INCLUDED
+#include <TiledArray/fwd.h>
diff --git a/tests/tot_dist_array_part1.cpp b/tests/tot_dist_array_part1.cpp
index 8f1f36d199..e71392ef8c 100644
--- a/tests/tot_dist_array_part1.cpp
+++ b/tests/tot_dist_array_part1.cpp
@@ -24,11 +24,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(typedefs, TestParam, test_params) {
   using tensor_t = tensor_type<TestParam>;
 
   //------------ Actual type checks start here -------------------------
-  {
-    constexpr bool is_same =
-        std::is_same_v<typename tensor_t::DistArray_, tensor_t>;
-    BOOST_TEST(is_same);
-  }
 
   {
     using corr_impl_type = detail::ArrayImpl<tile_type, policy_type>;