diff --git a/example/cstdfloat_example.cpp b/example/cstdfloat_example.cpp
index 64caa220e..29af3a254 100644
--- a/example/cstdfloat_example.cpp
+++ b/example/cstdfloat_example.cpp
@@ -30,7 +30,6 @@ Dover, New York, 4th ed., (1945), pages 180-188.
 #include <cmath>  // for pow function.
 #include <boost/math/special_functions.hpp> // For gamma function.
 //] [/cstdfloat_example_1]
-#include <boost/type_traits/is_same.hpp>
 
 #include <iostream>
 
diff --git a/example/numerical_derivative_example.cpp b/example/numerical_derivative_example.cpp
index b60f46ba9..6f05c6ba0 100644
--- a/example/numerical_derivative_example.cpp
+++ b/example/numerical_derivative_example.cpp
@@ -10,10 +10,10 @@
 # include <iostream>
 # include <iomanip>
 # include <limits>
+# include <type_traits>
 # include <cmath>
 
 #include <boost/math/tools/assert.hpp>
-#include <boost/type_traits/is_floating_point.hpp> 
 #include <boost/math/special_functions/next.hpp> // for float_distance
 
 //[numeric_derivative_example
diff --git a/example/root_elliptic_finding.cpp b/example/root_elliptic_finding.cpp
index 97cf74e42..28305c77a 100644
--- a/example/root_elliptic_finding.cpp
+++ b/example/root_elliptic_finding.cpp
@@ -16,8 +16,6 @@
 
 #include <boost/cstdlib.hpp>
 #include <boost/config.hpp>
-#include <boost/array.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
 #include <boost/math/tools/roots.hpp>
 #include <boost/math/special_functions/ellint_1.hpp>
 #include <boost/math/special_functions/ellint_2.hpp>
@@ -49,6 +47,7 @@ using boost::multiprecision::cpp_bin_float_50;
 #include <fstream> // std::ofstream
 #include <cmath>
 #include <typeinfo> // for type name using typid(thingy).name();
+#include <type_traits>
 
 #ifdef __FILE__
   std::string sourcefilename = __FILE__;
@@ -477,7 +476,7 @@ int test_root(cpp_bin_float_100 big_radius, cpp_bin_float_100 big_arc, cpp_bin_f
   using boost::timer::cpu_times;
   using boost::timer::cpu_timer;
 
-  long eval_count = boost::is_floating_point<T>::value ? 1000000 : 10000; // To give a sufficiently stable timing for the fast built-in types,
+  long eval_count = std::is_floating_point<T>::value ? 1000000 : 10000; // To give a sufficiently stable timing for the fast built-in types,
   // This takes an inconveniently long time for multiprecision cpp_bin_float_50 etc  types.
 
   cpu_times now; // Holds wall, user and system times.
diff --git a/example/root_finding_algorithms.cpp b/example/root_finding_algorithms.cpp
index df2e68acc..c51439072 100644
--- a/example/root_finding_algorithms.cpp
+++ b/example/root_finding_algorithms.cpp
@@ -15,9 +15,6 @@
 #include <boost/cstdlib.hpp>
 #include <boost/config.hpp>
 #include <boost/array.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
-
 #include "table_type.hpp"
 // Copy of i:\modular-boost\libs\math\test\table_type.hpp
 // #include "handle_test_result.hpp"
@@ -55,6 +52,7 @@ using boost::multiprecision::cpp_bin_float_50;
 #include <fstream> // std::ofstream
 #include <cmath>
 #include <typeinfo> // for type name using typid(thingy).name();
+#include <type_traits>
 
 #ifndef BOOST_ROOT
 # define BOOST_ROOT i:/modular-boost/
@@ -203,7 +201,7 @@ T cbrt_noderiv(T x)
 
   // Maybe guess should be double, or use enable_if to avoid warning about conversion double to float here?
   T guess;
-  if (boost::is_fundamental<T>::value)
+  if (std::is_fundamental<T>::value)
   { 
     int exponent;
     frexp(x, &exponent); // Get exponent of z (ignore mantissa).
@@ -257,7 +255,7 @@ T cbrt_deriv(T x)
   using namespace boost::math::tools;
   int exponent;
   T guess;
-  if(boost::is_fundamental<T>::value)
+  if(std::is_fundamental<T>::value)
   {
      frexp(x, &exponent); // Get exponent of z (ignore mantissa).
      guess = ldexp(static_cast<T>(1), exponent / 3); // Rough guess is to divide the exponent by three.
@@ -301,7 +299,7 @@ T cbrt_2deriv(T x)
   using namespace boost::math::tools;
   int exponent;
   T guess;
-  if(boost::is_fundamental<T>::value)
+  if(std::is_fundamental<T>::value)
   {
      frexp(x, &exponent); // Get exponent of z (ignore mantissa).
      guess = ldexp(static_cast<T>(1), exponent / 3); // Rough guess is to divide the exponent by three.
@@ -328,7 +326,7 @@ T cbrt_2deriv_s(T x)
   using namespace boost::math::tools;
   int exponent;
   T guess;
-  if(boost::is_fundamental<T>::value)
+  if(std::is_fundamental<T>::value)
   {
      frexp(x, &exponent); // Get exponent of z (ignore mantissa).
      guess = ldexp(static_cast<T>(1), exponent / 3); // Rough guess is to divide the exponent by three.
diff --git a/example/root_n_finding_algorithms.cpp b/example/root_n_finding_algorithms.cpp
index 017d6e057..35a1adc78 100644
--- a/example/root_n_finding_algorithms.cpp
+++ b/example/root_n_finding_algorithms.cpp
@@ -16,8 +16,6 @@
 
 #include <boost/cstdlib.hpp>
 #include <boost/config.hpp>
-#include <boost/array.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
 #include <boost/math/concepts/real_concept.hpp>
 #include <boost/math/tools/roots.hpp>
 
@@ -50,6 +48,7 @@ using boost::multiprecision::cpp_bin_float_50;
 #include <fstream> // std::ofstream
 #include <cmath>
 #include <typeinfo> // for type name using typid(thingy).name();
+#include <type_traits>
 
 #ifdef __FILE__
   std::string sourcefilename = __FILE__;
@@ -464,7 +463,7 @@ int test_root(cpp_bin_float_100 big_value, cpp_bin_float_100 answer, const char*
   using boost::timer::cpu_times;
   using boost::timer::cpu_timer;
 
-  int eval_count = boost::is_floating_point<T>::value ? 10000000 : 100000; // To give a sufficiently stable timing for the fast built-in types,
+  int eval_count = std::is_floating_point<T>::value ? 10000000 : 100000; // To give a sufficiently stable timing for the fast built-in types,
   //int eval_count = 1000000; // To give a sufficiently stable timing for the fast built-in types,
   // This takes an inconveniently long time for multiprecision cpp_bin_float_50 etc  types.
 
diff --git a/include/boost/math/distributions/detail/derived_accessors.hpp b/include/boost/math/distributions/detail/derived_accessors.hpp
index e90e7494d..fb2e89dc6 100644
--- a/include/boost/math/distributions/detail/derived_accessors.hpp
+++ b/include/boost/math/distributions/detail/derived_accessors.hpp
@@ -27,7 +27,7 @@
 // can find the definitions referred to herein.
 //
 
-#include <boost/type_traits/is_same.hpp>
+#include <cmath>
 #include <boost/math/tools/assert.hpp>
 
 #ifdef BOOST_MSVC
diff --git a/include/boost/math/distributions/geometric.hpp b/include/boost/math/distributions/geometric.hpp
index 6b2781657..cb59c1b9f 100644
--- a/include/boost/math/distributions/geometric.hpp
+++ b/include/boost/math/distributions/geometric.hpp
@@ -44,10 +44,6 @@
 #include <boost/math/tools/roots.hpp> // for root finding.
 #include <boost/math/distributions/detail/inv_discrete_quantile.hpp>
 
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_same.hpp>
-
 #include <limits> // using std::numeric_limits;
 #include <utility>
 
diff --git a/include/boost/math/distributions/negative_binomial.hpp b/include/boost/math/distributions/negative_binomial.hpp
index 6cb45e479..00cb0e615 100644
--- a/include/boost/math/distributions/negative_binomial.hpp
+++ b/include/boost/math/distributions/negative_binomial.hpp
@@ -52,10 +52,6 @@
 #include <boost/math/tools/roots.hpp> // for root finding.
 #include <boost/math/distributions/detail/inv_discrete_quantile.hpp>
 
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_same.hpp>
-
 #include <limits> // using std::numeric_limits;
 #include <utility>
 
diff --git a/include/boost/math/interpolators/barycentric_rational.hpp b/include/boost/math/interpolators/barycentric_rational.hpp
index 5419c70af..4a2df01b4 100644
--- a/include/boost/math/interpolators/barycentric_rational.hpp
+++ b/include/boost/math/interpolators/barycentric_rational.hpp
@@ -40,7 +40,7 @@ public:
     barycentric_rational(std::vector<Real>&& x, std::vector<Real>&& y, size_t approximation_order = 3);
 
     template <class InputIterator1, class InputIterator2>
-    barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3, typename boost::disable_if_c<boost::is_integral<InputIterator2>::value>::type* = 0);
+    barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3, typename std::enable_if<!std::is_integral<InputIterator2>::value>::type* = 0);
 
     Real operator()(Real x) const;
 
@@ -77,7 +77,7 @@ barycentric_rational<Real>::barycentric_rational(std::vector<Real>&& x, std::vec
 
 template <class Real>
 template <class InputIterator1, class InputIterator2>
-barycentric_rational<Real>::barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order, typename boost::disable_if_c<boost::is_integral<InputIterator2>::value>::type*)
+barycentric_rational<Real>::barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order, typename std::enable_if<!std::is_integral<InputIterator2>::value>::type*)
  : m_imp(std::make_shared<detail::barycentric_rational_imp<Real>>(start_x, end_x, start_y, approximation_order))
 {
 }
diff --git a/include/boost/math/quadrature/detail/tanh_sinh_constants.hpp b/include/boost/math/quadrature/detail/tanh_sinh_constants.hpp
index e9af4a9c5..e4269aff0 100644
--- a/include/boost/math/quadrature/detail/tanh_sinh_constants.hpp
+++ b/include/boost/math/quadrature/detail/tanh_sinh_constants.hpp
@@ -7,7 +7,10 @@
 #ifndef BOOST_MATH_QUADRATURE_DETAIL_TANH_SINH_CONSTANTS_HPP
 #define BOOST_MATH_QUADRATURE_DETAIL_TANH_SINH_CONSTANTS_HPP
 
-#include <boost/type_traits/is_constructible.hpp>
+#include <cmath>
+#include <cstddef>
+#include <vector>
+#include <type_traits>
 #include <boost/lexical_cast.hpp>
 
 namespace boost {
diff --git a/include/boost/math/quaternion.hpp b/include/boost/math/quaternion.hpp
index 7c4e6409c..561e09be9 100644
--- a/include/boost/math/quaternion.hpp
+++ b/include/boost/math/quaternion.hpp
@@ -13,8 +13,6 @@
 #include <boost/config.hpp> // for BOOST_NO_STD_LOCALE
 #include <boost/math_fwd.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/utility/enable_if.hpp>
 #ifndef    BOOST_NO_STD_LOCALE
 #  include <locale>                                    // for the "<<" operator
 #endif /* BOOST_NO_STD_LOCALE */
diff --git a/include/boost/math/special_functions/detail/bessel_jy.hpp b/include/boost/math/special_functions/detail/bessel_jy.hpp
index 529edb4ea..a319760b4 100644
--- a/include/boost/math/special_functions/detail/bessel_jy.hpp
+++ b/include/boost/math/special_functions/detail/bessel_jy.hpp
@@ -20,7 +20,6 @@
 #include <boost/math/special_functions/detail/bessel_jy_series.hpp>
 #include <boost/math/constants/constants.hpp>
 #include <boost/math/policies/error_handling.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
 #include <complex>
 
 // Bessel functions of the first and second kind of fractional order
diff --git a/include/boost/math/special_functions/detail/fp_traits.hpp b/include/boost/math/special_functions/detail/fp_traits.hpp
index b2d3d7ea5..3a69492c1 100644
--- a/include/boost/math/special_functions/detail/fp_traits.hpp
+++ b/include/boost/math/special_functions/detail/fp_traits.hpp
@@ -21,13 +21,12 @@ With these techniques, the code could be simplified.
 #endif
 
 #include <cstring>
+#include <cstdint>
 #include <limits>
-
+#include <type_traits>
 #include <boost/math/tools/assert.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/predef/other/endian.h>
 #include <boost/math/tools/assert.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
 
 #ifdef BOOST_NO_STDC_NAMESPACE
   namespace std{ using ::memcpy; }
@@ -526,7 +525,7 @@ template<> struct size_to_precision<16, true>
 template <class T>
 struct select_native
 {
-    typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
+    typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::std::is_floating_point<T>::value>::type precision;
     typedef fp_traits_non_native<T, precision> type;
 };
 template<>
@@ -564,7 +563,7 @@ struct select_native<long double>
 
 template<class T> struct fp_traits
 {
-    typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
+    typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T), ::std::is_floating_point<T>::value>::type precision;
 #if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
     typedef typename select_native<T>::type type;
 #else
diff --git a/include/boost/math/special_functions/detail/iconv.hpp b/include/boost/math/special_functions/detail/iconv.hpp
index e8fc3723c..90b4aa938 100644
--- a/include/boost/math/special_functions/detail/iconv.hpp
+++ b/include/boost/math/special_functions/detail/iconv.hpp
@@ -10,8 +10,8 @@
 #pragma once
 #endif
 
+#include <type_traits>
 #include <boost/math/special_functions/round.hpp>
-#include <boost/type_traits/is_convertible.hpp>
 
 namespace boost { namespace math { namespace detail{
 
diff --git a/include/boost/math/special_functions/gamma.hpp b/include/boost/math/special_functions/gamma.hpp
index a3919671a..98c775fbb 100644
--- a/include/boost/math/special_functions/gamma.hpp
+++ b/include/boost/math/special_functions/gamma.hpp
@@ -33,11 +33,11 @@
 #include <boost/math/special_functions/detail/lgamma_small.hpp>
 #include <boost/math/special_functions/bernoulli.hpp>
 #include <boost/math/special_functions/polygamma.hpp>
-#include <boost/type_traits/is_convertible.hpp>
 #include <boost/math/tools/assert.hpp>
 
 #include <cmath>
 #include <algorithm>
+#include <type_traits>
 
 #ifdef BOOST_MSVC
 # pragma warning(push)
diff --git a/include/boost/math/special_functions/lambert_w.hpp b/include/boost/math/special_functions/lambert_w.hpp
index 6bf10fb46..86d2842ba 100644
--- a/include/boost/math/special_functions/lambert_w.hpp
+++ b/include/boost/math/special_functions/lambert_w.hpp
@@ -58,7 +58,6 @@ BOOST_MATH_INSTRUMENT_LAMBERT_W_SMALL_Z_SERIES_ITERATIONS  // Show evaluation of
 #include <boost/math/tools/series.hpp> // series functor.
 //#include <boost/math/tools/polynomial.hpp>  // polynomial.
 #include <boost/math/tools/rational.hpp>  // evaluate_polynomial.
-#include <boost/type_traits/is_integral.hpp>
 #include <boost/math/tools/precision.hpp> // boost::math::tools::max_value().
 #include <boost/math/tools/big_constant.hpp>
 #include <boost/math/tools/cxx03_warn.hpp>
@@ -1744,7 +1743,7 @@ T lambert_wm1_imp(const T z, const Policy&  pol)
   // Integral types should be promoted to double by user Lambert w functions.
   // If integral type provided to user function lambert_w0 or lambert_wm1,
   // then should already have been promoted to double.
-  static_assert(!boost::is_integral<T>::value,
+  static_assert(!std::is_integral<T>::value,
     "Must be floating-point or fixed type (not integer type), for example: lambert_wm1(1.), not lambert_wm1(1)!");
 
   BOOST_MATH_STD_USING // Aid argument dependent lookup (ADL) of abs.
diff --git a/include/boost/math/special_functions/next.hpp b/include/boost/math/special_functions/next.hpp
index b4532cec4..32f7988dc 100644
--- a/include/boost/math/special_functions/next.hpp
+++ b/include/boost/math/special_functions/next.hpp
@@ -9,16 +9,16 @@
 #ifdef _MSC_VER
 #pragma once
 #endif
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_integral.hpp>
+
 #include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/policies/error_handling.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/math/special_functions/sign.hpp>
 #include <boost/math/special_functions/trunc.hpp>
 #include <boost/math/tools/traits.hpp>
+#include <type_traits>
+#include <cfloat>
 
-#include <float.h>
 
 #if !defined(_CRAYC) && !defined(__CUDACC__) && (!defined(__GNUC__) || (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 3)))
 #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || defined(__SSE2__)
@@ -684,18 +684,18 @@ inline typename tools::promote_args<T, U>::type float_distance(const T& a, const
    // We allow ONE of a and b to be an integer type, otherwise both must be the SAME type.
    //
    static_assert(
-      (boost::is_same<T, U>::value 
-      || (boost::is_integral<T>::value && !boost::is_integral<U>::value) 
-      || (!boost::is_integral<T>::value && boost::is_integral<U>::value)
+      (std::is_same<T, U>::value 
+      || (std::is_integral<T>::value && !std::is_integral<U>::value) 
+      || (!std::is_integral<T>::value && std::is_integral<U>::value)
       || (std::numeric_limits<T>::is_specialized && std::numeric_limits<U>::is_specialized
          && (std::numeric_limits<T>::digits == std::numeric_limits<U>::digits)
          && (std::numeric_limits<T>::radix == std::numeric_limits<U>::radix)
          && !std::numeric_limits<T>::is_integer && !std::numeric_limits<U>::is_integer)),
       "Float distance between two different floating point types is undefined.");
 
-   BOOST_IF_CONSTEXPR (!boost::is_same<T, U>::value)
+   BOOST_IF_CONSTEXPR (!std::is_same<T, U>::value)
    {
-      BOOST_IF_CONSTEXPR(boost::is_integral<T>::value)
+      BOOST_IF_CONSTEXPR(std::is_integral<T>::value)
       {
          return float_distance(static_cast<U>(a), b, pol);
       }
diff --git a/include/boost/math/special_functions/trunc.hpp b/include/boost/math/special_functions/trunc.hpp
index 401516430..b6c39af85 100644
--- a/include/boost/math/special_functions/trunc.hpp
+++ b/include/boost/math/special_functions/trunc.hpp
@@ -10,12 +10,11 @@
 #pragma once
 #endif
 
+#include <type_traits>
 #include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/tools/config.hpp>
 #include <boost/math/policies/error_handling.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
-#include <boost/type_traits/is_constructible.hpp>
-#include <boost/core/enable_if.hpp>
 
 namespace boost{ namespace math{ namespace detail{
 
@@ -123,7 +122,7 @@ inline typename std::enable_if<std::is_constructible<int, T>::value, int>::type
 }
 
 template <class T, class Policy>
-inline typename boost::disable_if_c<std::is_constructible<int, T>::value, int>::type
+inline typename std::enable_if<!std::is_constructible<int, T>::value, int>::type
    iconvert(const T& v, const Policy& pol) 
 {
    using boost::math::itrunc;
@@ -138,7 +137,7 @@ inline typename std::enable_if<std::is_constructible<long, T>::value, long>::typ
 }
 
 template <class T, class Policy>
-inline typename boost::disable_if_c<std::is_constructible<long, T>::value, long>::type
+inline typename std::enable_if<!std::is_constructible<long, T>::value, long>::type
    lconvert(const T& v, const Policy& pol) 
 {
    using boost::math::ltrunc;
@@ -155,7 +154,7 @@ inline typename std::enable_if<std::is_constructible<boost::long_long_type, T>::
 }
 
 template <class T, class Policy>
-inline typename boost::disable_if_c<std::is_constructible<boost::long_long_type, T>::value, boost::long_long_type>::type
+inline typename std::enable_if<!std::is_constructible<boost::long_long_type, T>::value, boost::long_long_type>::type
    llconvertert(const T& v, const Policy& pol) 
 {
    using boost::math::lltrunc;
diff --git a/include/boost/math/tools/big_constant.hpp b/include/boost/math/tools/big_constant.hpp
index 097bc4790..eeade5d59 100644
--- a/include/boost/math/tools/big_constant.hpp
+++ b/include/boost/math/tools/big_constant.hpp
@@ -11,9 +11,9 @@
 #ifndef BOOST_MATH_NO_LEXICAL_CAST
 #include <boost/lexical_cast.hpp>
 #endif
-#include <boost/type_traits/is_constructible.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
+
+#include <type_traits>
+#include <limits>
 
 namespace boost{ namespace math{ 
 
@@ -73,7 +73,7 @@ inline BOOST_MATH_CONSTEXPR T make_big_value(largest_float, const char* s, std::
       BOOST_STRINGIZE(x), \
       std::integral_constant<bool, (std::is_convertible<boost::math::tools::largest_float, T>::value) && \
       ((D <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits) \
-          || boost::is_floating_point<T>::value \
+          || std::is_floating_point<T>::value \
           || (boost::math::tools::numeric_traits<T>::is_specialized && \
           (boost::math::tools::numeric_traits<T>::digits10 <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits10))) >(), \
       std::is_constructible<T, const char*>())
@@ -82,7 +82,7 @@ inline BOOST_MATH_CONSTEXPR T make_big_value(largest_float, const char* s, std::
 //
 #define BOOST_MATH_HUGE_CONSTANT(T, D, x)\
    boost::math::tools::make_big_value<T>(0.0L, BOOST_STRINGIZE(x), \
-   std::integral_constant<bool, boost::is_floating_point<T>::value || (boost::math::tools::numeric_traits<T>::is_specialized && boost::math::tools::numeric_traits<T>::max_exponent <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::max_exponent && boost::math::tools::numeric_traits<T>::digits <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits)>(), \
+   std::integral_constant<bool, std::is_floating_point<T>::value || (boost::math::tools::numeric_traits<T>::is_specialized && boost::math::tools::numeric_traits<T>::max_exponent <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::max_exponent && boost::math::tools::numeric_traits<T>::digits <= boost::math::tools::numeric_traits<boost::math::tools::largest_float>::digits)>(), \
    std::is_constructible<T, const char*>())
 
 }}} // namespaces
diff --git a/include/boost/math/tools/complex.hpp b/include/boost/math/tools/complex.hpp
index 8bad37445..d462ca809 100644
--- a/include/boost/math/tools/complex.hpp
+++ b/include/boost/math/tools/complex.hpp
@@ -10,17 +10,31 @@
 #ifndef BOOST_MATH_TOOLS_COMPLEX_HPP
 #define BOOST_MATH_TOOLS_COMPLEX_HPP
 
-#include <boost/type_traits/is_complex.hpp>
+#include <utility>
+#include <boost/math/tools/is_detected.hpp>
 
 namespace boost {
    namespace math {
       namespace tools {
 
-         //
-         // Specialize this trait for user-defined complex types (ie Boost.Multiprecision):
-         //
-         template <class T>
-         struct is_complex_type : public boost::is_complex<T> {};
+         namespace detail {
+         template <typename T, typename = void>
+         struct is_complex_type_impl
+         {
+            static constexpr bool value = false;
+         };
+
+         template <typename T>
+         struct is_complex_type_impl<T, void_t<decltype(std::declval<T>().real()), 
+                                               decltype(std::declval<T>().imag())>>
+         {
+            static constexpr bool value = true;
+         };
+         } // Namespace detail
+
+         template <typename T>
+         struct is_complex_type : public detail::is_complex_type_impl<T> {};
+         
          //
          // Use this trait to typecast integer literals to something
          // that will interoperate with T:
diff --git a/include/boost/math/tools/convert_from_string.hpp b/include/boost/math/tools/convert_from_string.hpp
index edc2121ab..de670f520 100644
--- a/include/boost/math/tools/convert_from_string.hpp
+++ b/include/boost/math/tools/convert_from_string.hpp
@@ -10,8 +10,7 @@
 #pragma once
 #endif
 
-#include <boost/type_traits/is_constructible.hpp>
-#include <boost/type_traits/conditional.hpp>
+#include <type_traits>
 #include <boost/lexical_cast.hpp>
 
 namespace boost{ namespace math{ namespace tools{
@@ -19,7 +18,7 @@ namespace boost{ namespace math{ namespace tools{
    template <class T>
    struct convert_from_string_result
    {
-      typedef typename boost::conditional<std::is_constructible<T, const char*>::value, const char*, T>::type type;
+      typedef typename std::conditional<std::is_constructible<T, const char*>::value, const char*, T>::type type;
    };
 
    template <class Real>
diff --git a/include/boost/math/tools/detail/is_const_iterable.hpp b/include/boost/math/tools/detail/is_const_iterable.hpp
index 74d1a4758..0726ce90e 100644
--- a/include/boost/math/tools/detail/is_const_iterable.hpp
+++ b/include/boost/math/tools/detail/is_const_iterable.hpp
@@ -9,11 +9,11 @@
 #include <boost/config.hpp>
 #include <boost/math/tools/cxx03_warn.hpp>
 
-#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_SFINAE_EXPR)
+#if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
 
 #define BOOST_MATH_HAS_IS_CONST_ITERABLE
 
-#include <boost/type_traits/is_detected.hpp>
+#include <boost/math/tools/is_detected.hpp>
 #include <utility>
 
 namespace boost {
@@ -31,9 +31,9 @@ namespace boost {
             template <class T>
             struct is_const_iterable
                : public std::integral_constant<bool,
-               boost::is_detected<begin_t, T>::value
-               && boost::is_detected<end_t, T>::value
-               && boost::is_detected<const_iterator_t, T>::value
+               is_detected<begin_t, T>::value
+               && is_detected<end_t, T>::value
+               && is_detected<const_iterator_t, T>::value
                > {};
 
 } } } }
diff --git a/include/boost/math/tools/polynomial.hpp b/include/boost/math/tools/polynomial.hpp
index 050250012..9a5750bba 100644
--- a/include/boost/math/tools/polynomial.hpp
+++ b/include/boost/math/tools/polynomial.hpp
@@ -26,6 +26,7 @@
 #include <ostream>
 #include <algorithm>
 #include <initializer_list>
+#include <type_traits>
 
 namespace boost{ namespace math{ namespace tools{
 
@@ -122,7 +123,7 @@ namespace detail {
 * subtlety of distinction.
 */
 template <typename T, typename N>
-BOOST_DEDUCED_TYPENAME disable_if_c<std::numeric_limits<T>::is_integer, void >::type
+BOOST_DEDUCED_TYPENAME std::enable_if<!std::numeric_limits<T>::is_integer, void >::type
 division_impl(polynomial<T> &q, polynomial<T> &u, const polynomial<T>& v, N n, N k)
 {
     q[k] = u[n + k] / v[n];
@@ -165,7 +166,7 @@ T integer_power(T t, N n)
 * don't currently have that subtlety of distinction.
 */
 template <typename T, typename N>
-BOOST_DEDUCED_TYPENAME enable_if_c<std::numeric_limits<T>::is_integer, void >::type
+BOOST_DEDUCED_TYPENAME std::enable_if<std::numeric_limits<T>::is_integer, void >::type
 division_impl(polynomial<T> &q, polynomial<T> &u, const polynomial<T>& v, N n, N k)
 {
     q[k] = u[n + k] * integer_power(v[n], k);
diff --git a/include/boost/math/tools/polynomial_gcd.hpp b/include/boost/math/tools/polynomial_gcd.hpp
index 436923589..aa131fb00 100644
--- a/include/boost/math/tools/polynomial_gcd.hpp
+++ b/include/boost/math/tools/polynomial_gcd.hpp
@@ -11,10 +11,10 @@
 #pragma once
 #endif
 
+#include <algorithm>
+#include <type_traits>
 #include <boost/math/tools/polynomial.hpp>
 #include <boost/integer/common_factor_rt.hpp>
-#include <boost/type_traits/is_pod.hpp>
-
 
 namespace boost{
 
@@ -114,7 +114,7 @@ namespace detail
 * @return       Greatest common divisor of polynomials u and v.
 */
 template <class T>
-typename enable_if_c< std::numeric_limits<T>::is_integer, polynomial<T> >::type
+typename std::enable_if< std::numeric_limits<T>::is_integer, polynomial<T> >::type
 subresultant_gcd(polynomial<T> u, polynomial<T> v)
 {
     using std::swap;
@@ -167,14 +167,14 @@ subresultant_gcd(polynomial<T> u, polynomial<T> v)
  * @tparam  T   A multi-precision integral type.
  */
 template <typename T>
-typename enable_if_c<std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_bounded, polynomial<T> >::type
+typename std::enable_if<std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_bounded, polynomial<T> >::type
 gcd(polynomial<T> const &u, polynomial<T> const &v)
 {
     return subresultant_gcd(u, v);
 }
 // GCD over bounded integers is not currently allowed:
 template <typename T>
-typename enable_if_c<std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_bounded, polynomial<T> >::type
+typename std::enable_if<std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_bounded, polynomial<T> >::type
 gcd(polynomial<T> const &u, polynomial<T> const &v)
 {
    static_assert(sizeof(v) == 0, "GCD on polynomials of bounded integers is disallowed due to the excessive growth in the size of intermediate terms.");
@@ -182,7 +182,7 @@ gcd(polynomial<T> const &u, polynomial<T> const &v)
 }
 // GCD over polynomials of floats can go via the Euclid algorithm:
 template <typename T>
-typename enable_if_c<!std::numeric_limits<T>::is_integer && (std::numeric_limits<T>::min_exponent != std::numeric_limits<T>::max_exponent) && !std::numeric_limits<T>::is_exact, polynomial<T> >::type
+typename std::enable_if<!std::numeric_limits<T>::is_integer && (std::numeric_limits<T>::min_exponent != std::numeric_limits<T>::max_exponent) && !std::numeric_limits<T>::is_exact, polynomial<T> >::type
 gcd(polynomial<T> const &u, polynomial<T> const &v)
 {
    return boost::integer::gcd_detail::Euclid_gcd(u, v);
diff --git a/include/boost/math/tools/test_value.hpp b/include/boost/math/tools/test_value.hpp
index 7d4af5d8b..f9948e1eb 100644
--- a/include/boost/math/tools/test_value.hpp
+++ b/include/boost/math/tools/test_value.hpp
@@ -28,8 +28,8 @@
 
 #include <boost/cstdfloat.hpp> // For float_64_t, float128_t. Must be first include!
 #include <boost/lexical_cast.hpp>
-#include <boost/type_traits/is_constructible.hpp>
-#include <boost/type_traits/is_convertible.hpp>
+#include <limits>
+#include <type_traits>
 
 #ifdef BOOST_MATH_INSTRUMENT_CREATE_TEST_VALUE
 // global int create_type(0); must be defined before including this file.
diff --git a/test/compile_test/dist_find_location_incl_test.cpp b/test/compile_test/dist_find_location_incl_test.cpp
index 20aadba15..0e6d958cb 100644
--- a/test/compile_test/dist_find_location_incl_test.cpp
+++ b/test/compile_test/dist_find_location_incl_test.cpp
@@ -6,6 +6,7 @@
 // Basic sanity check that header <boost/math/distributions/find_location.hpp>
 // #includes all the files that it needs to.
 //
+#include <type_traits>
 #include <boost/math/distributions/find_location.hpp>
 //
 // Note this header includes no other headers, this is
@@ -36,8 +37,8 @@ T quantile(const boost::math::complemented2_type<test_distribution<T, Policy>, T
 
 namespace boost{ namespace math{ namespace tools{
 
-   template <class T, class Policy> struct is_distribution<test_distribution<T, Policy> > : public true_type{};
-   template <class T, class Policy> struct is_scaled_distribution<test_distribution<T, Policy> > : public true_type{};
+   template <class T, class Policy> struct is_distribution<test_distribution<T, Policy> > : public std::true_type {};
+   template <class T, class Policy> struct is_scaled_distribution<test_distribution<T, Policy> > : public std::true_type {};
 
 }}}
 
diff --git a/test/compile_test/dist_find_scale_incl_test.cpp b/test/compile_test/dist_find_scale_incl_test.cpp
index 5481e210d..f7e2eea94 100644
--- a/test/compile_test/dist_find_scale_incl_test.cpp
+++ b/test/compile_test/dist_find_scale_incl_test.cpp
@@ -36,8 +36,8 @@ T quantile(const boost::math::complemented2_type<test_distribution<T, Policy>, T
 
 namespace boost{ namespace math{ namespace tools{
 
-   template <class T, class Policy> struct is_distribution<test_distribution<T, Policy> > : public true_type{};
-   template <class T, class Policy> struct is_scaled_distribution<test_distribution<T, Policy> > : public true_type{};
+   template <class T, class Policy> struct is_distribution<test_distribution<T, Policy> > : public std::true_type {};
+   template <class T, class Policy> struct is_scaled_distribution<test_distribution<T, Policy> > : public std::true_type {};
 
 }}}