diff --git a/stan/math/fwd/fun/Phi.hpp b/stan/math/fwd/fun/Phi.hpp
index 5fe92943ef1..70c1c38249e 100644
--- a/stan/math/fwd/fun/Phi.hpp
+++ b/stan/math/fwd/fun/Phi.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/pow.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/Phi.hpp>
 #include <cmath>
@@ -12,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> Phi(const fvar<T>& x) {
-  using std::exp;
-  using std::sqrt;
   T xv = x.val_;
   return fvar<T>(Phi(xv), x.d_ * exp(xv * xv / -2.0) * INV_SQRT_TWO_PI);
 }
diff --git a/stan/math/fwd/fun/Phi_approx.hpp b/stan/math/fwd/fun/Phi_approx.hpp
index 582a9113d3a..2509a44348a 100644
--- a/stan/math/fwd/fun/Phi_approx.hpp
+++ b/stan/math/fwd/fun/Phi_approx.hpp
@@ -3,7 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
+#include <stan/math/fwd/fun/pow.hpp>
+#include <stan/math/prim/fun/Phi_approx.hpp>
 #include <cmath>
 
 namespace stan {
@@ -21,7 +23,6 @@ namespace math {
  */
 template <typename T>
 inline fvar<T> Phi_approx(const fvar<T>& x) {
-  using std::pow;
   return inv_logit(0.07056 * pow(x, 3.0) + 1.5976 * x);
 }
 
diff --git a/stan/math/fwd/fun/abs.hpp b/stan/math/fwd/fun/abs.hpp
index 1f50b149fd6..27305d4e053 100644
--- a/stan/math/fwd/fun/abs.hpp
+++ b/stan/math/fwd/fun/abs.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/abs.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/abs.hpp>
 #include <complex>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/acos.hpp b/stan/math/fwd/fun/acos.hpp
index 75f0561578c..e92b5525b79 100644
--- a/stan/math/fwd/fun/acos.hpp
+++ b/stan/math/fwd/fun/acos.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/acos.hpp>
 #include <cmath>
 #include <complex>
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> acos(const fvar<T>& x) {
-  using std::acos;
-  using std::sqrt;
   return fvar<T>(acos(x.val_), x.d_ / -sqrt(1 - square(x.val_)));
 }
 
diff --git a/stan/math/fwd/fun/acosh.hpp b/stan/math/fwd/fun/acosh.hpp
index 376daa568aa..fccf9a0b51f 100644
--- a/stan/math/fwd/fun/acosh.hpp
+++ b/stan/math/fwd/fun/acosh.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/acosh.hpp>
-#include <stan/math/prim/fun/square.hpp>
-#include <stan/math/prim/fun/sqrt.hpp>
 #include <cmath>
 #include <complex>
 
@@ -14,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> acosh(const fvar<T>& x) {
-  using std::sqrt;
   return fvar<T>(acosh(x.val_), x.d_ / sqrt(square(x.val_) - 1));
 }
 
diff --git a/stan/math/fwd/fun/asin.hpp b/stan/math/fwd/fun/asin.hpp
index 0ce1b593342..ecf7fa26918 100644
--- a/stan/math/fwd/fun/asin.hpp
+++ b/stan/math/fwd/fun/asin.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/asin.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> asin(const fvar<T>& x) {
-  using std::asin;
-  using std::sqrt;
   return fvar<T>(asin(x.val_), x.d_ / sqrt(1 - square(x.val_)));
 }
 
diff --git a/stan/math/fwd/fun/asinh.hpp b/stan/math/fwd/fun/asinh.hpp
index 4e430514ec4..bdd74be74d3 100644
--- a/stan/math/fwd/fun/asinh.hpp
+++ b/stan/math/fwd/fun/asinh.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/asinh.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> asinh(const fvar<T>& x) {
-  using std::sqrt;
   return fvar<T>(asinh(x.val_), x.d_ / sqrt(square(x.val_) + 1));
 }
 
diff --git a/stan/math/fwd/fun/atan.hpp b/stan/math/fwd/fun/atan.hpp
index a16f6ef8792..2e42c89dfb8 100644
--- a/stan/math/fwd/fun/atan.hpp
+++ b/stan/math/fwd/fun/atan.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/atanh.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/atan.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> atan(const fvar<T>& x) {
-  using std::atan;
   return fvar<T>(atan(x.val_), x.d_ / (1 + square(x.val_)));
 }
 
diff --git a/stan/math/fwd/fun/atan2.hpp b/stan/math/fwd/fun/atan2.hpp
index 9af5e37ca68..94bee5b263a 100644
--- a/stan/math/fwd/fun/atan2.hpp
+++ b/stan/math/fwd/fun/atan2.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/prim/fun/atan2.hpp>
 #include <cmath>
 
 namespace stan {
@@ -11,7 +12,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> atan2(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::atan2;
   return fvar<T>(atan2(x1.val_, x2.val_),
                  (x1.d_ * x2.val_ - x1.val_ * x2.d_)
                      / (square(x2.val_) + square(x1.val_)));
@@ -19,14 +19,12 @@ inline fvar<T> atan2(const fvar<T>& x1, const fvar<T>& x2) {
 
 template <typename T>
 inline fvar<T> atan2(double x1, const fvar<T>& x2) {
-  using std::atan2;
   return fvar<T>(atan2(x1, x2.val_),
                  (-x1 * x2.d_) / (square(x1) + square(x2.val_)));
 }
 
 template <typename T>
 inline fvar<T> atan2(const fvar<T>& x1, double x2) {
-  using std::atan2;
   return fvar<T>(atan2(x1.val_, x2),
                  (x1.d_ * x2) / (square(x2) + square(x1.val_)));
 }
diff --git a/stan/math/fwd/fun/atanh.hpp b/stan/math/fwd/fun/atanh.hpp
index ded211fd2d4..04b95144eac 100644
--- a/stan/math/fwd/fun/atanh.hpp
+++ b/stan/math/fwd/fun/atanh.hpp
@@ -3,8 +3,10 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/fwd/fun/value_of_rec.hpp>
 #include <stan/math/prim/fun/atanh.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/fwd/fun/beta.hpp b/stan/math/fwd/fun/beta.hpp
index b8ba5e7d10c..a4c8b782052 100644
--- a/stan/math/fwd/fun/beta.hpp
+++ b/stan/math/fwd/fun/beta.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/beta.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/cbrt.hpp b/stan/math/fwd/fun/cbrt.hpp
index a584eb8a710..bfdec65d9c9 100644
--- a/stan/math/fwd/fun/cbrt.hpp
+++ b/stan/math/fwd/fun/cbrt.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/cbrt.hpp>
-#include <stan/math/prim/fun/square.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/ceil.hpp b/stan/math/fwd/fun/ceil.hpp
index cc322cfaac8..3fca1ef6c77 100644
--- a/stan/math/fwd/fun/ceil.hpp
+++ b/stan/math/fwd/fun/ceil.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/fun/ceil.hpp>
 #include <cmath>
 
 namespace stan {
@@ -10,7 +11,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> ceil(const fvar<T>& x) {
-  using std::ceil;
   return fvar<T>(ceil(x.val_), 0);
 }
 
diff --git a/stan/math/fwd/fun/conj.hpp b/stan/math/fwd/fun/conj.hpp
index 706d97d2678..38be744e31a 100644
--- a/stan/math/fwd/fun/conj.hpp
+++ b/stan/math/fwd/fun/conj.hpp
@@ -5,22 +5,4 @@
 #include <stan/math/prim/fun/conj.hpp>
 #include <complex>
 
-namespace stan {
-namespace math {
-
-/**
- * Return the phase angle of the complex argument.
- *
- * @tparam T value type of autodiff variable
- * @param[in] z argument
- * @return phase angle of the argument
- */
-template <typename T>
-inline std::complex<fvar<T>> conj(const std::complex<fvar<T>>& z) {
-  return internal::complex_conj(z);
-}
-
-}  // namespace math
-}  // namespace stan
-
 #endif
diff --git a/stan/math/fwd/fun/cos.hpp b/stan/math/fwd/fun/cos.hpp
index 0cfe38166b8..19be59e91de 100644
--- a/stan/math/fwd/fun/cos.hpp
+++ b/stan/math/fwd/fun/cos.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
+#include <stan/math/fwd/fun/cosh.hpp>
 #include <stan/math/prim/fun/cos.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> cos(const fvar<T>& x) {
-  using std::cos;
-  using std::sin;
   return fvar<T>(cos(x.val_), x.d_ * -sin(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/cosh.hpp b/stan/math/fwd/fun/cosh.hpp
index d1194cf54ed..c96e0c6789d 100644
--- a/stan/math/fwd/fun/cosh.hpp
+++ b/stan/math/fwd/fun/cosh.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/sinh.hpp>
 #include <stan/math/prim/fun/cosh.hpp>
 #include <cmath>
 #include <complex>
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> cosh(const fvar<T>& x) {
-  using std::cosh;
-  using std::sinh;
   return fvar<T>(cosh(x.val_), x.d_ * sinh(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/determinant.hpp b/stan/math/fwd/fun/determinant.hpp
index e3fee48d829..ac6cfa12e57 100644
--- a/stan/math/fwd/fun/determinant.hpp
+++ b/stan/math/fwd/fun/determinant.hpp
@@ -1,11 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_DETERMINANT_HPP
 #define STAN_MATH_FWD_FUN_DETERMINANT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/fwd/core.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/digamma.hpp b/stan/math/fwd/fun/digamma.hpp
index 3ab0cbb5fb8..ede447b685a 100644
--- a/stan/math/fwd/fun/digamma.hpp
+++ b/stan/math/fwd/fun/digamma.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/trigamma.hpp>
 
 #include <stan/math/prim/fun/digamma.hpp>
-#include <stan/math/prim/fun/trigamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/erf.hpp b/stan/math/fwd/fun/erf.hpp
index 6e88c092c0a..2ed906da5f8 100644
--- a/stan/math/fwd/fun/erf.hpp
+++ b/stan/math/fwd/fun/erf.hpp
@@ -3,9 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/erf.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> erf(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(erf(x.val_), x.d_ * exp(-square(x.val_)) * TWO_OVER_SQRT_PI);
 }
 
diff --git a/stan/math/fwd/fun/erfc.hpp b/stan/math/fwd/fun/erfc.hpp
index 458013f5a7b..b3c222561ee 100644
--- a/stan/math/fwd/fun/erfc.hpp
+++ b/stan/math/fwd/fun/erfc.hpp
@@ -3,9 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/erfc.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> erfc(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(erfc(x.val_), -x.d_ * exp(-square(x.val_)) * TWO_OVER_SQRT_PI);
 }
 
diff --git a/stan/math/fwd/fun/exp.hpp b/stan/math/fwd/fun/exp.hpp
index d0690fd803d..d24e35e06eb 100644
--- a/stan/math/fwd/fun/exp.hpp
+++ b/stan/math/fwd/fun/exp.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
 #include <stan/math/prim/fun/exp.hpp>
 #include <cmath>
 #include <complex>
@@ -11,7 +13,6 @@ namespace stan {
 namespace math {
 template <typename T>
 inline fvar<T> exp(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(exp(x.val_), x.d_ * exp(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/exp2.hpp b/stan/math/fwd/fun/exp2.hpp
index 52e6ed65c44..cda233bfad0 100644
--- a/stan/math/fwd/fun/exp2.hpp
+++ b/stan/math/fwd/fun/exp2.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/exp2.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/exp2.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/expm1.hpp b/stan/math/fwd/fun/expm1.hpp
index 72c388fadfb..86a0b146f1d 100644
--- a/stan/math/fwd/fun/expm1.hpp
+++ b/stan/math/fwd/fun/expm1.hpp
@@ -1,9 +1,10 @@
 #ifndef STAN_MATH_FWD_FUN_EXPM1_HPP
 #define STAN_MATH_FWD_FUN_EXPM1_HPP
 
-#include <stan/math/prim/fun/expm1.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/prim/fun/expm1.hpp>
 #include <cmath>
 
 namespace stan {
@@ -11,7 +12,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> expm1(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(expm1(x.val_), x.d_ * exp(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/fabs.hpp b/stan/math/fwd/fun/fabs.hpp
index 47af374b153..dff73342478 100644
--- a/stan/math/fwd/fun/fabs.hpp
+++ b/stan/math/fwd/fun/fabs.hpp
@@ -3,9 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
+#include <stan/math/fwd/fun/is_nan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/is_nan.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/fabs.hpp>
 #include <cmath>
 
 namespace stan {
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> fabs(const fvar<T>& x) {
-  using std::fabs;
-
   if (unlikely(is_nan(value_of(x.val_)))) {
     return fvar<T>(fabs(x.val_), NOT_A_NUMBER);
   } else if (x.val_ > 0.0) {
diff --git a/stan/math/fwd/fun/falling_factorial.hpp b/stan/math/fwd/fun/falling_factorial.hpp
index e62796c7a1a..930bf911aa7 100644
--- a/stan/math/fwd/fun/falling_factorial.hpp
+++ b/stan/math/fwd/fun/falling_factorial.hpp
@@ -3,9 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/falling_factorial.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/floor.hpp b/stan/math/fwd/fun/floor.hpp
index bdd12a10b93..d68164c0159 100644
--- a/stan/math/fwd/fun/floor.hpp
+++ b/stan/math/fwd/fun/floor.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/fun/floor.hpp>
 #include <cmath>
 
 namespace stan {
@@ -10,7 +11,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> floor(const fvar<T>& x) {
-  using std::floor;
   return fvar<T>(floor(x.val_), 0);
 }
 
diff --git a/stan/math/fwd/fun/fmax.hpp b/stan/math/fwd/fun/fmax.hpp
index b5227d31adb..3919b6a64d6 100644
--- a/stan/math/fwd/fun/fmax.hpp
+++ b/stan/math/fwd/fun/fmax.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/is_nan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/fmax.hpp>
-#include <stan/math/prim/fun/is_nan.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/fmin.hpp b/stan/math/fwd/fun/fmin.hpp
index e906df91f36..df5f6a66c71 100644
--- a/stan/math/fwd/fun/fmin.hpp
+++ b/stan/math/fwd/fun/fmin.hpp
@@ -4,8 +4,8 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/fmin.hpp>
 #include <stan/math/prim/fun/is_nan.hpp>
+#include <stan/math/prim/fun/fmin.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/fmod.hpp b/stan/math/fwd/fun/fmod.hpp
index 2cbed3e8c09..0642c5add99 100644
--- a/stan/math/fwd/fun/fmod.hpp
+++ b/stan/math/fwd/fun/fmod.hpp
@@ -3,9 +3,11 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/trunc.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/fmod.hpp>
 #include <cmath>
 
 namespace stan {
@@ -13,15 +15,12 @@ namespace math {
 
 template <typename T>
 inline fvar<T> fmod(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::fmod;
-  using std::trunc;
   return fvar<T>(fmod(x1.val_, x2.val_),
                  x1.d_ - x2.d_ * trunc(x1.val_ / x2.val_));
 }
 
 template <typename T>
 inline fvar<T> fmod(const fvar<T>& x1, double x2) {
-  using std::fmod;
   if (unlikely(is_any_nan(value_of(x1.val_), x2))) {
     return fvar<T>(fmod(x1.val_, x2), NOT_A_NUMBER);
   } else {
@@ -31,8 +30,6 @@ inline fvar<T> fmod(const fvar<T>& x1, double x2) {
 
 template <typename T>
 inline fvar<T> fmod(double x1, const fvar<T>& x2) {
-  using std::fmod;
-  using std::trunc;
   return fvar<T>(fmod(x1, x2.val_), -x2.d_ * trunc(x1 / x2.val_));
 }
 
diff --git a/stan/math/fwd/fun/gamma_p.hpp b/stan/math/fwd/fun/gamma_p.hpp
index f3f84cc7b04..20c1d25016c 100644
--- a/stan/math/fwd/fun/gamma_p.hpp
+++ b/stan/math/fwd/fun/gamma_p.hpp
@@ -3,10 +3,12 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/lgamma.hpp>
+#include <stan/math/fwd/fun/log.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/gamma_p.hpp>
 #include <stan/math/prim/fun/grad_reg_lower_inc_gamma.hpp>
-#include <stan/math/prim/fun/lgamma.hpp>
+#include <stan/math/prim/fun/gamma_p.hpp>
 #include <cmath>
 
 namespace stan {
@@ -14,9 +16,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> gamma_p(const fvar<T> &x1, const fvar<T> &x2) {
-  using std::exp;
-  using std::log;
-
   T u = gamma_p(x1.val_, x2.val_);
   if (is_inf(x1.val_)) {
     return fvar<T>(u, NOT_A_NUMBER);
@@ -48,9 +47,6 @@ inline fvar<T> gamma_p(const fvar<T> &x1, double x2) {
 
 template <typename T>
 inline fvar<T> gamma_p(double x1, const fvar<T> &x2) {
-  using std::exp;
-  using std::log;
-
   T u = gamma_p(x1, x2.val_);
   if (is_inf(x1)) {
     return fvar<T>(u, NOT_A_NUMBER);
diff --git a/stan/math/fwd/fun/gamma_q.hpp b/stan/math/fwd/fun/gamma_q.hpp
index b2ba8d41255..2e1951bcd82 100644
--- a/stan/math/fwd/fun/gamma_q.hpp
+++ b/stan/math/fwd/fun/gamma_q.hpp
@@ -3,7 +3,12 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/tgamma.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/fabs.hpp>
+#include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/fwd/fun/pow.hpp>
+#include <stan/math/fwd/fun/tgamma.hpp>
 #include <stan/math/prim/fun/gamma_q.hpp>
 #include <cmath>
 
@@ -12,12 +17,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> gamma_q(const fvar<T>& x1, const fvar<T>& x2) {
-  using boost::math::digamma;
-  using std::exp;
-  using std::fabs;
-  using std::log;
-  using std::pow;
-
   T u = gamma_q(x1.val_, x2.val_);
 
   T S = 0;
@@ -44,14 +43,7 @@ inline fvar<T> gamma_q(const fvar<T>& x1, const fvar<T>& x2) {
 
 template <typename T>
 inline fvar<T> gamma_q(const fvar<T>& x1, double x2) {
-  using boost::math::digamma;
-  using std::exp;
-  using std::fabs;
-  using std::log;
-  using std::pow;
-
   T u = gamma_q(x1.val_, x2);
-
   T S = 0;
   double s = 1;
   double l = log(x2);
@@ -75,15 +67,9 @@ inline fvar<T> gamma_q(const fvar<T>& x1, double x2) {
 
 template <typename T>
 inline fvar<T> gamma_q(double x1, const fvar<T>& x2) {
-  using std::exp;
-  using std::pow;
-
   T u = gamma_q(x1, x2.val_);
-
   double g = tgamma(x1);
-
   T der2 = -exp(-x2.val_) * pow(x2.val_, x1 - 1.0) / g;
-
   return fvar<T>(u, x2.d_ * der2);
 }
 }  // namespace math
diff --git a/stan/math/fwd/fun/grad_inc_beta.hpp b/stan/math/fwd/fun/grad_inc_beta.hpp
index 70e0453c674..6c8c6e88486 100644
--- a/stan/math/fwd/fun/grad_inc_beta.hpp
+++ b/stan/math/fwd/fun/grad_inc_beta.hpp
@@ -1,8 +1,6 @@
 #ifndef STAN_MATH_FWD_FUN_GRAD_INC_BETA_HPP
 #define STAN_MATH_FWD_FUN_GRAD_INC_BETA_HPP
 
-#include <stan/math/prim/fun/grad_2F1.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun/beta.hpp>
@@ -11,6 +9,8 @@
 #include <stan/math/fwd/fun/log.hpp>
 #include <stan/math/fwd/fun/log1m.hpp>
 #include <stan/math/fwd/fun/value_of.hpp>
+#include <stan/math/prim/fun/grad_2F1.hpp>
+#include <stan/math/prim/fun/grad_inc_beta.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/hypergeometric_1F0.hpp b/stan/math/fwd/fun/hypergeometric_1F0.hpp
index 8448b6cc3a4..b304d5c8381 100644
--- a/stan/math/fwd/fun/hypergeometric_1F0.hpp
+++ b/stan/math/fwd/fun/hypergeometric_1F0.hpp
@@ -1,9 +1,12 @@
 #ifndef STAN_MATH_FWD_FUN_HYPERGEOMETRIC_1F0_HPP
 #define STAN_MATH_FWD_FUN_HYPERGEOMETRIC_1F0_HPP
 
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/hypergeometric_1F0.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/log1m.hpp>
+#include <stan/math/fwd/fun/inv.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
+#include <stan/math/prim/fun/hypergeometric_1F0.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/hypergeometric_2F1.hpp b/stan/math/fwd/fun/hypergeometric_2F1.hpp
index 993825bd51d..9e450cda01f 100644
--- a/stan/math/fwd/fun/hypergeometric_2F1.hpp
+++ b/stan/math/fwd/fun/hypergeometric_2F1.hpp
@@ -3,8 +3,9 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/hypergeometric_2F1.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/grad_2F1.hpp>
+#include <stan/math/prim/fun/hypergeometric_2F1.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/hypergeometric_pFq.hpp b/stan/math/fwd/fun/hypergeometric_pFq.hpp
index cec91aaa90b..3165878ffcf 100644
--- a/stan/math/fwd/fun/hypergeometric_pFq.hpp
+++ b/stan/math/fwd/fun/hypergeometric_pFq.hpp
@@ -3,8 +3,10 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/hypergeometric_pFq.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
+#include <stan/math/prim/fun/dot_product.hpp>
 #include <stan/math/prim/fun/grad_pFq.hpp>
+#include <stan/math/prim/fun/hypergeometric_pFq.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/hypot.hpp b/stan/math/fwd/fun/hypot.hpp
index 07def1797e4..09d186d6009 100644
--- a/stan/math/fwd/fun/hypot.hpp
+++ b/stan/math/fwd/fun/hypot.hpp
@@ -24,7 +24,6 @@ namespace math {
  */
 template <typename T>
 inline fvar<T> hypot(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::sqrt;
   T u = hypot(x1.val_, x2.val_);
   return fvar<T>(u, (x1.d_ * x1.val_ + x2.d_ * x2.val_) / u);
 }
@@ -44,7 +43,6 @@ inline fvar<T> hypot(const fvar<T>& x1, const fvar<T>& x2) {
  */
 template <typename T>
 inline fvar<T> hypot(const fvar<T>& x1, double x2) {
-  using std::sqrt;
   T u = hypot(x1.val_, x2);
   return fvar<T>(u, (x1.d_ * x1.val_) / u);
 }
@@ -64,7 +62,6 @@ inline fvar<T> hypot(const fvar<T>& x1, double x2) {
  */
 template <typename T>
 inline fvar<T> hypot(double x1, const fvar<T>& x2) {
-  using std::sqrt;
   T u = hypot(x1, x2.val_);
   return fvar<T>(u, (x2.d_ * x2.val_) / u);
 }
diff --git a/stan/math/fwd/fun/inc_beta.hpp b/stan/math/fwd/fun/inc_beta.hpp
index 8f964d365ea..d0b89e35e06 100644
--- a/stan/math/fwd/fun/inc_beta.hpp
+++ b/stan/math/fwd/fun/inc_beta.hpp
@@ -1,15 +1,15 @@
 #ifndef STAN_MATH_FWD_FUN_INC_BETA_HPP
 #define STAN_MATH_FWD_FUN_INC_BETA_HPP
 
-#include <stan/math/prim/fun/digamma.hpp>
-#include <stan/math/prim/fun/grad_reg_inc_beta.hpp>
-#include <stan/math/prim/fun/lbeta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun/beta.hpp>
 #include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/lbeta.hpp>
 #include <stan/math/fwd/fun/pow.hpp>
+#include <stan/math/prim/fun/grad_reg_inc_beta.hpp>
+#include <stan/math/prim/fun/inc_beta.hpp>
 #include <cmath>
 
 namespace stan {
@@ -17,7 +17,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> inc_beta(const fvar<T>& a, const fvar<T>& b, const fvar<T>& x) {
-  using std::pow;
   T d_a;
   T d_b;
   const T beta_ab = beta(a.val_, b.val_);
diff --git a/stan/math/fwd/fun/inv.hpp b/stan/math/fwd/fun/inv.hpp
index b5b2531f4fe..3d0cd3108a5 100644
--- a/stan/math/fwd/fun/inv.hpp
+++ b/stan/math/fwd/fun/inv.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/prim/fun/inv.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/inv_Phi.hpp b/stan/math/fwd/fun/inv_Phi.hpp
index bfff53da0e2..5424f484f74 100644
--- a/stan/math/fwd/fun/inv_Phi.hpp
+++ b/stan/math/fwd/fun/inv_Phi.hpp
@@ -3,9 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/inv_Phi.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
@@ -13,7 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> inv_Phi(const fvar<T>& p) {
-  using std::exp;
   T xv = inv_Phi(p.val_);
   return fvar<T>(xv, p.d_ / exp(-0.5 * square(xv)) * SQRT_TWO_PI);
 }
diff --git a/stan/math/fwd/fun/inv_cloglog.hpp b/stan/math/fwd/fun/inv_cloglog.hpp
index d0e7a0f4c34..73767500376 100644
--- a/stan/math/fwd/fun/inv_cloglog.hpp
+++ b/stan/math/fwd/fun/inv_cloglog.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
 #include <stan/math/prim/fun/inv_cloglog.hpp>
 #include <cmath>
 
@@ -11,7 +12,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> inv_cloglog(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(inv_cloglog(x.val_), x.d_ * exp(x.val_ - exp(x.val_)));
 }
 }  // namespace math
diff --git a/stan/math/fwd/fun/inv_erfc.hpp b/stan/math/fwd/fun/inv_erfc.hpp
index c2b5852b958..f9628d013e0 100644
--- a/stan/math/fwd/fun/inv_erfc.hpp
+++ b/stan/math/fwd/fun/inv_erfc.hpp
@@ -3,10 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/inv_erfc.hpp>
-#include <stan/math/fwd/fun/square.hpp>
-#include <stan/math/fwd/fun/exp.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/inv_inc_beta.hpp b/stan/math/fwd/fun/inv_inc_beta.hpp
index ab095c557db..23ce0d583ed 100644
--- a/stan/math/fwd/fun/inv_inc_beta.hpp
+++ b/stan/math/fwd/fun/inv_inc_beta.hpp
@@ -3,15 +3,18 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/inv_inc_beta.hpp>
-#include <stan/math/prim/fun/inc_beta.hpp>
-#include <stan/math/prim/fun/exp.hpp>
-#include <stan/math/prim/fun/log.hpp>
-#include <stan/math/prim/fun/log_diff_exp.hpp>
-#include <stan/math/prim/fun/lbeta.hpp>
-#include <stan/math/prim/fun/lgamma.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/fabs.hpp>
+#include <stan/math/fwd/fun/inc_beta.hpp>
+#include <stan/math/fwd/fun/lbeta.hpp>
+#include <stan/math/fwd/fun/lgamma.hpp>
+#include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/fwd/fun/log1m.hpp>
+#include <stan/math/fwd/fun/log_diff_exp.hpp>
+#include <stan/math/fwd/fun/sum.hpp>
 #include <stan/math/prim/fun/hypergeometric_3F2.hpp>
+#include <stan/math/prim/fun/inv_inc_beta.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/inv_logit.hpp b/stan/math/fwd/fun/inv_logit.hpp
index 8a6bd96d438..7becb85444a 100644
--- a/stan/math/fwd/fun/inv_logit.hpp
+++ b/stan/math/fwd/fun/inv_logit.hpp
@@ -18,8 +18,6 @@ namespace math {
  */
 template <typename T>
 inline fvar<T> inv_logit(const fvar<T>& x) {
-  using std::exp;
-  using std::pow;
   return fvar<T>(inv_logit(x.val_),
                  x.d_ * inv_logit(x.val_) * (1 - inv_logit(x.val_)));
 }
diff --git a/stan/math/fwd/fun/inv_sqrt.hpp b/stan/math/fwd/fun/inv_sqrt.hpp
index 40625094d37..eefe580c075 100644
--- a/stan/math/fwd/fun/inv_sqrt.hpp
+++ b/stan/math/fwd/fun/inv_sqrt.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/prim/fun/inv_sqrt.hpp>
 #include <cmath>
 
 namespace stan {
@@ -10,9 +12,8 @@ namespace math {
 
 template <typename T>
 inline fvar<T> inv_sqrt(const fvar<T>& x) {
-  using std::sqrt;
   T sqrt_x(sqrt(x.val_));
-  return fvar<T>(1 / sqrt_x, -0.5 * x.d_ / (x.val_ * sqrt_x));
+  return fvar<T>(1.0 / sqrt_x, -0.5 * x.d_ / (x.val_ * sqrt_x));
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/fwd/fun/inv_square.hpp b/stan/math/fwd/fun/inv_square.hpp
index 016ed9e9294..d1f41d48f30 100644
--- a/stan/math/fwd/fun/inv_square.hpp
+++ b/stan/math/fwd/fun/inv_square.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/prim/fun/inv_square.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/inverse.hpp b/stan/math/fwd/fun/inverse.hpp
index 36f8da0b4c1..82e817b2dc9 100644
--- a/stan/math/fwd/fun/inverse.hpp
+++ b/stan/math/fwd/fun/inverse.hpp
@@ -1,14 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_INVERSE_HPP
 #define STAN_MATH_FWD_FUN_INVERSE_HPP
 
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/multiply.hpp>
-#include <stan/math/prim/fun/inverse.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/fwd/fun/to_fvar.hpp>
+#include <stan/math/fwd/meta.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/inverse.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/lambert_w.hpp b/stan/math/fwd/fun/lambert_w.hpp
index 622dff79612..45968e8722f 100644
--- a/stan/math/fwd/fun/lambert_w.hpp
+++ b/stan/math/fwd/fun/lambert_w.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
 #include <stan/math/prim/fun/lambert_w.hpp>
 #include <cmath>
 
diff --git a/stan/math/fwd/fun/lbeta.hpp b/stan/math/fwd/fun/lbeta.hpp
index b1f55bc483d..eb2c05b4c1a 100644
--- a/stan/math/fwd/fun/lbeta.hpp
+++ b/stan/math/fwd/fun/lbeta.hpp
@@ -4,7 +4,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/lbeta.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/lgamma.hpp b/stan/math/fwd/fun/lgamma.hpp
index 864d6dda152..780dc896bcb 100644
--- a/stan/math/fwd/fun/lgamma.hpp
+++ b/stan/math/fwd/fun/lgamma.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/lgamma.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/lmgamma.hpp b/stan/math/fwd/fun/lmgamma.hpp
index 7281086cce7..77698007cc8 100644
--- a/stan/math/fwd/fun/lmgamma.hpp
+++ b/stan/math/fwd/fun/lmgamma.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/lmgamma.hpp>
 #include <cmath>
 
@@ -12,7 +12,6 @@ namespace math {
 
 template <typename T>
 inline fvar<return_type_t<T, int>> lmgamma(int x1, const fvar<T>& x2) {
-  using std::log;
   T deriv = 0;
   for (int count = 1; count < x1 + 1; count++) {
     deriv += x2.d_ * digamma(x2.val_ + (1.0 - count) / 2.0);
diff --git a/stan/math/fwd/fun/lmultiply.hpp b/stan/math/fwd/fun/lmultiply.hpp
index 7df57e26d23..4af4aaf27c4 100644
--- a/stan/math/fwd/fun/lmultiply.hpp
+++ b/stan/math/fwd/fun/lmultiply.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/log.hpp>
 #include <stan/math/prim/fun/lmultiply.hpp>
 #include <cmath>
 
@@ -11,20 +12,17 @@ namespace math {
 
 template <typename T>
 inline fvar<T> lmultiply(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::log;
   return fvar<T>(lmultiply(x1.val_, x2.val_),
                  x1.d_ * log(x2.val_) + x1.val_ * x2.d_ / x2.val_);
 }
 
 template <typename T>
 inline fvar<T> lmultiply(double x1, const fvar<T>& x2) {
-  using std::log;
   return fvar<T>(lmultiply(x1, x2.val_), x1 * x2.d_ / x2.val_);
 }
 
 template <typename T>
 inline fvar<T> lmultiply(const fvar<T>& x1, double x2) {
-  using std::log;
   return fvar<T>(lmultiply(x1.val_, x2), x1.d_ * log(x2));
 }
 }  // namespace math
diff --git a/stan/math/fwd/fun/log.hpp b/stan/math/fwd/fun/log.hpp
index d7ce96f0bfa..d3270d2b833 100644
--- a/stan/math/fwd/fun/log.hpp
+++ b/stan/math/fwd/fun/log.hpp
@@ -3,6 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/norm.hpp>
+#include <stan/math/fwd/fun/arg.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/log.hpp>
 #include <cmath>
@@ -13,7 +16,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> log(const fvar<T>& x) {
-  using std::log;
   if (x.val_ < 0.0) {
     return fvar<T>(NOT_A_NUMBER, NOT_A_NUMBER);
   } else {
diff --git a/stan/math/fwd/fun/log10.hpp b/stan/math/fwd/fun/log10.hpp
index f418eeb4b37..a28bef26a61 100644
--- a/stan/math/fwd/fun/log10.hpp
+++ b/stan/math/fwd/fun/log10.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/log.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/log10.hpp>
 #include <cmath>
@@ -13,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> log10(const fvar<T>& x) {
-  using std::log;
-  using std::log10;
   if (x.val_ < 0.0) {
     return fvar<T>(NOT_A_NUMBER, NOT_A_NUMBER);
   } else {
diff --git a/stan/math/fwd/fun/log1m_exp.hpp b/stan/math/fwd/fun/log1m_exp.hpp
index 9ce2211d07d..9f1b1e7a9d6 100644
--- a/stan/math/fwd/fun/log1m_exp.hpp
+++ b/stan/math/fwd/fun/log1m_exp.hpp
@@ -5,7 +5,6 @@
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/expm1.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/expm1.hpp>
 #include <stan/math/prim/fun/log1m_exp.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/log1m_inv_logit.hpp b/stan/math/fwd/fun/log1m_inv_logit.hpp
index edf27198399..6251e7e8b11 100644
--- a/stan/math/fwd/fun/log1m_inv_logit.hpp
+++ b/stan/math/fwd/fun/log1m_inv_logit.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log1m_inv_logit.hpp>
 #include <cmath>
 
@@ -19,7 +20,6 @@ namespace math {
  */
 template <typename T>
 inline fvar<T> log1m_inv_logit(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(log1m_inv_logit(x.val_), -x.d_ * inv_logit(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/log1p_exp.hpp b/stan/math/fwd/fun/log1p_exp.hpp
index ca7d82661fb..7b5d689ccf1 100644
--- a/stan/math/fwd/fun/log1p_exp.hpp
+++ b/stan/math/fwd/fun/log1p_exp.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log1p_exp.hpp>
 #include <cmath>
 
@@ -11,7 +12,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> log1p_exp(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(log1p_exp(x.val_), x.d_ * inv_logit(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/log_determinant.hpp b/stan/math/fwd/fun/log_determinant.hpp
index 2270718ee43..78405cdc88f 100644
--- a/stan/math/fwd/fun/log_determinant.hpp
+++ b/stan/math/fwd/fun/log_determinant.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_LOG_DETERMINANT_HPP
 #define STAN_MATH_FWD_FUN_LOG_DETERMINANT_HPP
 
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/determinant.hpp>
 #include <stan/math/fwd/fun/fabs.hpp>
 #include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/err.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/log_diff_exp.hpp b/stan/math/fwd/fun/log_diff_exp.hpp
index 1ee40481ec7..036cc04884b 100644
--- a/stan/math/fwd/fun/log_diff_exp.hpp
+++ b/stan/math/fwd/fun/log_diff_exp.hpp
@@ -4,7 +4,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/expm1.hpp>
+#include <stan/math/fwd/fun/expm1.hpp>
 #include <stan/math/prim/fun/log_diff_exp.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/log_falling_factorial.hpp b/stan/math/fwd/fun/log_falling_factorial.hpp
index 4a879b02649..636b823f3ef 100644
--- a/stan/math/fwd/fun/log_falling_factorial.hpp
+++ b/stan/math/fwd/fun/log_falling_factorial.hpp
@@ -4,7 +4,6 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/digamma.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 #include <stan/math/prim/fun/log_falling_factorial.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/log_inv_logit.hpp b/stan/math/fwd/fun/log_inv_logit.hpp
index d0139d30278..c1ca6eaefbd 100644
--- a/stan/math/fwd/fun/log_inv_logit.hpp
+++ b/stan/math/fwd/fun/log_inv_logit.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log_inv_logit.hpp>
 #include <cmath>
 
@@ -12,7 +12,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> log_inv_logit(const fvar<T>& x) {
-  using std::exp;
   return fvar<T>(log_inv_logit(x.val_), x.d_ * inv_logit(-x.val_));
 }
 }  // namespace math
diff --git a/stan/math/fwd/fun/log_inv_logit_diff.hpp b/stan/math/fwd/fun/log_inv_logit_diff.hpp
index 05df12dd376..e31f166d040 100644
--- a/stan/math/fwd/fun/log_inv_logit_diff.hpp
+++ b/stan/math/fwd/fun/log_inv_logit_diff.hpp
@@ -3,10 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
+#include <stan/math/fwd/fun/inv.hpp>
+#include <stan/math/fwd/fun/expm1.hpp>
 #include <stan/math/prim/fun/log_inv_logit_diff.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
-#include <stan/math/prim/fun/inv.hpp>
-#include <stan/math/prim/fun/expm1.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/log_mix.hpp b/stan/math/fwd/fun/log_mix.hpp
index 0477b398865..3da901d67d6 100644
--- a/stan/math/fwd/fun/log_mix.hpp
+++ b/stan/math/fwd/fun/log_mix.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/log_mix.hpp>
 #include <cmath>
 #include <type_traits>
@@ -28,7 +29,6 @@ template <typename T_theta, typename T_lambda1, typename T_lambda2, int N>
 inline void log_mix_partial_helper(
     const T_theta& theta, const T_lambda1& lambda1, const T_lambda2& lambda2,
     promote_args_t<T_theta, T_lambda1, T_lambda2> (&partials_array)[N]) {
-  using std::exp;
   using partial_return_type = promote_args_t<T_theta, T_lambda1, T_lambda2>;
   auto lam2_m_lam1 = lambda2 - lambda1;
   auto exp_lam2_m_lam1 = exp(lam2_m_lam1);
diff --git a/stan/math/fwd/fun/log_rising_factorial.hpp b/stan/math/fwd/fun/log_rising_factorial.hpp
index 399f13d1cb3..89e2f4bcc1e 100644
--- a/stan/math/fwd/fun/log_rising_factorial.hpp
+++ b/stan/math/fwd/fun/log_rising_factorial.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/log_rising_factorial.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/log_softmax.hpp b/stan/math/fwd/fun/log_softmax.hpp
index 7cd5f1dc684..82d1f7b0204 100644
--- a/stan/math/fwd/fun/log_softmax.hpp
+++ b/stan/math/fwd/fun/log_softmax.hpp
@@ -1,12 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_LOG_SOFTMAX_HPP
 #define STAN_MATH_FWD_FUN_LOG_SOFTMAX_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun/softmax.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/log_softmax.hpp>
-#include <stan/math/prim/fun/softmax.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/log_sum_exp.hpp b/stan/math/fwd/fun/log_sum_exp.hpp
index beb34551160..30795b8f99b 100644
--- a/stan/math/fwd/fun/log_sum_exp.hpp
+++ b/stan/math/fwd/fun/log_sum_exp.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_LOG_SUM_EXP_HPP
 #define STAN_MATH_FWD_FUN_LOG_SUM_EXP_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/fwd/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/log_sum_exp.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/log_sum_exp.hpp>
 #include <cmath>
 #include <vector>
 
@@ -16,7 +16,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> log_sum_exp(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::exp;
   return fvar<T>(log_sum_exp(x1.val_, x2.val_),
                  x1.d_ * inv_logit(-(x2.val_ - x1.val_))
                      + x2.d_ * inv_logit(-(x1.val_ - x2.val_)));
@@ -24,7 +23,6 @@ inline fvar<T> log_sum_exp(const fvar<T>& x1, const fvar<T>& x2) {
 
 template <typename T>
 inline fvar<T> log_sum_exp(double x1, const fvar<T>& x2) {
-  using std::exp;
   if (x1 == NEGATIVE_INFTY) {
     return fvar<T>(x2.val_, x2.d_);
   }
diff --git a/stan/math/fwd/fun/logit.hpp b/stan/math/fwd/fun/logit.hpp
index c5572814bf5..472329d4fa1 100644
--- a/stan/math/fwd/fun/logit.hpp
+++ b/stan/math/fwd/fun/logit.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/logit.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/logit.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/mdivide_left.hpp b/stan/math/fwd/fun/mdivide_left.hpp
index 7fd7c6a1e5e..654b017afc6 100644
--- a/stan/math/fwd/fun/mdivide_left.hpp
+++ b/stan/math/fwd/fun/mdivide_left.hpp
@@ -1,13 +1,12 @@
 #ifndef STAN_MATH_FWD_FUN_MDIVIDE_LEFT_HPP
 #define STAN_MATH_FWD_FUN_MDIVIDE_LEFT_HPP
 
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/mdivide_left.hpp>
-#include <stan/math/prim/fun/multiply.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/fwd/fun/to_fvar.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/mdivide_left.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/mdivide_left_ldlt.hpp b/stan/math/fwd/fun/mdivide_left_ldlt.hpp
index 69db8bd1d8e..7400873dbd4 100644
--- a/stan/math/fwd/fun/mdivide_left_ldlt.hpp
+++ b/stan/math/fwd/fun/mdivide_left_ldlt.hpp
@@ -1,11 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_MDIVIDE_LEFT_LDLT_HPP
 #define STAN_MATH_FWD_FUN_MDIVIDE_LEFT_LDLT_HPP
 
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/fwd/fun/to_fvar.hpp>
+#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/LDLT_factor.hpp>
 #include <stan/math/prim/fun/mdivide_left_ldlt.hpp>
-#include <stan/math/fwd/fun/to_fvar.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/mdivide_left_tri_low.hpp b/stan/math/fwd/fun/mdivide_left_tri_low.hpp
index 67be26be5d1..5aedc86dcfa 100644
--- a/stan/math/fwd/fun/mdivide_left_tri_low.hpp
+++ b/stan/math/fwd/fun/mdivide_left_tri_low.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_FWD_FUN_MDIVIDE_LEFT_TRI_LOW_HPP
 #define STAN_MATH_FWD_FUN_MDIVIDE_LEFT_TRI_LOW_HPP
 
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/mdivide_left.hpp>
-#include <stan/math/fwd/fun/typedefs.hpp>
+#include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/mdivide_left.hpp>
 #include <stan/math/fwd/fun/to_fvar.hpp>
+#include <stan/math/fwd/fun/typedefs.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
-#include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/mdivide_left_tri_low.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/mdivide_right.hpp b/stan/math/fwd/fun/mdivide_right.hpp
index b87cbcb102e..a2421931918 100644
--- a/stan/math/fwd/fun/mdivide_right.hpp
+++ b/stan/math/fwd/fun/mdivide_right.hpp
@@ -1,13 +1,12 @@
 #ifndef STAN_MATH_FWD_FUN_MDIVIDE_RIGHT_HPP
 #define STAN_MATH_FWD_FUN_MDIVIDE_RIGHT_HPP
 
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/mdivide_right.hpp>
-#include <stan/math/prim/fun/multiply.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/fwd/fun/to_fvar.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/mdivide_right.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/mdivide_right_tri_low.hpp b/stan/math/fwd/fun/mdivide_right_tri_low.hpp
index a5fe504a146..039dc7dd57c 100644
--- a/stan/math/fwd/fun/mdivide_right_tri_low.hpp
+++ b/stan/math/fwd/fun/mdivide_right_tri_low.hpp
@@ -1,12 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_MDIVIDE_RIGHT_TRI_LOW_HPP
 #define STAN_MATH_FWD_FUN_MDIVIDE_RIGHT_TRI_LOW_HPP
 
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/mdivide_right.hpp>
-#include <stan/math/fwd/fun/to_fvar.hpp>
-#include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/mdivide_right.hpp>
+#include <stan/math/fwd/fun/multiply.hpp>
+#include <stan/math/fwd/fun/to_fvar.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/mdivide_right_tri_low.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/multiply.hpp b/stan/math/fwd/fun/multiply.hpp
index 3e5d94ab199..cbe365b2860 100644
--- a/stan/math/fwd/fun/multiply.hpp
+++ b/stan/math/fwd/fun/multiply.hpp
@@ -1,12 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_MULTIPLY_HPP
 #define STAN_MATH_FWD_FUN_MULTIPLY_HPP
 
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/dot_product.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun/typedefs.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/dot_product.hpp>
+#include <stan/math/prim/fun/multiply.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/multiply_log.hpp b/stan/math/fwd/fun/multiply_log.hpp
index 32eea41173f..3df40b33268 100644
--- a/stan/math/fwd/fun/multiply_log.hpp
+++ b/stan/math/fwd/fun/multiply_log.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/log.hpp>
 #include <stan/math/prim/fun/multiply_log.hpp>
 #include <cmath>
 
@@ -11,20 +12,17 @@ namespace math {
 
 template <typename T>
 inline fvar<T> multiply_log(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::log;
   return fvar<T>(multiply_log(x1.val_, x2.val_),
                  x1.d_ * log(x2.val_) + x1.val_ * x2.d_ / x2.val_);
 }
 
 template <typename T>
 inline fvar<T> multiply_log(double x1, const fvar<T>& x2) {
-  using std::log;
   return fvar<T>(multiply_log(x1, x2.val_), x1 * x2.d_ / x2.val_);
 }
 
 template <typename T>
 inline fvar<T> multiply_log(const fvar<T>& x1, double x2) {
-  using std::log;
   return fvar<T>(multiply_log(x1.val_, x2), x1.d_ * log(x2));
 }
 }  // namespace math
diff --git a/stan/math/fwd/fun/multiply_lower_tri_self_transpose.hpp b/stan/math/fwd/fun/multiply_lower_tri_self_transpose.hpp
index 93923da0f1e..c9ca25018b5 100644
--- a/stan/math/fwd/fun/multiply_lower_tri_self_transpose.hpp
+++ b/stan/math/fwd/fun/multiply_lower_tri_self_transpose.hpp
@@ -2,8 +2,9 @@
 #define STAN_MATH_FWD_FUN_MULTIPLY_LOWER_TRI_SELF_TRANSPOSE_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/transpose.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
+#include <stan/math/prim/fun/transpose.hpp>
+#include <stan/math/prim/fun/multiply_lower_tri_self_transpose.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/norm.hpp b/stan/math/fwd/fun/norm.hpp
index 1de3e640223..6a087506c0a 100644
--- a/stan/math/fwd/fun/norm.hpp
+++ b/stan/math/fwd/fun/norm.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_FWD_FUN_NORM_HPP
 
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/norm.hpp>
 #include <complex>
 
diff --git a/stan/math/fwd/fun/norm1.hpp b/stan/math/fwd/fun/norm1.hpp
index a4c35dcddd7..151216f2f12 100644
--- a/stan/math/fwd/fun/norm1.hpp
+++ b/stan/math/fwd/fun/norm1.hpp
@@ -1,14 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_NORM1_HPP
 #define STAN_MATH_FWD_FUN_NORM1_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/norm1.hpp>
 #include <stan/math/prim/fun/sign.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/norm1.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/norm2.hpp b/stan/math/fwd/fun/norm2.hpp
index 7d78d7b7ce7..3ba8200363a 100644
--- a/stan/math/fwd/fun/norm2.hpp
+++ b/stan/math/fwd/fun/norm2.hpp
@@ -1,12 +1,12 @@
 #ifndef STAN_MATH_FWD_FUN_NORM2_HPP
 #define STAN_MATH_FWD_FUN_NORM2_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/norm2.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/norm2.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/owens_t.hpp b/stan/math/fwd/fun/owens_t.hpp
index 42c5898ed15..3793697dbd9 100644
--- a/stan/math/fwd/fun/owens_t.hpp
+++ b/stan/math/fwd/fun/owens_t.hpp
@@ -3,10 +3,11 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/erf.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/erf.hpp>
 #include <stan/math/prim/fun/owens_t.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
@@ -23,8 +24,6 @@ namespace math {
  */
 template <typename T>
 inline fvar<T> owens_t(const fvar<T>& x1, const fvar<T>& x2) {
-  using std::exp;
-
   T neg_x1_sq_div_2 = -square(x1.val_) * 0.5;
   T one_p_x2_sq = 1.0 + square(x2.val_);
   return fvar<T>(owens_t(x1.val_, x2.val_),
@@ -45,8 +44,6 @@ inline fvar<T> owens_t(const fvar<T>& x1, const fvar<T>& x2) {
  */
 template <typename T>
 inline fvar<T> owens_t(double x1, const fvar<T>& x2) {
-  using std::exp;
-
   T neg_x1_sq_div_2 = -square(x1) * 0.5;
   T one_p_x2_sq = 1.0 + square(x2.val_);
   return fvar<T>(
@@ -64,8 +61,6 @@ inline fvar<T> owens_t(double x1, const fvar<T>& x2) {
  */
 template <typename T>
 inline fvar<T> owens_t(const fvar<T>& x1, double x2) {
-  using std::exp;
-
   T neg_x1_sq_div_2 = -square(x1.val_) * 0.5;
   return fvar<T>(owens_t(x1.val_, x2),
                  -x1.d_
diff --git a/stan/math/fwd/fun/polar.hpp b/stan/math/fwd/fun/polar.hpp
index 891c2f0d500..2728e6ded8d 100644
--- a/stan/math/fwd/fun/polar.hpp
+++ b/stan/math/fwd/fun/polar.hpp
@@ -3,6 +3,9 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
+#include <stan/math/fwd/fun/is_inf.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
 #include <stan/math/prim/fun/polar.hpp>
 #include <complex>
 #include <type_traits>
diff --git a/stan/math/fwd/fun/pow.hpp b/stan/math/fwd/fun/pow.hpp
index c2056c9f5cf..12337c3d3ba 100644
--- a/stan/math/fwd/fun/pow.hpp
+++ b/stan/math/fwd/fun/pow.hpp
@@ -30,8 +30,6 @@ template <typename T1, typename T2,
           require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr,
           require_all_stan_scalar_t<T1, T2>* = nullptr>
 inline auto pow(const T1& x1, const T2& x2) {
-  using std::log;
-  using std::pow;
   if constexpr (is_complex<T1>::value || is_complex<T2>::value) {
     return internal::complex_pow(x1, x2);
   } else if constexpr (is_fvar<T1>::value && is_fvar<T2>::value) {
@@ -43,23 +41,17 @@ inline auto pow(const T1& x1, const T2& x2) {
     auto u = stan::math::pow(x1, x2.val_);
     return T2(u, x2.d_ * stan::math::log(x1) * u);
   } else {
-    using std::sqrt;
     if (x2 == -2) {
       return stan::math::inv_square(x1);
-    }
-    if (x2 == -1) {
+    } else if (x2 == -1) {
       return stan::math::inv(x1);
-    }
-    if (x2 == -0.5) {
+    } else if (x2 == -0.5) {
       return stan::math::inv_sqrt(x1);
-    }
-    if (x2 == 0.5) {
+    } else if (x2 == 0.5) {
       return stan::math::sqrt(x1);
-    }
-    if (x2 == 1.0) {
+    } else if (x2 == 1.0) {
       return x1;
-    }
-    if (x2 == 2.0) {
+    } else if (x2 == 2.0) {
       return stan::math::square(x1);
     }
     return T1(stan::math::pow(x1.val_, x2),
diff --git a/stan/math/fwd/fun/proj.hpp b/stan/math/fwd/fun/proj.hpp
index 931d2dc4b72..d07ee0aa004 100644
--- a/stan/math/fwd/fun/proj.hpp
+++ b/stan/math/fwd/fun/proj.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_FWD_FUN_PROJ_HPP
 
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/is_inf.hpp>
 #include <stan/math/prim/fun/proj.hpp>
 #include <complex>
 
diff --git a/stan/math/fwd/fun/rising_factorial.hpp b/stan/math/fwd/fun/rising_factorial.hpp
index 461665edce1..f816c0b53cb 100644
--- a/stan/math/fwd/fun/rising_factorial.hpp
+++ b/stan/math/fwd/fun/rising_factorial.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/rising_factorial.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/round.hpp b/stan/math/fwd/fun/round.hpp
index 31d0108263e..35f31fdbc56 100644
--- a/stan/math/fwd/fun/round.hpp
+++ b/stan/math/fwd/fun/round.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/is_nan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/is_nan.hpp>
 #include <stan/math/prim/fun/round.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/sin.hpp b/stan/math/fwd/fun/sin.hpp
index c938cf4948d..a208ff190be 100644
--- a/stan/math/fwd/fun/sin.hpp
+++ b/stan/math/fwd/fun/sin.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/sinh.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
 #include <stan/math/prim/fun/sin.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> sin(const fvar<T>& x) {
-  using std::cos;
-  using std::sin;
   return fvar<T>(sin(x.val_), x.d_ * cos(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/sinh.hpp b/stan/math/fwd/fun/sinh.hpp
index 0a7e6d4343a..15c114ec7ab 100644
--- a/stan/math/fwd/fun/sinh.hpp
+++ b/stan/math/fwd/fun/sinh.hpp
@@ -1,9 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_SINH_HPP
 #define STAN_MATH_FWD_FUN_SINH_HPP
 
-#include <stan/math/prim/fun/sinh.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/cosh.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/prim/fun/sinh.hpp>
 #include <complex>
 
 namespace stan {
@@ -11,8 +13,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> sinh(const fvar<T>& x) {
-  using std::cosh;
-  using std::sinh;
   return fvar<T>(sinh(x.val_), x.d_ * cosh(x.val_));
 }
 
diff --git a/stan/math/fwd/fun/softmax.hpp b/stan/math/fwd/fun/softmax.hpp
index 3e1f4c93ef5..3625332ddf2 100644
--- a/stan/math/fwd/fun/softmax.hpp
+++ b/stan/math/fwd/fun/softmax.hpp
@@ -1,12 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_SOFTMAX_HPP
 #define STAN_MATH_FWD_FUN_SOFTMAX_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/value_of.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/softmax.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/softmax.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/sqrt.hpp b/stan/math/fwd/fun/sqrt.hpp
index aa8fa0abc5c..81d0f187423 100644
--- a/stan/math/fwd/fun/sqrt.hpp
+++ b/stan/math/fwd/fun/sqrt.hpp
@@ -3,10 +3,11 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/inv_sqrt.hpp>
-#include <stan/math/prim/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
 #include <stan/math/fwd/fun/inv_sqrt.hpp>
-#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
+#include <stan/math/fwd/fun/hypot.hpp>
+#include <stan/math/prim/fun/sqrt.hpp>
 #include <cmath>
 #include <complex>
 
@@ -15,7 +16,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> sqrt(const fvar<T>& x) {
-  using std::sqrt;
   if (value_of_rec(x.val_) == 0.0) {
     return fvar<T>(sqrt(x.val_), 0.0 * x.d_);
   }
diff --git a/stan/math/fwd/fun/sum.hpp b/stan/math/fwd/fun/sum.hpp
index 36eef6ad687..ad587cdb91e 100644
--- a/stan/math/fwd/fun/sum.hpp
+++ b/stan/math/fwd/fun/sum.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_FWD_FUN_SUM_HPP
 #define STAN_MATH_FWD_FUN_SUM_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/sum.hpp>
 #include <vector>
 
diff --git a/stan/math/fwd/fun/tan.hpp b/stan/math/fwd/fun/tan.hpp
index 503ca10e2ef..b19cd576969 100644
--- a/stan/math/fwd/fun/tan.hpp
+++ b/stan/math/fwd/fun/tan.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
+#include <stan/math/fwd/fun/tanh.hpp>
 #include <stan/math/prim/fun/tan.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +14,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> tan(const fvar<T>& x) {
-  using std::cos;
-  using std::tan;
   return fvar<T>(tan(x.val_), x.d_ / (cos(x.val_) * cos(x.val_)));
 }
 
diff --git a/stan/math/fwd/fun/tanh.hpp b/stan/math/fwd/fun/tanh.hpp
index 9bb120ba4e3..9699163b226 100644
--- a/stan/math/fwd/fun/tanh.hpp
+++ b/stan/math/fwd/fun/tanh.hpp
@@ -13,7 +13,6 @@ namespace math {
 
 template <typename T>
 inline fvar<T> tanh(const fvar<T>& x) {
-  using std::tanh;
   T u = tanh(x.val_);
   return fvar<T>(u, x.d_ * (1 - u * u));
 }
diff --git a/stan/math/fwd/fun/tcrossprod.hpp b/stan/math/fwd/fun/tcrossprod.hpp
index f25b4036576..c5fdb3e66b0 100644
--- a/stan/math/fwd/fun/tcrossprod.hpp
+++ b/stan/math/fwd/fun/tcrossprod.hpp
@@ -1,11 +1,11 @@
 #ifndef STAN_MATH_FWD_FUN_TCROSSPROD_HPP
 #define STAN_MATH_FWD_FUN_TCROSSPROD_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/transpose.hpp>
-#include <stan/math/fwd/fun/multiply.hpp>
 
 namespace stan {
 namespace math {
@@ -18,7 +18,13 @@ tcrossprod(const EigMat& m) {
     return {};
   }
   const auto& m_ref = to_ref(m);
-  return m_ref * m_ref.transpose();
+  auto ret = multiply(m_ref, m_ref.transpose());
+  if constexpr (is_stan_scalar<decltype(ret)>::value) {
+    return Eigen::Matrix<value_type_t<EigMat>, EigMat::RowsAtCompileTime,
+                         EigMat::RowsAtCompileTime>{{ret}};
+  } else {
+    return ret;
+  }
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/tgamma.hpp b/stan/math/fwd/fun/tgamma.hpp
index ef9d2f0b173..0f89977edcd 100644
--- a/stan/math/fwd/fun/tgamma.hpp
+++ b/stan/math/fwd/fun/tgamma.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/digamma.hpp>
 #include <stan/math/prim/fun/tgamma.hpp>
-#include <boost/math/special_functions/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/to_fvar.hpp b/stan/math/fwd/fun/to_fvar.hpp
index 103936b148b..3c4c9226e09 100644
--- a/stan/math/fwd/fun/to_fvar.hpp
+++ b/stan/math/fwd/fun/to_fvar.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_FWD_FUN_TO_FVAR_HPP
 #define STAN_MATH_FWD_FUN_TO_FVAR_HPP
 
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/err.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/trace_quad_form.hpp b/stan/math/fwd/fun/trace_quad_form.hpp
index 5720ddc6734..f10a0dbc1c4 100644
--- a/stan/math/fwd/fun/trace_quad_form.hpp
+++ b/stan/math/fwd/fun/trace_quad_form.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_FWD_FUN_TRACE_QUAD_FORM_HPP
 #define STAN_MATH_FWD_FUN_TRACE_QUAD_FORM_HPP
 
-#include <stan/math/prim/err.hpp>
+#include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
-#include <stan/math/prim/fun/multiply.hpp>
+#include <stan/math/fwd/fun/sum.hpp>
+#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/transpose.hpp>
 #include <stan/math/prim/fun/trace.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/fwd/core.hpp>
 
 namespace stan {
 namespace math {
@@ -20,7 +20,7 @@ inline return_type_t<EigMat1, EigMat2> trace_quad_form(const EigMat1& A,
   check_square("trace_quad_form", "A", A);
   check_multiplicable("trace_quad_form", "A", A, "B", B);
   const auto& B_ref = to_ref(B);
-  return B_ref.cwiseProduct(multiply(A, B_ref)).sum();
+  return sum(B_ref.cwiseProduct(multiply(A, B_ref)));
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/trigamma.hpp b/stan/math/fwd/fun/trigamma.hpp
index 3f60c14a9f5..b1a4f6dea2d 100644
--- a/stan/math/fwd/fun/trigamma.hpp
+++ b/stan/math/fwd/fun/trigamma.hpp
@@ -3,6 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/inv.hpp>
+#include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
+#include <stan/math/fwd/fun/inv_square.hpp>
 #include <stan/math/prim/fun/trigamma.hpp>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/value_of.hpp b/stan/math/fwd/fun/value_of.hpp
index e8ad84e0f67..ad3b68f19dc 100644
--- a/stan/math/fwd/fun/value_of.hpp
+++ b/stan/math/fwd/fun/value_of.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
-
+#include <stan/math/prim/fun/value_of.hpp>
 namespace stan {
 namespace math {
 
diff --git a/stan/math/fwd/fun/value_of_rec.hpp b/stan/math/fwd/fun/value_of_rec.hpp
index 811836c57ff..27c297b8fa7 100644
--- a/stan/math/fwd/fun/value_of_rec.hpp
+++ b/stan/math/fwd/fun/value_of_rec.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_FWD_FUN_VALUE_OF_REC_HPP
 #define STAN_MATH_FWD_FUN_VALUE_OF_REC_HPP
 
-#include <stan/math/prim/fun/value_of_rec.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/fun/value_of_rec.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/mix/fun/typedefs.hpp b/stan/math/mix/fun/typedefs.hpp
index ddf7ea5d793..a03fd87f3eb 100644
--- a/stan/math/mix/fun/typedefs.hpp
+++ b/stan/math/mix/fun/typedefs.hpp
@@ -2,8 +2,8 @@
 #define STAN_MATH_MIX_MAT_FUN_TYPEDEFS_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/fwd/core.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/Eigen_NumTraits.hpp>
 
 namespace stan {
diff --git a/stan/math/mix/functor/derivative.hpp b/stan/math/mix/functor/derivative.hpp
index 868d1591716..478063fe82b 100644
--- a/stan/math/mix/functor/derivative.hpp
+++ b/stan/math/mix/functor/derivative.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_DERIVATIVE_HPP
 #define STAN_MATH_MIX_FUNCTOR_DERIVATIVE_HPP
 
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp b/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp
index 108b059149c..8c38ed5477f 100644
--- a/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp
+++ b/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp
@@ -2,9 +2,9 @@
 #define STAN_MATH_MIX_FUNCTOR_FINITE_DIFF_GRAD_HESSIAN_AUTO_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/mix/functor/hessian.hpp>
+#include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/mix/functor/grad_hessian.hpp b/stan/math/mix/functor/grad_hessian.hpp
index 9fcf47ba1f6..d8abb272feb 100644
--- a/stan/math/mix/functor/grad_hessian.hpp
+++ b/stan/math/mix/functor/grad_hessian.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_GRAD_HESSIAN_HPP
 #define STAN_MATH_MIX_FUNCTOR_GRAD_HESSIAN_HPP
 
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
 #include <stdexcept>
 #include <vector>
 
diff --git a/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp b/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp
index 1463a21e150..c8f72b98a00 100644
--- a/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp
+++ b/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_GRAD_TR_MAT_TIMES_HESSIAN_HPP
 #define STAN_MATH_MIX_FUNCTOR_GRAD_TR_MAT_TIMES_HESSIAN_HPP
 
+#include <stan/math/mix/functor/gradient_dot_vector.hpp>
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/mix/functor/gradient_dot_vector.hpp>
 #include <stdexcept>
 #include <vector>
 
diff --git a/stan/math/mix/functor/gradient_dot_vector.hpp b/stan/math/mix/functor/gradient_dot_vector.hpp
index 99124607053..b664effd19b 100644
--- a/stan/math/mix/functor/gradient_dot_vector.hpp
+++ b/stan/math/mix/functor/gradient_dot_vector.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_GRADIENT_DOT_VECTOR_HPP
 #define STAN_MATH_MIX_FUNCTOR_GRADIENT_DOT_VECTOR_HPP
 
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/mix/functor/hessian.hpp b/stan/math/mix/functor/hessian.hpp
index d885d49e224..601444384ea 100644
--- a/stan/math/mix/functor/hessian.hpp
+++ b/stan/math/mix/functor/hessian.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_HESSIAN_HPP
 #define STAN_MATH_MIX_FUNCTOR_HESSIAN_HPP
 
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
 #include <stdexcept>
 
 namespace stan {
diff --git a/stan/math/mix/functor/hessian_times_vector.hpp b/stan/math/mix/functor/hessian_times_vector.hpp
index ebcc0f3933f..5d3bf9fb567 100644
--- a/stan/math/mix/functor/hessian_times_vector.hpp
+++ b/stan/math/mix/functor/hessian_times_vector.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_HESSIAN_TIMES_VECTOR_HPP
 #define STAN_MATH_MIX_FUNCTOR_HESSIAN_TIMES_VECTOR_HPP
 
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
 #include <stdexcept>
 #include <vector>
 
diff --git a/stan/math/mix/functor/partial_derivative.hpp b/stan/math/mix/functor/partial_derivative.hpp
index 8cec018dca3..dfa428c2185 100644
--- a/stan/math/mix/functor/partial_derivative.hpp
+++ b/stan/math/mix/functor/partial_derivative.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_PARTIAL_DERIVATIVE_HPP
 #define STAN_MATH_MIX_FUNCTOR_PARTIAL_DERIVATIVE_HPP
 
+#include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/core.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/mix/meta.hpp b/stan/math/mix/meta.hpp
index 3ca1e63ce70..f0622433c71 100644
--- a/stan/math/mix/meta.hpp
+++ b/stan/math/mix/meta.hpp
@@ -3,16 +3,16 @@
 
 #include <stan/math/prim/meta/ad_promotable.hpp>
 
-#include <stan/math/fwd/core.hpp>
-#include <stan/math/fwd/meta/is_fvar.hpp>
-#include <stan/math/fwd/meta/partials_type.hpp>
-
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta/is_var.hpp>
 #include <stan/math/rev/meta/partials_type.hpp>
+#include <stan/math/rev/meta.hpp>
+
+#include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/meta/is_fvar.hpp>
+#include <stan/math/fwd/meta/partials_type.hpp>
 
 #include <stan/math/fwd/meta.hpp>
-#include <stan/math/rev/meta.hpp>
 #include <stan/math/prim/meta.hpp>
 
 #endif
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 317fd6a846d..fca073133ec 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -34,9 +34,9 @@ inline T abs(T x) {
  * @param x argument
  * @return absolute value of argument (a real number)
  */
-template <typename T, require_complex_t<T>* = nullptr>
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
 inline auto abs(T x) {
-  return hypot(x.real(), x.imag());
+  return std::hypot(x.real(), x.imag());
 }
 
 /**
@@ -62,10 +62,7 @@ struct abs_fun {
  * @param x argument
  * @return Absolute value of each variable in the container.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_not_stan_scalar_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto abs(const Container& x) {
   return apply_scalar_unary<abs_fun, Container>::apply(x);
 }
@@ -79,7 +76,7 @@ inline auto abs(const Container& x) {
  * @return Absolute value of each variable in the container.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto abs(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [&](const auto& v) { return v.array().abs(); });
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 1dd3c348b84..1efa76b5174 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -18,6 +18,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the arc cosine of the arithmetic argument.
+ *
+ * @tparam V An `Arithmetic` argument
+ * @param[in] x argument
+ * @return arc cosine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto acos(const T x) {
+  return std::acos(x);
+}
+
+/**
+ * Return the arc cosine of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return arc cosine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto acos(const T x) {
+  return std::acos(x);
+}
+
 /**
  * Structure to wrap `acos()` so it can be vectorized.
  *
@@ -28,7 +52,6 @@ namespace math {
 struct acos_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::acos;
     return acos(x);
   }
 };
@@ -41,11 +64,7 @@ struct acos_fun {
  * @param x argument
  * @return Arc cosine of each variable in the container, in radians.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto acos(const Container& x) {
   return apply_scalar_unary<acos_fun, Container>::apply(x);
 }
@@ -59,7 +78,7 @@ inline auto acos(const Container& x) {
  * @return Arc cosine of each variable in the container, in radians.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto acos(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().acos(); });
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 2869fc842b7..5580e9e1e73 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -19,11 +19,12 @@ namespace math {
  * Return the inverse hyperbolic cosine of the specified value.
  * Returns nan for nan argument.
  *
- * @param[in] x Argument.
+ * @param[in] x `Arithmetic` Argument.
  * @return Inverse hyperbolic cosine of the argument.
  * @throw std::domain_error If argument is less than 1.
  */
-inline double acosh(double x) {
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline double acosh(const T x) {
   if (is_nan(x)) {
     return x;
   } else {
@@ -37,23 +38,16 @@ inline double acosh(double x) {
 }
 
 /**
- * Integer version of acosh.
+ * Return the inverse hyperbolic cosine of the specified value.
+ * Returns nan for nan argument.
  *
- * @param[in] x Argument.
+ * @param[in] x `complex<Arithmetic>` Argument.
  * @return Inverse hyperbolic cosine of the argument.
  * @throw std::domain_error If argument is less than 1.
  */
-inline double acosh(int x) {
-  if (is_nan(x)) {
-    return x;
-  } else {
-    check_greater_or_equal("acosh", "x", x, 1);
-#ifdef _WIN32
-    if (is_inf(x))
-      return x;
-#endif
-    return std::acosh(x);
-  }
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto acosh(const T x) {
+  return std::acosh(x);
 }
 
 /**
@@ -83,13 +77,27 @@ struct acosh_fun {
  * @param x container
  * @return Elementwise acosh of members of container.
  */
-template <
-    typename T, require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto acosh(const T& x) {
   return apply_scalar_unary<acosh_fun, T>::apply(x);
 }
 
+/**
+ * Return the elementwise application of <code>acosh()</code> to
+ * specified argument container.  The return type promotes the
+ * underlying scalar argument type to double if it is an integer,
+ * and otherwise is the argument type.
+ *
+ * @tparam T type of container
+ * @param x container
+ * @return Elementwise acosh of members of container.
+ */
+template <typename Container,
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
+inline auto acosh(const Container& x) {
+  return apply_scalar_unary<acosh_fun, Container>::apply(x);
+}
+
 namespace internal {
 
 /**
diff --git a/stan/math/prim/fun/arg.hpp b/stan/math/prim/fun/arg.hpp
index 718aa48ee10..cf0e79fa12b 100644
--- a/stan/math/prim/fun/arg.hpp
+++ b/stan/math/prim/fun/arg.hpp
@@ -1,6 +1,7 @@
 #ifndef STAN_MATH_PRIM_FUN_ARG_HPP
 #define STAN_MATH_PRIM_FUN_ARG_HPP
 
+#include <stan/math/prim/fun/atan2.hpp>
 #include <cmath>
 #include <complex>
 
@@ -13,7 +14,7 @@ namespace math {
  * @param[in] z argument
  * @return phase angle of the argument
  */
-template <typename V>
+template <typename V, require_arithmetic_t<V>* = nullptr>
 inline V arg(const std::complex<V>& z) {
   return std::arg(z);
 }
@@ -28,7 +29,6 @@ namespace internal {
  */
 template <typename V>
 inline V complex_arg(const std::complex<V>& z) {
-  using std::atan2;
   return atan2(z.imag(), z.real());
 }
 }  // namespace internal
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index e34afb1f1c0..f620a24d2af 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -16,6 +16,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the arc sine of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return arc sine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto asin(const T x) {
+  return std::asin(x);
+}
+
+/**
+ * Return the arc sine of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic> argument
+ * @param[in] x argument
+ * @return arc sine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto asin(const T x) {
+  return std::asin(x);
+}
+
 /**
  * Structure to wrap `asin()` so it can be vectorized.
  *
@@ -26,7 +50,6 @@ namespace math {
 struct asin_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::asin;
     return asin(x);
   }
 };
@@ -39,11 +62,7 @@ struct asin_fun {
  * @param x container
  * @return Arcsine of each variable in the container, in radians.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto asin(const Container& x) {
   return apply_scalar_unary<asin_fun, Container>::apply(x);
 }
@@ -57,7 +76,7 @@ inline auto asin(const Container& x) {
  * @return Arcsine of each variable in the container, in radians.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto asin(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().asin(); });
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index cc8d0d02543..ab72065efae 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -19,6 +19,29 @@
 
 namespace stan {
 namespace math {
+/**
+ * Return the hyperbolic arc sine of the arithmetic argument.
+ *
+ * @tparam V An arithmetic type
+ * @param[in] x argument
+ * @return hyperbolic arc sine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto asinh(const T x) {
+  return std::asinh(x);
+}
+
+/**
+ * Return the hyperbolic arc sine of the complex argument.
+ *
+ * @tparam V a complex type with inner arithmetic type.
+ * @param[in] x argument
+ * @return hyperbolic arc sine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto asinh(const T x) {
+  return std::asinh(x);
+}
 
 /**
  * Structure to wrap `asinh()` so it can be vectorized.
@@ -30,7 +53,6 @@ namespace math {
 struct asinh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::asinh;
     return asinh(x);
   }
 };
@@ -43,13 +65,25 @@ struct asinh_fun {
  * @param x container
  * @return Inverse hyperbolic sine of each value in the container.
  */
-template <
-    typename T, require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto asinh(const T& x) {
   return apply_scalar_unary<asinh_fun, T>::apply(x);
 }
 
+/**
+ * Returns the elementwise `asinh()` of the input,
+ * which may be a scalar or any Stan container of numeric scalars.
+ *
+ * @tparam T type of container
+ * @param x container
+ * @return Inverse hyperbolic sine of each value in the container.
+ */
+template <typename Container,
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
+inline auto asinh(const Container& x) {
+  return apply_scalar_unary<asinh_fun, Container>::apply(x);
+}
+
 namespace internal {
 /**
  * Return the hyperbolic arc sine of the complex argument.
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 3adc5cb14c8..9e7099b7d43 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_PRIM_FUN_ATAN_HPP
 #define STAN_MATH_PRIM_FUN_ATAN_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/core.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/atanh.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/i_times.hpp>
 #include <stan/math/prim/functor/apply_scalar_unary.hpp>
 #include <stan/math/prim/functor/apply_vector_unary.hpp>
@@ -14,6 +14,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the arc tangent of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return arc tangent of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto atan(const T x) {
+  return std::atan(x);
+}
+
+/**
+ * Return the arc tangent of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return arc tangent of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto atan(const T x) {
+  return std::atan(x);
+}
+
 /**
  * Structure to wrap \c atan() so it can be vectorized.
  *
@@ -24,7 +48,6 @@ namespace math {
 struct atan_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::atan;
     return atan(x);
   }
 };
@@ -37,11 +60,7 @@ struct atan_fun {
  * @param x container
  * @return Arctan of each value in x, in radians.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto atan(const Container& x) {
   return apply_scalar_unary<atan_fun, Container>::apply(x);
 }
@@ -55,7 +74,7 @@ inline auto atan(const Container& x) {
  * @return Elementwise atan of members of container.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto atan(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().atan(); });
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index 0aad7199435..fdf6c4df9b5 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -20,11 +20,12 @@ namespace math {
  * returns infinity.
  * Returns nan for nan argument.
  *
- * @param[in] x Argument.
+ * @param[in] x `Arithmetic` Argument.
  * @return Inverse hyperbolic tangent of the argument.
  * @throw std::domain_error If argument is not in [-1, 1].
  */
-inline double atanh(double x) {
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline double atanh(const T x) {
   if (is_nan(x)) {
     return x;
   } else {
@@ -34,14 +35,17 @@ inline double atanh(double x) {
 }
 
 /**
- * Integer version of atanh.
+ * Return the inverse hyperbolic tangent of the specified value.
+ * An argument of -1 returns negative infinity and an argument of 1
+ * returns infinity.
+ * Returns nan for nan argument.
  *
- * @param[in] x Argument.
+ * @param[in] x `complex<Arithmetic>` Argument.
  * @return Inverse hyperbolic tangent of the argument.
- * @throw std::domain_error If argument is less than 1.
+ * @throw std::domain_error If argument is not in [-1, 1].
  */
-inline double atanh(int x) {
-  check_bounded("atanh", "x", x, -1, 1);
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto atanh(const T x) {
   return std::atanh(x);
 }
 
@@ -72,13 +76,27 @@ struct atanh_fun {
  * @param x container
  * @return Elementwise atanh of members of container.
  */
-template <
-    typename T, require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto atanh(const T& x) {
   return apply_scalar_unary<atanh_fun, T>::apply(x);
 }
 
+/**
+ * Return the elementwise application of <code>atanh()</code> to
+ * specified argument container.  The return type promotes the
+ * underlying scalar argument type to double if it is an integer,
+ * and otherwise is the argument type.
+ *
+ * @tparam T type of container
+ * @param x container
+ * @return Elementwise atanh of members of container.
+ */
+template <typename Container,
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
+inline auto atanh(const Container& x) {
+  return apply_scalar_unary<atanh_fun, Container>::apply(x);
+}
+
 namespace internal {
 /**
  * Return the hyperbolic arc tangent of the complex argument.
diff --git a/stan/math/prim/fun/conj.hpp b/stan/math/prim/fun/conj.hpp
index 49a569e757c..ebb9ac28222 100644
--- a/stan/math/prim/fun/conj.hpp
+++ b/stan/math/prim/fun/conj.hpp
@@ -1,8 +1,8 @@
 #ifndef STAN_MATH_PRIM_FUN_CONJ_HPP
 #define STAN_MATH_PRIM_FUN_CONJ_HPP
 
-#include <complex>
 #include <stan/math/prim/meta.hpp>
+#include <complex>
 
 namespace stan {
 namespace math {
@@ -14,21 +14,38 @@ namespace math {
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
-template <typename V>
-inline std::complex<V> conj(const std::complex<V>& z) {
+template <typename V, require_complex_bt<std::is_arithmetic, V>* = nullptr>
+inline auto conj(const V& z) {
   return std::conj(z);
 }
 
+/**
+ * Return the complex conjugate the complex argument.
+ *
+ * @tparam V value type of argument
+ * @param[in] z argument
+ * @return complex conjugate of the argument
+ */
+template <typename V, require_complex_bt<is_autodiff, V>* = nullptr>
+inline V conj(const V& z) {
+  return {z.real(), -z.imag()};
+}
+
 /**
  * Return the complex conjugate the Eigen object.
  *
- * @tparam Eig A type derived from `Eigen::EigenBase`
+ * @tparam Eig A type derived from `Eigen::EigenBase` with an inner complex
+ * autodiff type.
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
 template <typename Eig, require_eigen_vt<is_complex, Eig>* = nullptr>
-inline auto conj(const Eig& z) {
-  return z.conjugate();
+inline auto conj(Eig&& z) {
+  return make_holder(
+      [](auto&& z_inner) {
+        return z_inner.unaryExpr([](auto&& z_i) { return conj(z_i); });
+      },
+      std::forward<Eig>(z));
 }
 
 /**
@@ -40,25 +57,14 @@ inline auto conj(const Eig& z) {
  */
 template <typename StdVec, require_std_vector_st<is_complex, StdVec>* = nullptr>
 inline auto conj(const StdVec& z) {
-  promote_scalar_t<scalar_type_t<StdVec>, StdVec> result(z.size());
-  std::transform(z.begin(), z.end(), result.begin(),
-                 [](auto&& x) { return stan::math::conj(x); });
+  const auto z_size = z.size();
+  promote_scalar_t<scalar_type_t<StdVec>, StdVec> result(z_size);
+  for (std::size_t i = 0; i < z_size; ++i) {
+    result[i] = conj(z[i]);
+  }
   return result;
 }
 
-namespace internal {
-/**
- * Return the complex conjugate the complex argument.
- *
- * @tparam V value type of argument
- * @param[in] z argument
- * @return complex conjugate of the argument
- */
-template <typename V>
-inline std::complex<V> complex_conj(const std::complex<V>& z) {
-  return {z.real(), -z.imag()};
-}
-}  // namespace internal
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index 33046c6d180..0a3b044ccdc 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -13,6 +13,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the cosine of the arithmetic argument.
+ *
+ * @tparam T An arithmetic argument
+ * @param[in] x argument
+ * @return cosine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto cos(const T x) {
+  return std::cos(x);
+}
+
+/**
+ * Return the cosine of the complex argument.
+ *
+ * @tparam T `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return cosine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto cos(const T x) {
+  return std::cos(x);
+}
+
 /**
  * Structure to wrap `cos()` so it can be vectorized.
  *
@@ -23,7 +47,6 @@ namespace math {
 struct cos_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::cos;
     return cos(x);
   }
 };
@@ -36,11 +59,7 @@ struct cos_fun {
  * @param x angles in radians
  * @return Cosine of each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto cos(const Container& x) {
   return apply_scalar_unary<cos_fun, Container>::apply(x);
 }
@@ -54,7 +73,7 @@ inline auto cos(const Container& x) {
  * @return Cosine of each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto cos(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [&](const auto& v) { return v.array().cos(); });
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index 62f76a21fbc..ae60c233a68 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -12,6 +12,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the hyperbolic cosine of the arithmetic argument.
+ *
+ * @tparam V An arithmetic type
+ * @param[in] x argument
+ * @return hyperbolic cosine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto cosh(const T x) {
+  return std::cosh(x);
+}
+
+/**
+ * Return the hyperbolic cosine of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` type of argument
+ * @param[in] x argument
+ * @return hyperbolic cosine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto cosh(const T x) {
+  return std::cosh(x);
+}
+
 /**
  * Structure to wrap `cosh()` so it can be vectorized.
  *
@@ -22,7 +46,6 @@ namespace math {
 struct cosh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::cosh;
     return cosh(x);
   }
 };
@@ -35,11 +58,7 @@ struct cosh_fun {
  * @param x angles in radians
  * @return Hyberbolic cosine of x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto cosh(const Container& x) {
   return apply_scalar_unary<cosh_fun, Container>::apply(x);
 }
@@ -53,7 +72,7 @@ inline auto cosh(const Container& x) {
  * @return Hyberbolic cosine of x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto cosh(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().cosh(); });
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index eed21f36914..d12d82cb556 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -11,6 +11,35 @@
 
 namespace stan {
 namespace math {
+
+/**
+ * Return the natural (base e) exponentiation of the specified
+ * complex argument.
+ *
+ * @tparam V `Arithmetic` type
+ * @param x input
+ * @return natural exponentiation of specified number
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto exp(const T x) {
+  return std::exp(x);
+}
+
+/**
+ * Return the natural (base e) complex exponentiation of the specified
+ * complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` type
+ * @param x complex number
+ * @return natural exponentiation of specified complex number
+ * @see documentation for `std::complex` for boundary condition and
+ * branch cut details
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto exp(const T x) {
+  return std::exp(x);
+}
+
 /**
  * Structure to wrap `exp()` so that it can be
  * vectorized.
@@ -25,7 +54,6 @@ struct exp_fun {
    */
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::exp;
     return exp(x);
   }
 };
@@ -39,11 +67,7 @@ struct exp_fun {
  * @param[in] x container
  * @return Elementwise application of exponentiation to the argument.
  */
-template <
-    typename Container,
-    require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-    require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr,
-    require_not_var_matrix_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto exp(const Container& x) {
   return apply_scalar_unary<exp_fun, Container>::apply(x);
 }
@@ -57,7 +81,7 @@ inline auto exp(const Container& x) {
  * @return Elementwise application of exponentiation to the argument.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto exp(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().exp(); });
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index 6fd4cccc01c..3845bee34b2 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -10,6 +10,15 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto floor(const T x) {
+  return std::floor(x);
+}
+
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto floor(const T x) {
+  return std::floor(x);
+}
 /**
  * Structure to wrap `floor()` so that it can be vectorized.
  *
@@ -20,7 +29,6 @@ namespace math {
 struct floor_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::floor;
     return floor(x);
   }
 };
@@ -33,11 +41,7 @@ struct floor_fun {
  * @param x container
  * @return Greatest integer <= each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto floor(const Container& x) {
   return apply_scalar_unary<floor_fun, Container>::apply(x);
 }
@@ -51,7 +55,7 @@ inline auto floor(const Container& x) {
  * @return Greatest integer <= each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_container_bt<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
 inline auto floor(const Container& x) {
   return apply_vector_unary<Container>::apply(
diff --git a/stan/math/prim/fun/generalized_inverse.hpp b/stan/math/prim/fun/generalized_inverse.hpp
index 9a4ef5a4447..fd03af80007 100644
--- a/stan/math/prim/fun/generalized_inverse.hpp
+++ b/stan/math/prim/fun/generalized_inverse.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/inverse.hpp>
+#include <stan/math/prim/fun/generalized_inverse.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/prim/fun/gp_periodic_cov.hpp b/stan/math/prim/fun/gp_periodic_cov.hpp
index c2dc72745d6..c0be5931535 100644
--- a/stan/math/prim/fun/gp_periodic_cov.hpp
+++ b/stan/math/prim/fun/gp_periodic_cov.hpp
@@ -46,8 +46,6 @@ inline typename Eigen::Matrix<return_type_t<T_x, T_sigma, T_l, T_p>,
                               Eigen::Dynamic, Eigen::Dynamic>
 gp_periodic_cov(const std::vector<T_x> &x, const T_sigma &sigma, const T_l &l,
                 const T_p &p) {
-  using std::exp;
-  using std::sin;
   const char *fun = "gp_periodic_cov";
   check_positive(fun, "signal standard deviation", sigma);
   check_positive(fun, "length-scale", l);
@@ -126,8 +124,6 @@ inline typename Eigen::Matrix<return_type_t<T_x1, T_x2, T_sigma, T_l, T_p>,
                               Eigen::Dynamic, Eigen::Dynamic>
 gp_periodic_cov(const std::vector<T_x1> &x1, const std::vector<T_x2> &x2,
                 const T_sigma &sigma, const T_l &l, const T_p &p) {
-  using std::exp;
-  using std::sin;
   const char *fun = "gp_periodic_cov";
   check_positive(fun, "signal standard deviation", sigma);
   check_positive(fun, "length-scale", l);
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 669c2c41ef0..f197d49c24e 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -45,8 +45,26 @@ namespace math {
  * @param x Argument.
  * @return Inverse complementary log-log of the argument.
  */
-inline double inv_cloglog(double x) {
-  using std::exp;
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto inv_cloglog(const T x) {
+  return 1. - std::exp(-std::exp(x));
+}
+
+/**
+ * The inverse complementary log-log function.
+ *
+ * The function is defined by
+ *
+ * <code>inv_cloglog(x) = 1 - exp(-exp(x))</code>.
+ *
+ * This function can be used to implement the inverse link
+ * function for complementary-log-log regression.
+ *
+ * @param x Argument.
+ * @return Inverse complementary log-log of the argument.
+ */
+template <typename T, require_complex_t<T>* = nullptr>
+inline auto inv_cloglog(const T& x) {
   return 1. - exp(-exp(x));
 }
 
@@ -71,11 +89,7 @@ struct inv_cloglog_fun {
  * @param x container
  * @return 1 - exp(-exp()) applied to each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto inv_cloglog(const Container& x) {
   return apply_scalar_unary<inv_cloglog_fun, Container>::apply(x);
 }
@@ -89,7 +103,7 @@ inline auto inv_cloglog(const Container& x) {
  * @return 1 - exp(-exp()) applied to each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_cloglog(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return 1 - (-v.array().exp()).exp(); });
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index c4e58fcbedb..00fa616a45f 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -12,11 +12,16 @@
 namespace stan {
 namespace math {
 
-template <typename T, require_stan_scalar_t<T>* = nullptr>
-inline auto inv_sqrt(T x) {
-  using std::sqrt;
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto inv_sqrt(const T x) {
+  return inv(std::sqrt(x));
+}
+
+template <typename T, require_complex_t<T>* = nullptr>
+inline auto inv_sqrt(const T x) {
   return inv(sqrt(x));
 }
+
 /**
  * Structure to wrap `1 / sqrt(x)` so that it can be vectorized.
  *
@@ -39,12 +44,7 @@ struct inv_sqrt_fun {
  * @param x container
  * @return inverse square root of each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_not_stan_scalar_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto inv_sqrt(const Container& x) {
   return apply_scalar_unary<inv_sqrt_fun, Container>::apply(x);
 }
@@ -58,7 +58,7 @@ inline auto inv_sqrt(const Container& x) {
  * @return inverse square root each variable in the container.
  */
 template <typename Container, require_not_var_matrix_t<Container>* = nullptr,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_sqrt(const Container& x) {
 // Eigen 3.4.0 has precision issues on ARM64 with vectorised rsqrt
 // Resolved in current master branch, below can be removed on next release
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 75a2dcd00b9..8216cee2aa6 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -16,6 +16,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the natural logarithm of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return natural logarithm of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto log(const T x) {
+  return std::log(x);
+}
+
+/**
+ * Return the natural logarithm of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return natural logarithm of the argument
+ */
+template <typename T, require_complex_t<T>* = nullptr>
+inline auto log(const T x) {
+  return std::log(x);
+}
+
 /**
  * Structure to wrap `log()` so that it can be vectorized.
  */
@@ -29,7 +53,6 @@ struct log_fun {
    */
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::log;
     return log(x);
   }
 };
@@ -43,11 +66,7 @@ struct log_fun {
  * @param[in] x container
  * @return Elementwise application of natural log to the argument.
  */
-template <
-    typename Container,
-    require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-    require_not_var_matrix_t<Container>* = nullptr,
-    require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto log(const Container& x) {
   return apply_scalar_unary<log_fun, Container>::apply(x);
 }
@@ -61,7 +80,7 @@ inline auto log(const Container& x) {
  * @return Natural log of each variable in the container.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto log(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().log(); });
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 02e60664a29..f7d81343ea5 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -12,6 +12,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the base 10 logarithm of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return base 10 logarithm of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto log10(const T x) {
+  return std::log10(x);
+}
+
+/**
+ * Return the base 10 logarithm of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return base 10 logarithm of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto log10(const T x) {
+  return std::log10(x);
+}
+
 /**
  * Structure to wrap log10() so it can be vectorized.
  *
@@ -22,7 +46,6 @@ namespace math {
 struct log10_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::log10;
     return log10(x);
   }
 };
@@ -34,10 +57,7 @@ struct log10_fun {
  * @param x container
  * @return Log base-10 applied to each value in x.
  */
-template <
-    typename Container, require_not_var_matrix_t<Container>* = nullptr,
-    require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-    require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto log10(const Container& x) {
   return apply_scalar_unary<log10_fun, Container>::apply(x);
 }
@@ -51,7 +71,7 @@ inline auto log10(const Container& x) {
  * @return Log base-10 of each variable in the container.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto log10(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().log10(); });
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index e0b9715adf5..3f6f7ce7a8c 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -43,9 +43,9 @@ namespace math {
  * @param u argument
  * @return log odds of argument
  */
-inline double logit(double u) {
-  using std::log;
-  return log(u / (1 - u));
+template <typename T, require_floating_point_t<T>* = nullptr>
+inline double logit(const T u) {
+  return std::log(u / (1 - u));
 }
 
 /**
@@ -54,7 +54,10 @@ inline double logit(double u) {
  * @param u argument
  * @return log odds of argument
  */
-inline double logit(int u) { return logit(static_cast<double>(u)); }
+template <typename T, require_integral_t<T>* = nullptr>
+inline double logit(const T u) {
+  return logit(static_cast<double>(u));
+}
 
 /**
  * Structure to wrap logit() so it can be vectorized.
@@ -83,11 +86,7 @@ struct logit_fun {
  * @param x container
  * @return elementwise logit of container elements
  */
-template <
-    typename Container,
-    require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-    require_not_var_matrix_t<Container>* = nullptr,
-    require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto logit(const Container& x) {
   return apply_scalar_unary<logit_fun, Container>::apply(x);
 }
@@ -104,7 +103,7 @@ inline auto logit(const Container& x) {
  * of scope
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto logit(const Container& x) {
   return make_holder(
       [](const auto& v_ref) {
diff --git a/stan/math/prim/fun/matrix_exp_2x2.hpp b/stan/math/prim/fun/matrix_exp_2x2.hpp
index 7a2c0fd472b..8f020bf71c3 100644
--- a/stan/math/prim/fun/matrix_exp_2x2.hpp
+++ b/stan/math/prim/fun/matrix_exp_2x2.hpp
@@ -24,11 +24,6 @@ namespace math {
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
 Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic, Eigen::Dynamic>
 matrix_exp_2x2(const EigMat& A) {
-  using std::cosh;
-  using std::exp;
-  using std::sinh;
-  using std::sqrt;
-
   using T = value_type_t<EigMat>;
   T a = A(0, 0), b = A(0, 1), c = A(1, 0), d = A(1, 1), delta;
   delta = sqrt(square(a - d) + 4 * b * c);
diff --git a/stan/math/prim/fun/norm.hpp b/stan/math/prim/fun/norm.hpp
index ba2afb2d71e..b006bf1ad4c 100644
--- a/stan/math/prim/fun/norm.hpp
+++ b/stan/math/prim/fun/norm.hpp
@@ -14,7 +14,7 @@ namespace math {
  * @param[in] z argument
  * @return squared magnitude of the argument
  */
-template <typename V>
+template <typename V, require_arithmetic_t<V>* = nullptr>
 inline V norm(const std::complex<V>& z) {
   return std::norm(z);
 }
diff --git a/stan/math/prim/fun/polar.hpp b/stan/math/prim/fun/polar.hpp
index 9ba15ee3aae..e894cc9d203 100644
--- a/stan/math/prim/fun/polar.hpp
+++ b/stan/math/prim/fun/polar.hpp
@@ -1,9 +1,10 @@
 #ifndef STAN_MATH_PRIM_FUN_POLAR_HPP
 #define STAN_MATH_PRIM_FUN_POLAR_HPP
 
+#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/cos.hpp>
 #include <stan/math/prim/fun/is_inf.hpp>
-#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/sin.hpp>
 #include <cmath>
 #include <complex>
 #include <limits>
@@ -20,8 +21,6 @@ namespace internal {
  */
 template <typename U, typename V>
 inline complex_return_t<U, V> complex_polar(const U& r, const V& theta) {
-  using std::cos;
-  using std::sin;
   if (!(r >= 0) || is_inf(theta)) {
     return {std::numeric_limits<double>::quiet_NaN()};
   }
@@ -36,16 +35,8 @@ inline complex_return_t<U, V> complex_polar(const U& r, const V& theta) {
  * @param[in] theta phase angle
  * @return complex number with magnitude and phase angle
  */
-inline std::complex<double> polar(double r, double theta) {
-  return internal::complex_polar(r, theta);
-}
-inline std::complex<double> polar(double r, int theta) {
-  return internal::complex_polar(r, static_cast<double>(theta));
-}
-inline std::complex<double> polar(int r, double theta) {
-  return internal::complex_polar(static_cast<double>(r), theta);
-}
-inline std::complex<double> polar(int r, int theta) {
+template <typename U, typename V, require_all_arithmetic_t<U, V>* = nullptr>
+inline std::complex<double> polar(U r, V theta) {
   return internal::complex_polar(static_cast<double>(r),
                                  static_cast<double>(theta));
 }
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
index 95809bd8830..2cb708c7f5c 100644
--- a/stan/math/prim/fun/pow.hpp
+++ b/stan/math/prim/fun/pow.hpp
@@ -33,42 +33,73 @@ inline complex_return_t<U, V> complex_pow(const U& x, const V& y) {
  * Return the first argument raised to the power of the second
  * argument.
  *
- * @tparam T1 type of first argument
- * @tparam T2 type of second argument
+ * @tparam T1 `complex<Arithmetic>` type
+ * @tparam T2 `complex<Arithmetic>` type
  * @param a first argument
  * @param b second argument
  * @return the first argument raised to the power of the second
  * argument.
  */
-template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
-          require_arithmetic_t<T2>* = nullptr>
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
 inline auto pow(const std::complex<T1>& a, const std::complex<T2>& b) {
   return std::pow(a, b);
 }
 
-template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
-          require_arithmetic_t<T2>* = nullptr>
+/**
+ * Return the first argument raised to the power of the second
+ * argument.
+ *
+ * @tparam T1 `Arithmetic` type
+ * @tparam T2 `complex<Arithmetic>` type
+ * @param a first argument
+ * @param b second argument
+ * @return the first argument raised to the power of the second
+ * argument.
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
 inline auto pow(const T1& a, const std::complex<T2>& b) {
   return std::pow(a, b);
 }
 
-template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
-          require_arithmetic_t<T2>* = nullptr>
+/**
+ * Return the first argument raised to the power of the second
+ * argument.
+ *
+ * @tparam T1 `complex<Arithmetic>` type
+ * @tparam T2 `Arithmetic` type
+ * @param a first argument
+ * @param b second argument
+ * @return the first argument raised to the power of the second
+ * argument.
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
 inline auto pow(const std::complex<T1>& a, const T2& b) {
   return std::pow(a, b);
 }
 
-template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
-          require_arithmetic_t<T2>* = nullptr>
+/**
+ * Return the first argument raised to the power of the second
+ * argument.
+ *
+ * @tparam T1 `Arithmetic` type
+ * @tparam T2 `Arithmetic` type
+ * @param a first argument
+ * @param b second argument
+ * @return the first argument raised to the power of the second
+ * argument.
+ */
+template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
 inline auto pow(const T1& a, const T2& b) {
   return std::pow(a, b);
 }
 /**
  * Returns the elementwise raising of the first argument to the power of the
- * second argument.
+ * second argument. One type must be a `Container` type.
  *
- * @tparam T1 type of first argument
- * @tparam T2 type of second argument
+ * @tparam T1 A `Container` type with a @ref base_type that is `Arithmetic` or
+ * an `Arithmetic`
+ * @tparam T1 A `Container` type with a @ref base_type that is `Arithmetic` or
+ * an `Arithmetic`
  * @param a first argument
  * @param b second argument
  * @return the elementwise raising of the first argument to the power of the
@@ -79,6 +110,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_arithmetic_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
 inline auto pow(const T1& a, const T2& b) {
   return apply_scalar_binary(
+      // Qualified pow since only Arithmetic types are accepted here
       a, b, [](const auto& c, const auto& d) { return stan::math::pow(c, d); });
 }
 }  // namespace math
diff --git a/stan/math/prim/fun/proj.hpp b/stan/math/prim/fun/proj.hpp
index 52c5dce6299..f731830edd5 100644
--- a/stan/math/prim/fun/proj.hpp
+++ b/stan/math/prim/fun/proj.hpp
@@ -15,7 +15,7 @@ namespace math {
  * @param[in] z argument
  * @return projection of the argument onto the Riemann sphere
  */
-template <typename V>
+template <typename V, require_arithmetic_t<V>* = nullptr>
 inline std::complex<V> proj(const std::complex<V>& z) {
   return std::proj(z);
 }
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index b4b92206da9..a0145dd4c6b 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -13,6 +13,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the sine of the complex argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return sine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto sin(const T x) {
+  return std::sin(x);
+}
+
+/**
+ * Return the sine of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return sine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto sin(const T x) {
+  return std::sin(x);
+}
+
 /**
  * Structure to wrap sin() so it can be vectorized.
  *
@@ -23,7 +47,6 @@ namespace math {
 struct sin_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::sin;
     return sin(x);
   }
 };
@@ -35,10 +58,7 @@ struct sin_fun {
  * @param x angles in radians
  * @return Sine of each value in x.
  */
-template <
-    typename T, require_not_container_st<std::is_arithmetic, T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto sin(const T& x) {
   return apply_scalar_unary<sin_fun, T>::apply(x);
 }
@@ -52,7 +72,7 @@ inline auto sin(const T& x) {
  * @return Sine of each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto sin(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [&](const auto& v) { return v.array().sin(); });
@@ -68,6 +88,7 @@ namespace internal {
  */
 template <typename V>
 inline std::complex<V> complex_sin(const std::complex<V>& z) {
+  using namespace stan::math;
   return neg_i_times(sinh(i_times(z)));
 }
 }  // namespace internal
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index 35d917fdd8d..e3e55fa7477 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -11,6 +11,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the hyperbolic sine of the arithmetic argument.
+ *
+ * @tparam V An arithmetic argument
+ * @param[in] x argument
+ * @return hyperbolic sine of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto sinh(const T x) {
+  return std::sinh(x);
+}
+
+/**
+ * Return the hyperbolic sine of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return hyperbolic sine of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto sinh(const T x) {
+  return std::sinh(x);
+}
+
 /**
  * Structure to wrap sinh() so that it can be vectorized.
  *
@@ -21,7 +45,6 @@ namespace math {
 struct sinh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::sinh;
     return sinh(x);
   }
 };
@@ -33,11 +56,7 @@ struct sinh_fun {
  * @param x container
  * @return Hyperbolic sine of each variable in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto sinh(const Container& x) {
   return apply_scalar_unary<sinh_fun, Container>::apply(x);
 }
@@ -51,7 +70,7 @@ inline auto sinh(const Container& x) {
  * @return Hyperbolic sine of each variable in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto sinh(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().sinh(); });
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index 79c2f07aea0..3e1620d2a61 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -11,6 +11,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the square root of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return square root of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto sqrt(const T x) {
+  return std::sqrt(x);
+}
+
+/**
+ * Return the square root of the complex argument.
+ *
+ * @tparam V `complex<Aritmetic>` argument
+ * @param[in] x argument
+ * @return square root of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto sqrt(const T x) {
+  return std::sqrt(x);
+}
+
 /**
  * Structure to wrap `sqrt()` so that it can be vectorized.
  *
@@ -21,7 +45,6 @@ namespace math {
 struct sqrt_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::sqrt;
     return sqrt(x);
   }
 };
@@ -33,11 +56,7 @@ struct sqrt_fun {
  * @param x container
  * @return Square root of each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto sqrt(const Container& x) {
   return apply_scalar_unary<sqrt_fun, Container>::apply(x);
 }
@@ -51,7 +70,7 @@ inline auto sqrt(const Container& x) {
  * @return Square root of each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_container_bt<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
 inline auto sqrt(const Container& x) {
   return apply_vector_unary<Container>::apply(
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index 2ac0105266c..cb14bd77c8b 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -23,7 +23,10 @@ namespace math {
  * @param x Input to square.
  * @return Square of input.
  */
-inline double square(double x) { return std::pow(x, 2); }
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline double square(const T x) {
+  return std::pow(x, 2);
+}
 
 /**
  * Structure to wrap square() so that it can be vectorized.
@@ -46,11 +49,7 @@ struct square_fun {
  * @param x container
  * @return Each value in x squared.
  */
-template <
-    typename Container, require_not_stan_scalar_t<Container>* = nullptr,
-    require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-    require_not_var_matrix_t<Container>* = nullptr,
-    require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto square(const Container& x) {
   return apply_scalar_unary<square_fun, Container>::apply(x);
 }
@@ -64,7 +63,7 @@ inline auto square(const Container& x) {
  * @return Each value in x squared.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto square(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().square(); });
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index a0f63790105..373672eb0c8 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -13,6 +13,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the tangent of the arithmetic argument.
+ *
+ * @tparam V value type of argument
+ * @param[in] x argument
+ * @return tangent of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto tan(const T x) {
+  return std::tan(x);
+}
+
+/**
+ * Return the tangent of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic> argument
+ * @param[in] x argument
+ * @return tangent of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto tan(const T x) {
+  return std::tan(x);
+}
+
 /**
  * Structure to wrap `tan()` so that it can be vectorized.
  *
@@ -23,7 +47,6 @@ namespace math {
 struct tan_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::tan;
     return tan(x);
   }
 };
@@ -35,11 +58,7 @@ struct tan_fun {
  * @param x angles in radians
  * @return Tangent of each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto tan(const Container& x) {
   return apply_scalar_unary<tan_fun, Container>::apply(x);
 }
@@ -53,7 +72,7 @@ inline auto tan(const Container& x) {
  * @return Tangent of each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto tan(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().tan(); });
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index 197f1e581f0..1ae3faff087 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -13,6 +13,30 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the hyperbolic tangent of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] x argument
+ * @return hyperbolic tangent of the argument
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto tanh(const T x) {
+  return std::tanh(x);
+}
+
+/**
+ * Return the hyperbolic tangent of the complex argument.
+ *
+ * @tparam V `complex<Arithmetic>` argument
+ * @param[in] x argument
+ * @return hyperbolic tangent of the argument
+ */
+template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
+inline auto tanh(const T x) {
+  return std::tanh(x);
+}
+
 /**
  * Structure to wrap `tanh()` so that it can be vectorized.
  *
@@ -23,7 +47,6 @@ namespace math {
 struct tanh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::tanh;
     return tanh(x);
   }
 };
@@ -35,11 +58,7 @@ struct tanh_fun {
  * @param x angles in radians
  * @return Hyperbolic tangent of each value in x.
  */
-template <typename Container,
-          require_not_container_st<std::is_arithmetic, Container>* = nullptr,
-          require_not_var_matrix_t<Container>* = nullptr,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto tanh(const Container& x) {
   return apply_scalar_unary<tanh_fun, Container>::apply(x);
 }
@@ -53,7 +72,7 @@ inline auto tanh(const Container& x) {
  * @return Hyperbolic tangent of each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto tanh(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().tanh(); });
@@ -69,7 +88,6 @@ namespace internal {
  */
 template <typename V>
 inline std::complex<V> complex_tanh(const std::complex<V>& z) {
-  using std::exp;
   auto exp_z = exp(z);
   auto exp_neg_z = exp(-z);
   return stan::math::internal::complex_divide(exp_z - exp_neg_z,
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index 1121f64f94f..9a30daab99b 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -35,9 +35,6 @@ namespace math {
  */
 template <typename T>
 inline T trigamma_impl(const T& x) {
-  using std::floor;
-  using std::sin;
-
   double small = 0.0001;
   double large = 5.0;
   T value;
diff --git a/stan/math/prim/meta.hpp b/stan/math/prim/meta.hpp
index 68d89d34ba5..445816ca69a 100644
--- a/stan/math/prim/meta.hpp
+++ b/stan/math/prim/meta.hpp
@@ -110,6 +110,7 @@
 #include <stan/math/prim/meta/is_var_or_arithmetic.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_vector_like.hpp>
+#include <stan/math/prim/meta/is_real.hpp>
 #include <stan/math/prim/meta/is_stan_scalar.hpp>
 #include <stan/math/prim/meta/is_stan_scalar_or_eigen.hpp>
 #include <stan/math/prim/meta/modify_eigen_options.hpp>
diff --git a/stan/math/prim/meta/base_type.hpp b/stan/math/prim/meta/base_type.hpp
index 80cebb44cb0..26f52e875f5 100644
--- a/stan/math/prim/meta/base_type.hpp
+++ b/stan/math/prim/meta/base_type.hpp
@@ -2,7 +2,6 @@
 #define STAN_MATH_PRIM_META_BASE_TYPE_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/meta/is_complex.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
@@ -53,17 +52,5 @@ struct base_type<T, std::enable_if_t<is_eigen<T>::value>> {
   using type = base_type_t<typename std::decay_t<T>::Scalar>;
 };
 
-/**
- * Template metaprogram defining the base type for values
- * stored in a complex number.
- *
- * @tparam T type of complex number
- * @ingroup type_trait
- */
-template <typename T>
-struct base_type<T, std::enable_if_t<is_complex<T>::value>> {
-  using type = base_type_t<typename std::decay_t<T>::value_type>;
-};
-
 }  // namespace stan
 #endif
diff --git a/stan/math/prim/meta/is_complex.hpp b/stan/math/prim/meta/is_complex.hpp
index 3d76b1b16ac..2ccbbc97d8d 100644
--- a/stan/math/prim/meta/is_complex.hpp
+++ b/stan/math/prim/meta/is_complex.hpp
@@ -1,6 +1,9 @@
 #ifndef STAN_MATH_PRIM_META_IS_COMPLEX_HPP
 #define STAN_MATH_PRIM_META_IS_COMPLEX_HPP
 
+#include <stan/math/prim/meta/conjunction.hpp>
+#include <stan/math/prim/meta/is_autodiff.hpp>
+#include <stan/math/prim/meta/base_type.hpp>
 #include <stan/math/prim/meta/scalar_type.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <stan/math/prim/meta/require_helpers.hpp>
@@ -27,7 +30,7 @@ struct is_complex_impl<std::complex<Ts...>> : std::true_type {};
 }  // namespace internal
 
 /**
- * If `T` is an arithmetic type (that is, an instance of
+ * If `T` is a complex type (that is, an instance of
  * `std::complex`) or a cv-qualified version thereof, provides the
  * member constant `value` equal `true`; for any other type the value is
  * `false`.
@@ -55,6 +58,55 @@ struct scalar_type<T, std::enable_if_t<is_complex<T>::value>> {
   using type = std::complex<typename std::decay_t<T>::value_type>;
 };
 
+/**
+ * Template metaprogram defining the base type for values
+ * stored in a complex number.
+ *
+ * @tparam T type of complex number
+ * @ingroup type_trait
+ */
+template <typename T>
+struct base_type<T, std::enable_if_t<is_complex<T>::value>> {
+  using type = base_type_t<typename std::decay_t<T>::value_type>;
+};
+
+/**
+ * If `T` is a complex type with an inner arithmetic type (that is, an instance
+ * of `std::complex<Arithmetic>`) or a cv-qualified version thereof, provides
+ * the member constant `value` equal `true`; for any other type the value is
+ * `false`.
+ *
+ * @tparam T type to check
+ * @ingroup type_trait
+ */
+template <typename T, typename = void>
+struct is_complex_arithmetic : std::false_type {};
+
+template <typename T>
+struct is_complex_arithmetic<
+    T, std::enable_if_t<stan::math::conjunction<
+           std::is_arithmetic<base_type_t<T>>,
+           internal::is_complex_impl<std::decay_t<T>>>::value>>
+    : std::true_type {};
+
+/**
+ * If `T` is a complex type with an inner autodiff type (that is, an instance of
+ * `std::complex<var>` or `std::complex<fvar<T>>`) or a cv-qualified version
+ * thereof, provides the member constant `value` equal `true`; for any other
+ * type the value is `false`.
+ *
+ * @tparam T type to check
+ * @ingroup type_trait
+ */
+template <typename T, typename = void>
+struct is_complex_ad : std::false_type {};
+
+template <typename T>
+struct is_complex_ad<T, std::enable_if_t<stan::math::conjunction<
+                            is_autodiff<base_type_t<T>>,
+                            internal::is_complex_impl<std::decay_t<T>>>::value>>
+    : std::true_type {};
+
 /*! \ingroup require_stan_scalar_complex */
 /*! \defgroup complex_types complex  */
 /*! \addtogroup complex_types */
@@ -107,6 +159,16 @@ using require_not_vt_complex
 template <typename T>
 using require_not_st_complex
     = require_not_t<is_complex<scalar_type_t<std::decay_t<T>>>>;
+
+/*! \brief Require type satisfies @ref is_eigen */
+/*! and scalar type satisfies `TypeCheck` */
+/*! @tparam TypeCheck The type trait to check the scalar type against */
+/*! @tparam Check The type to test @ref is_eigen for and whose @ref scalar_type
+ * is checked with `TypeCheck` */
+template <template <class...> class TypeCheck, class Check>
+using require_complex_bt
+    = require_all_t<is_complex<Check>, TypeCheck<base_type_t<Check>>>;
+
 /*! @} */
 
 /**
diff --git a/stan/math/prim/meta/is_container.hpp b/stan/math/prim/meta/is_container.hpp
index 9e115e7c682..25479694f6b 100644
--- a/stan/math/prim/meta/is_container.hpp
+++ b/stan/math/prim/meta/is_container.hpp
@@ -3,9 +3,11 @@
 
 #include <stan/math/prim/meta/bool_constant.hpp>
 #include <stan/math/prim/meta/disjunction.hpp>
+#include <stan/math/prim/meta/is_autodiff.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_var_matrix.hpp>
+#include <stan/math/prim/meta/base_type.hpp>
 #include <stan/math/prim/meta/scalar_type.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <stan/math/prim/meta/require_helpers.hpp>
@@ -71,6 +73,15 @@ using require_container_st
     = require_t<container_type_check_base<is_container, scalar_type_t,
                                           TypeCheck, Check...>>;
 
+/*! \brief Require type satisfies @ref is_container */
+/*! and @ref base_type satisfies `TypeCheck` */
+/*! @tparam TypeCheck The type trait to check the scalar type against */
+/*! @tparam Check The type to test @ref is_container for and whose @ref
+ * scalar_type is checked with `TypeCheck` */
+template <template <class...> class TypeCheck, class... Check>
+using require_container_bt = require_t<
+    container_type_check_base<is_container, base_type_t, TypeCheck, Check...>>;
+
 /*! \brief Require type does not satisfy @ref is_container */
 /*! or scalar type does not satisfy `TypeCheck` */
 /*! @tparam TypeCheck The type trait to check the scalar type against */
@@ -80,6 +91,14 @@ template <template <class...> class TypeCheck, class... Check>
 using require_not_container_st
     = require_not_t<container_type_check_base<is_container, scalar_type_t,
                                               TypeCheck, Check...>>;
+
+/*! \brief Require type satisfies @ref is_container */
+/*! and holds a base type that satisfies @ref is_autodiff */
+/*! @tparam T the type to check */
+template <typename T>
+using require_ad_container_t
+    = require_all_t<stan::math::disjunction<is_eigen<T>, is_std_vector<T>>,
+                    is_autodiff<base_type_t<T>>>;
 /*! @} */
 
 }  // namespace stan
diff --git a/stan/math/prim/meta/is_real.hpp b/stan/math/prim/meta/is_real.hpp
new file mode 100644
index 00000000000..1f7aaccab41
--- /dev/null
+++ b/stan/math/prim/meta/is_real.hpp
@@ -0,0 +1,75 @@
+#ifndef STAN_MATH_PRIM_META_IS_REAL_HPP
+#define STAN_MATH_PRIM_META_IS_REAL_HPP
+
+#include <stan/math/prim/meta/conjunction.hpp>
+#include <stan/math/prim/meta/disjunction.hpp>
+#include <stan/math/prim/meta/is_complex.hpp>
+#include <stan/math/prim/meta/is_fvar.hpp>
+#include <stan/math/prim/meta/is_var.hpp>
+#include <stan/math/prim/meta/is_var_or_arithmetic.hpp>
+#include <stan/math/prim/meta/scalar_type.hpp>
+#include <stan/math/prim/meta/value_type.hpp>
+#include <stan/math/prim/meta/require_helpers.hpp>
+
+#include <type_traits>
+
+namespace stan {
+
+/**
+ * Checks if decayed type is a var, fvar, or arithmetic. This
+ * is equivalent to @ref is_stan_scalar, except for excluding std::complex
+ * @tparam The type to check
+ * @ingroup type_trait
+ */
+template <typename T>
+struct is_real : bool_constant<math::disjunction<
+                     math::conjunction<is_var<std::decay_t<T>>,
+                                       std::is_arithmetic<value_type_t<T>>>,
+                     is_fvar<std::decay_t<T>>,
+                     std::is_arithmetic<std::decay_t<T>>>::value> {};
+
+template <typename T>
+constexpr bool is_real_v = is_real<T>::value;
+
+/*! \ingroup require_real_real */
+/*! \defgroup real_types real  */
+/*! \addtogroup real_types */
+/*! @{ */
+
+/*! \brief Require type satisfies @ref is_real */
+/*! @tparam T the type to check */
+template <typename T>
+using require_real_t = require_t<is_real<std::decay_t<T>>>;
+
+/*! \brief Require type does not satisfy @ref is_real */
+/*! @tparam T the type to check */
+template <typename T>
+using require_not_real_t = require_not_t<is_real<std::decay_t<T>>>;
+
+/*! \brief Require all of the types satisfy @ref is_real */
+/*! @tparam Types The types that are checked */
+template <typename... Types>
+using require_all_real_t = require_all_t<is_real<std::decay_t<Types>>...>;
+
+/*! \brief Require any of the types satisfy @ref is_real */
+/*! @tparam Types The types that are checked */
+template <typename... Types>
+using require_any_real_t = require_any_t<is_real<std::decay_t<Types>>...>;
+
+/*! \brief Require none of the types satisfy @ref is_real */
+/*! @tparam Types The types that are checked */
+template <typename... Types>
+using require_all_not_real_t
+    = require_all_not_t<is_real<std::decay_t<Types>>...>;
+
+/*! \brief Require at least one of the types do not satisfy @ref is_real
+ */
+/*! @tparam Types The types that are checked */
+template <typename... Types>
+using require_any_not_real_t
+    = require_any_not_t<is_real<std::decay_t<Types>>...>;
+/*! @} */
+
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/prob/cauchy_lccdf.hpp b/stan/math/prim/prob/cauchy_lccdf.hpp
index 154c24e6e0b..a49678ad88a 100644
--- a/stan/math/prim/prob/cauchy_lccdf.hpp
+++ b/stan/math/prim/prob/cauchy_lccdf.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/atan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/log.hpp>
 #include <stan/math/prim/fun/max_size.hpp>
@@ -36,8 +37,6 @@ template <typename T_y, typename T_loc, typename T_scale,
 return_type_t<T_y, T_loc, T_scale> cauchy_lccdf(const T_y& y, const T_loc& mu,
                                                 const T_scale& sigma) {
   using T_partials_return = partials_return_t<T_y, T_loc, T_scale>;
-  using std::atan;
-  using std::log;
   using T_y_ref = ref_type_t<T_y>;
   using T_mu_ref = ref_type_t<T_loc>;
   using T_sigma_ref = ref_type_t<T_scale>;
diff --git a/stan/math/prim/prob/cauchy_lcdf.hpp b/stan/math/prim/prob/cauchy_lcdf.hpp
index d1716f3d867..c5eb2231bed 100644
--- a/stan/math/prim/prob/cauchy_lcdf.hpp
+++ b/stan/math/prim/prob/cauchy_lcdf.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/atan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/log.hpp>
 #include <stan/math/prim/fun/max_size.hpp>
@@ -36,8 +37,6 @@ template <typename T_y, typename T_loc, typename T_scale,
 return_type_t<T_y, T_loc, T_scale> cauchy_lcdf(const T_y& y, const T_loc& mu,
                                                const T_scale& sigma) {
   using T_partials_return = partials_return_t<T_y, T_loc, T_scale>;
-  using std::atan;
-  using std::log;
   using T_y_ref = ref_type_t<T_y>;
   using T_mu_ref = ref_type_t<T_loc>;
   using T_sigma_ref = ref_type_t<T_scale>;
diff --git a/stan/math/prim/prob/wiener_lpdf.hpp b/stan/math/prim/prob/wiener_lpdf.hpp
index a61d0959deb..b31e3045f75 100644
--- a/stan/math/prim/prob/wiener_lpdf.hpp
+++ b/stan/math/prim/prob/wiener_lpdf.hpp
@@ -35,11 +35,13 @@
 #include <stan/math/prim/fun/ceil.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/exp.hpp>
+#include <stan/math/prim/fun/floor.hpp>
 #include <stan/math/prim/fun/log.hpp>
 #include <stan/math/prim/fun/max_size.hpp>
 #include <stan/math/prim/fun/scalar_seq_view.hpp>
 #include <stan/math/prim/fun/size_zero.hpp>
 #include <stan/math/prim/fun/square.hpp>
+#include <stan/math/prim/fun/sqrt.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <algorithm>
 #include <cmath>
@@ -83,12 +85,6 @@ return_type_t<T_y, T_alpha, T_tau, T_beta, T_delta> wiener_lpdf(
   using T_tau_ref = ref_type_t<T_tau>;
   using T_beta_ref = ref_type_t<T_beta>;
   using T_delta_ref = ref_type_t<T_delta>;
-  using std::ceil;
-  using std::exp;
-  using std::floor;
-  using std::log;
-  using std::sin;
-  using std::sqrt;
   static constexpr const char* function = "wiener_lpdf";
   check_consistent_sizes(function, "Random variable", y, "Boundary separation",
                          alpha, "A-priori bias", beta, "Nondecision time", tau,
diff --git a/stan/math/rev/fun/Phi_approx.hpp b/stan/math/rev/fun/Phi_approx.hpp
index 901e5aff5fa..0219c92853d 100644
--- a/stan/math/rev/fun/Phi_approx.hpp
+++ b/stan/math/rev/fun/Phi_approx.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
+#include <stan/math/prim/fun/Phi_approx.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/abs.hpp b/stan/math/rev/fun/abs.hpp
index 919fb320bf9..9e29024ed63 100644
--- a/stan/math/rev/fun/abs.hpp
+++ b/stan/math/rev/fun/abs.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_REV_FUN_ABS_HPP
 #define STAN_MATH_REV_FUN_ABS_HPP
 
-#include <stan/math/prim/fun/abs.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/fabs.hpp>
 #include <stan/math/rev/fun/hypot.hpp>
+#include <stan/math/prim/fun/abs.hpp>
 #include <complex>
 
 namespace stan {
diff --git a/stan/math/rev/fun/acos.hpp b/stan/math/rev/fun/acos.hpp
index e83da1b74d1..33d54df935a 100644
--- a/stan/math/rev/fun/acos.hpp
+++ b/stan/math/rev/fun/acos.hpp
@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_REV_FUN_ACOS_HPP
 #define STAN_MATH_REV_FUN_ACOS_HPP
 
-#include <stan/math/prim/fun/acos.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/abs.hpp>
@@ -10,6 +9,7 @@
 #include <stan/math/rev/fun/is_inf.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
 #include <stan/math/rev/fun/polar.hpp>
+#include <stan/math/prim/fun/acos.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/acosh.hpp b/stan/math/rev/fun/acosh.hpp
index 2c569e501b3..51a5c924693 100644
--- a/stan/math/rev/fun/acosh.hpp
+++ b/stan/math/rev/fun/acosh.hpp
@@ -1,13 +1,8 @@
 #ifndef STAN_MATH_REV_FUN_ACOSH_HPP
 #define STAN_MATH_REV_FUN_ACOSH_HPP
 
-#include <stan/math/prim/core.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/acosh.hpp>
-#include <stan/math/prim/fun/isnan.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/rev/fun/abs.hpp>
 #include <stan/math/rev/fun/arg.hpp>
 #include <stan/math/rev/fun/cosh.hpp>
@@ -15,6 +10,11 @@
 #include <stan/math/rev/fun/log.hpp>
 #include <stan/math/rev/fun/polar.hpp>
 #include <stan/math/rev/fun/sqrt.hpp>
+#include <stan/math/rev/fun/value_of_rec.hpp>
+#include <stan/math/prim/core.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/isnan.hpp>
+#include <stan/math/prim/fun/acosh.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/append_col.hpp b/stan/math/rev/fun/append_col.hpp
index 315645877a9..f0d45a24aad 100644
--- a/stan/math/rev/fun/append_col.hpp
+++ b/stan/math/rev/fun/append_col.hpp
@@ -2,10 +2,10 @@
 #define STAN_MATH_REV_FUN_APPEND_COL_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/append_col.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/append_col.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/append_row.hpp b/stan/math/rev/fun/append_row.hpp
index 214bcd6368b..7f83208a6d7 100644
--- a/stan/math/rev/fun/append_row.hpp
+++ b/stan/math/rev/fun/append_row.hpp
@@ -2,10 +2,10 @@
 #define STAN_MATH_REV_FUN_APPEND_ROW_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/append_row.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/append_row.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/asin.hpp b/stan/math/rev/fun/asin.hpp
index fec7015e488..d306d9679b1 100644
--- a/stan/math/rev/fun/asin.hpp
+++ b/stan/math/rev/fun/asin.hpp
@@ -1,13 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_ASIN_HPP
 #define STAN_MATH_REV_FUN_ASIN_HPP
 
-#include <stan/math/prim/fun/asin.hpp>
-#include <stan/math/prim/fun/abs.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/abs.hpp>
 #include <stan/math/rev/fun/asinh.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
+#include <stan/math/prim/fun/asin.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/asinh.hpp b/stan/math/rev/fun/asinh.hpp
index 6805269813d..eab4debaa3c 100644
--- a/stan/math/rev/fun/asinh.hpp
+++ b/stan/math/rev/fun/asinh.hpp
@@ -1,11 +1,6 @@
 #ifndef STAN_MATH_REV_FUN_ASINH_HPP
 #define STAN_MATH_REV_FUN_ASINH_HPP
 
-#include <stan/math/prim/core.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/asinh.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/is_inf.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
@@ -17,6 +12,9 @@
 #include <stan/math/rev/fun/log.hpp>
 #include <stan/math/rev/fun/polar.hpp>
 #include <stan/math/rev/fun/sqrt.hpp>
+#include <stan/math/prim/core.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/asinh.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/atan.hpp b/stan/math/rev/fun/atan.hpp
index a00cb9a5604..b1f1a88a722 100644
--- a/stan/math/rev/fun/atan.hpp
+++ b/stan/math/rev/fun/atan.hpp
@@ -1,10 +1,6 @@
 #ifndef STAN_MATH_REV_FUN_ATAN_HPP
 #define STAN_MATH_REV_FUN_ATAN_HPP
 
-#include <stan/math/prim/fun/abs.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/isnan.hpp>
-#include <stan/math/prim/fun/atan.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/hypot.hpp>
 #include <stan/math/rev/meta.hpp>
@@ -15,6 +11,7 @@
 #include <stan/math/rev/fun/sqrt.hpp>
 #include <stan/math/rev/fun/is_inf.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
+#include <stan/math/prim/fun/atan.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/atan2.hpp b/stan/math/rev/fun/atan2.hpp
index 7703076f449..9243cc4da2f 100644
--- a/stan/math/rev/fun/atan2.hpp
+++ b/stan/math/rev/fun/atan2.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/atan2.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/atanh.hpp b/stan/math/rev/fun/atanh.hpp
index 0c92b427f73..2532dfcaa21 100644
--- a/stan/math/rev/fun/atanh.hpp
+++ b/stan/math/rev/fun/atanh.hpp
@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_REV_FUN_ATANH_HPP
 #define STAN_MATH_REV_FUN_ATANH_HPP
 
-#include <stan/math/prim/fun/atanh.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
@@ -10,6 +9,7 @@
 #include <stan/math/rev/fun/log.hpp>
 #include <stan/math/rev/fun/sinh.hpp>
 #include <stan/math/rev/fun/hypot.hpp>
+#include <stan/math/prim/fun/atanh.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/beta.hpp b/stan/math/rev/fun/beta.hpp
index 01e0de95029..26303e923c5 100644
--- a/stan/math/rev/fun/beta.hpp
+++ b/stan/math/rev/fun/beta.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/beta.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/binary_log_loss.hpp b/stan/math/rev/fun/binary_log_loss.hpp
index 990a0b979c3..c521f613d53 100644
--- a/stan/math/rev/fun/binary_log_loss.hpp
+++ b/stan/math/rev/fun/binary_log_loss.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/log1p.hpp>
+#include <stan/math/rev/fun/log1p.hpp>
+#include <stan/math/prim/fun/binary_log_loss.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/ceil.hpp b/stan/math/rev/fun/ceil.hpp
index 072fa9469e9..025caa71e82 100644
--- a/stan/math/rev/fun/ceil.hpp
+++ b/stan/math/rev/fun/ceil.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/is_nan.hpp>
+#include <stan/math/prim/fun/ceil.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/cholesky_decompose.hpp b/stan/math/rev/fun/cholesky_decompose.hpp
index c192dba731b..ac0f22e7d03 100644
--- a/stan/math/rev/fun/cholesky_decompose.hpp
+++ b/stan/math/rev/fun/cholesky_decompose.hpp
@@ -1,14 +1,13 @@
 #ifndef STAN_MATH_REV_MAT_FUN_CHOLESKY_DECOMPOSE_HPP
 #define STAN_MATH_REV_MAT_FUN_CHOLESKY_DECOMPOSE_HPP
 
-#include <stan/math/rev/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/cholesky_decompose.hpp>
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/value_of_rec.hpp>
+#include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/cholesky_decompose.hpp>
 #include <stan/math/prim/err/check_pos_definite.hpp>
 #include <stan/math/prim/err/check_square.hpp>
 #include <stan/math/prim/err/check_symmetric.hpp>
diff --git a/stan/math/rev/fun/columns_dot_product.hpp b/stan/math/rev/fun/columns_dot_product.hpp
index baa7ffe8e77..086bc3996cd 100644
--- a/stan/math/rev/fun/columns_dot_product.hpp
+++ b/stan/math/rev/fun/columns_dot_product.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_COLUMNS_DOT_PRODUCT_HPP
 #define STAN_MATH_REV_FUN_COLUMNS_DOT_PRODUCT_HPP
 
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/rev/fun/dot_product.hpp>
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/err.hpp>
 
 #include <type_traits>
 
diff --git a/stan/math/rev/fun/columns_dot_self.hpp b/stan/math/rev/fun/columns_dot_self.hpp
index bddaad4edf9..e21b8a2e313 100644
--- a/stan/math/rev/fun/columns_dot_self.hpp
+++ b/stan/math/rev/fun/columns_dot_self.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_COLUMNS_DOT_SELF_HPP
 #define STAN_MATH_REV_FUN_COLUMNS_DOT_SELF_HPP
 
-#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/dot_self.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/columns_dot_self.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/conj.hpp b/stan/math/rev/fun/conj.hpp
index 2537f17c8e8..b7ff38c0195 100644
--- a/stan/math/rev/fun/conj.hpp
+++ b/stan/math/rev/fun/conj.hpp
@@ -5,20 +5,4 @@
 #include <stan/math/prim/fun/conj.hpp>
 #include <complex>
 
-namespace stan {
-namespace math {
-
-/**
- * Return the complex conjugate of the complex argument.
- *
- * @param[in] z argument
- * @return complex conjugate of the argument
- */
-inline std::complex<var> conj(const std::complex<var>& z) {
-  return internal::complex_conj(z);
-}
-
-}  // namespace math
-}  // namespace stan
-
 #endif
diff --git a/stan/math/rev/fun/cos.hpp b/stan/math/rev/fun/cos.hpp
index 4b48a5e5fe4..4e5b7d7b39d 100644
--- a/stan/math/rev/fun/cos.hpp
+++ b/stan/math/rev/fun/cos.hpp
@@ -1,15 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_COS_HPP
 #define STAN_MATH_REV_FUN_COS_HPP
 
-#include <stan/math/prim/fun/abs.hpp>
-#include <stan/math/prim/fun/cos.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/isfinite.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/abs.hpp>
 #include <stan/math/rev/fun/cosh.hpp>
 #include <stan/math/rev/fun/sinh.hpp>
+#include <stan/math/prim/fun/cos.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/cosh.hpp b/stan/math/rev/fun/cosh.hpp
index 997e0e85a12..2b73be9f60a 100644
--- a/stan/math/rev/fun/cosh.hpp
+++ b/stan/math/rev/fun/cosh.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_COSH_HPP
 #define STAN_MATH_REV_FUN_COSH_HPP
 
-#include <stan/math/prim/fun/cosh.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/operator_multiplication.hpp>
 #include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/rev/fun/sin.hpp>
 #include <stan/math/rev/fun/sinh.hpp>
+#include <stan/math/prim/fun/cosh.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/cov_exp_quad.hpp b/stan/math/rev/fun/cov_exp_quad.hpp
index 2fb9cf9db81..5ade5d2460b 100644
--- a/stan/math/rev/fun/cov_exp_quad.hpp
+++ b/stan/math/rev/fun/cov_exp_quad.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_COV_EXP_QUAD_HPP
 #define STAN_MATH_REV_FUN_COV_EXP_QUAD_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/fun/gp_exp_quad_cov.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/squared_distance.hpp>
-#include <stan/math/prim/fun/exp.hpp>
+#include <stan/math/rev/fun/squared_distance.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/prim/fun/cov_exp_quad.hpp>
 #include <type_traits>
 #include <vector>
 #include <cmath>
diff --git a/stan/math/rev/fun/csr_matrix_times_vector.hpp b/stan/math/rev/fun/csr_matrix_times_vector.hpp
index 4665c7a4dbd..5e336746a58 100644
--- a/stan/math/rev/fun/csr_matrix_times_vector.hpp
+++ b/stan/math/rev/fun/csr_matrix_times_vector.hpp
@@ -2,10 +2,11 @@
 #define STAN_MATH_REV_FUN_CSR_MATRIX_TIMES_VECTOR_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/fun/to_soa_sparse_matrix.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/to_soa_sparse_matrix.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/csr_u_to_z.hpp>
+#include <stan/math/prim/fun/csr_matrix_times_vector.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/determinant.hpp b/stan/math/rev/fun/determinant.hpp
index 19f30f50415..d824151e818 100644
--- a/stan/math/rev/fun/determinant.hpp
+++ b/stan/math/rev/fun/determinant.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/determinant.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/diag_post_multiply.hpp b/stan/math/rev/fun/diag_post_multiply.hpp
index ff826eee68b..f16cb178d05 100644
--- a/stan/math/rev/fun/diag_post_multiply.hpp
+++ b/stan/math/rev/fun/diag_post_multiply.hpp
@@ -2,8 +2,9 @@
 #define STAN_MATH_REV_FUN_DIAG_POST_MULTIPLY_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/diag_post_multiply.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/diag_pre_multiply.hpp b/stan/math/rev/fun/diag_pre_multiply.hpp
index 22a9fb9fbe2..9538659f44f 100644
--- a/stan/math/rev/fun/diag_pre_multiply.hpp
+++ b/stan/math/rev/fun/diag_pre_multiply.hpp
@@ -2,8 +2,9 @@
 #define STAN_MATH_REV_FUN_DIAG_PRE_MULTIPLY_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/diag_pre_multiply.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/digamma.hpp b/stan/math/rev/fun/digamma.hpp
index 0d892e61218..beca0e006ee 100644
--- a/stan/math/rev/fun/digamma.hpp
+++ b/stan/math/rev/fun/digamma.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/trigamma.hpp>
+#include <stan/math/rev/fun/trigamma.hpp>
 #include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/dims.hpp b/stan/math/rev/fun/dims.hpp
index 99c0916a1a0..eda8ee0926a 100644
--- a/stan/math/rev/fun/dims.hpp
+++ b/stan/math/rev/fun/dims.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/dims.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/dot_product.hpp b/stan/math/rev/fun/dot_product.hpp
index 02b87424968..76cbc28d793 100644
--- a/stan/math/rev/fun/dot_product.hpp
+++ b/stan/math/rev/fun/dot_product.hpp
@@ -1,19 +1,17 @@
 #ifndef STAN_MATH_REV_FUN_DOT_PRODUCT_HPP
 #define STAN_MATH_REV_FUN_DOT_PRODUCT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/rev/fun/dot_product.hpp>
 #include <stan/math/rev/fun/to_arena.hpp>
-#include <stan/math/rev/core/arena_matrix.hpp>
-#include <stan/math/rev/core/reverse_pass_callback.hpp>
+#include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/as_column_vector_or_scalar.hpp>
-#include <stan/math/prim/fun/dot_product.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/dot_product.hpp>
 #include <type_traits>
 #include <vector>
 
diff --git a/stan/math/rev/fun/dot_self.hpp b/stan/math/rev/fun/dot_self.hpp
index c318c99ee1d..47b889fd6df 100644
--- a/stan/math/rev/fun/dot_self.hpp
+++ b/stan/math/rev/fun/dot_self.hpp
@@ -1,12 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_DOT_SELF_HPP
 #define STAN_MATH_REV_FUN_DOT_SELF_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/rev/core/typedefs.hpp>
+#include <stan/math/rev/fun/square.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/prim/fun/dot_self.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/eigendecompose_sym.hpp b/stan/math/rev/fun/eigendecompose_sym.hpp
index 9c7c41cf014..17663bd7ce5 100644
--- a/stan/math/rev/fun/eigendecompose_sym.hpp
+++ b/stan/math/rev/fun/eigendecompose_sym.hpp
@@ -1,15 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_EIGENDECOMPOSE_HPP
 #define STAN_MATH_REV_FUN_EIGENDECOMPOSE_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
-#include <stan/math/rev/core/typedefs.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/err/check_symmetric.hpp>
 #include <stan/math/prim/err/check_nonzero_size.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/value_of_rec.hpp>
+#include <stan/math/prim/fun/eigendecompose_sym.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/eigenvalues_sym.hpp b/stan/math/rev/fun/eigenvalues_sym.hpp
index bfb5287deb5..a74ca07d237 100644
--- a/stan/math/rev/fun/eigenvalues_sym.hpp
+++ b/stan/math/rev/fun/eigenvalues_sym.hpp
@@ -1,15 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_EIGENVALUES_HPP
 #define STAN_MATH_REV_FUN_EIGENVALUES_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/err/check_symmetric.hpp>
 #include <stan/math/prim/err/check_nonzero_size.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/value_of_rec.hpp>
+#include <stan/math/prim/fun/eigenvalues_sym.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/eigenvectors_sym.hpp b/stan/math/rev/fun/eigenvectors_sym.hpp
index 17d17cead41..6f2d2bfca4d 100644
--- a/stan/math/rev/fun/eigenvectors_sym.hpp
+++ b/stan/math/rev/fun/eigenvectors_sym.hpp
@@ -1,15 +1,16 @@
 #ifndef STAN_MATH_REV_FUN_EIGENVECTORS_HPP
 #define STAN_MATH_REV_FUN_EIGENVECTORS_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/err/check_symmetric.hpp>
 #include <stan/math/prim/err/check_nonzero_size.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/prim/fun/value_of_rec.hpp>
+#include <stan/math/prim/fun/eigenvectors_sym.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/elt_divide.hpp b/stan/math/rev/fun/elt_divide.hpp
index 5cfd473e2fa..1bf9f4c854b 100644
--- a/stan/math/rev/fun/elt_divide.hpp
+++ b/stan/math/rev/fun/elt_divide.hpp
@@ -2,10 +2,11 @@
 #define STAN_MATH_REV_FUN_ELT_DIVIDE_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/eval.hpp>
-#include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/elt_divide.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/elt_multiply.hpp b/stan/math/rev/fun/elt_multiply.hpp
index 6e593c44524..581037f90cb 100644
--- a/stan/math/rev/fun/elt_multiply.hpp
+++ b/stan/math/rev/fun/elt_multiply.hpp
@@ -2,11 +2,12 @@
 #define STAN_MATH_REV_FUN_ELT_MULTIPLY_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/multiply.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/eval.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/rev/fun/multiply.hpp>
+#include <stan/math/prim/fun/elt_multiply.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/exp.hpp b/stan/math/rev/fun/exp.hpp
index 5f04d8917d2..88a9a22a179 100644
--- a/stan/math/rev/fun/exp.hpp
+++ b/stan/math/rev/fun/exp.hpp
@@ -3,14 +3,11 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/cos.hpp>
-#include <stan/math/prim/fun/exp.hpp>
+#include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/is_inf.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/isfinite.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
-#include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/sin.hpp>
+#include <stan/math/prim/fun/exp.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/exp2.hpp b/stan/math/rev/fun/exp2.hpp
index d444b3838fa..325fa712b03 100644
--- a/stan/math/rev/fun/exp2.hpp
+++ b/stan/math/rev/fun/exp2.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/exp2.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/exp2.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/fabs.hpp b/stan/math/rev/fun/fabs.hpp
index 21a71a26e69..c525e9e3763 100644
--- a/stan/math/rev/fun/fabs.hpp
+++ b/stan/math/rev/fun/fabs.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/fabs.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/falling_factorial.hpp b/stan/math/rev/fun/falling_factorial.hpp
index db2228d24fc..5ca211a4cac 100644
--- a/stan/math/rev/fun/falling_factorial.hpp
+++ b/stan/math/rev/fun/falling_factorial.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/falling_factorial.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/fdim.hpp b/stan/math/rev/fun/fdim.hpp
index 7b1786af147..1d51b84a059 100644
--- a/stan/math/rev/fun/fdim.hpp
+++ b/stan/math/rev/fun/fdim.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/fdim.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/fft.hpp b/stan/math/rev/fun/fft.hpp
index 797950b3056..5250705ef49 100644
--- a/stan/math/rev/fun/fft.hpp
+++ b/stan/math/rev/fun/fft.hpp
@@ -2,11 +2,10 @@
 #define STAN_MATH_REV_FUN_FFT_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/prim/fun/fft.hpp>
+#include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/prim/fun/to_complex.hpp>
-#include <Eigen/Dense>
+#include <stan/math/prim/fun/fft.hpp>
 #include <complex>
 #include <type_traits>
 #include <vector>
diff --git a/stan/math/rev/fun/fill.hpp b/stan/math/rev/fun/fill.hpp
index 703a2c657b6..bb1e1e76377 100644
--- a/stan/math/rev/fun/fill.hpp
+++ b/stan/math/rev/fun/fill.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/fill.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/floor.hpp b/stan/math/rev/fun/floor.hpp
index 8ba83842085..bac9ab778ed 100644
--- a/stan/math/rev/fun/floor.hpp
+++ b/stan/math/rev/fun/floor.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/is_nan.hpp>
+#include <stan/math/prim/fun/floor.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/fma.hpp b/stan/math/rev/fun/fma.hpp
index ec629bab257..2a12123e13a 100644
--- a/stan/math/rev/fun/fma.hpp
+++ b/stan/math/rev/fun/fma.hpp
@@ -4,8 +4,8 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/fma.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/fma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/fmax.hpp b/stan/math/rev/fun/fmax.hpp
index 2a3c44be0b6..9f9e21530b0 100644
--- a/stan/math/rev/fun/fmax.hpp
+++ b/stan/math/rev/fun/fmax.hpp
@@ -4,8 +4,8 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
-#include <stan/math/prim/fun/is_nan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/fmax.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/fmin.hpp b/stan/math/rev/fun/fmin.hpp
index 2be163d2e62..5b49dd3da69 100644
--- a/stan/math/rev/fun/fmin.hpp
+++ b/stan/math/rev/fun/fmin.hpp
@@ -5,7 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/is_nan.hpp>
+#include <stan/math/prim/fun/fmin.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/fmod.hpp b/stan/math/rev/fun/fmod.hpp
index 3ef2abe383d..74d338d28f4 100644
--- a/stan/math/rev/fun/fmod.hpp
+++ b/stan/math/rev/fun/fmod.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/fmod.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/gamma_p.hpp b/stan/math/rev/fun/gamma_p.hpp
index 9ded606dcc7..e25d60132b7 100644
--- a/stan/math/rev/fun/gamma_p.hpp
+++ b/stan/math/rev/fun/gamma_p.hpp
@@ -3,11 +3,11 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/lgamma.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/gamma_p.hpp>
 #include <stan/math/prim/fun/grad_reg_lower_inc_gamma.hpp>
 #include <stan/math/prim/fun/is_inf.hpp>
-#include <stan/math/prim/fun/lgamma.hpp>
+#include <stan/math/prim/fun/gamma_p.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/gamma_q.hpp b/stan/math/rev/fun/gamma_q.hpp
index 2bf66d25203..73ccfb6c68c 100644
--- a/stan/math/rev/fun/gamma_q.hpp
+++ b/stan/math/rev/fun/gamma_q.hpp
@@ -3,10 +3,11 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
-#include <stan/math/prim/fun/gamma_q.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
+#include <stan/math/rev/fun/tgamma.hpp>
 #include <stan/math/prim/fun/grad_reg_inc_gamma.hpp>
-#include <stan/math/prim/fun/tgamma.hpp>
+#include <stan/math/prim/fun/gamma_q.hpp>
+
 #include <boost/math/special_functions/gamma.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/generalized_inverse.hpp b/stan/math/rev/fun/generalized_inverse.hpp
index 48a95deca23..11c0eb18ada 100644
--- a/stan/math/rev/fun/generalized_inverse.hpp
+++ b/stan/math/rev/fun/generalized_inverse.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_GENERALIZED_INVERSE_HPP
 #define STAN_MATH_REV_FUN_GENERALIZED_INVERSE_HPP
 
-#include <stan/math/prim/fun/add_diag.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/inverse.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/add_diag.hpp>
+#include <stan/math/prim/fun/generalized_inverse.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/gp_exp_quad_cov.hpp b/stan/math/rev/fun/gp_exp_quad_cov.hpp
index 5287cb10f88..6712f9bd6ea 100644
--- a/stan/math/rev/fun/gp_exp_quad_cov.hpp
+++ b/stan/math/rev/fun/gp_exp_quad_cov.hpp
@@ -1,14 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_GP_EXP_QUAD_COV_HPP
 #define STAN_MATH_REV_FUN_GP_EXP_QUAD_COV_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/adjoint_of.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/squared_distance.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/exp.hpp>
-#include <stan/math/prim/fun/squared_distance.hpp>
+#include <stan/math/prim/fun/gp_exp_quad_cov.hpp>
 #include <cmath>
 #include <type_traits>
 #include <vector>
diff --git a/stan/math/rev/fun/gp_periodic_cov.hpp b/stan/math/rev/fun/gp_periodic_cov.hpp
index 4a307cbaa1b..18602d487b5 100644
--- a/stan/math/rev/fun/gp_periodic_cov.hpp
+++ b/stan/math/rev/fun/gp_periodic_cov.hpp
@@ -1,15 +1,18 @@
 #ifndef STAN_MATH_REV_FUN_GP_PERIODIC_COV_HPP
 #define STAN_MATH_REV_FUN_GP_PERIODIC_COV_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/fun/adjoint_of.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/sin.hpp>
+#include <stan/math/rev/fun/square.hpp>
+#include <stan/math/rev/fun/squared_distance.hpp>
+#include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/square.hpp>
-#include <stan/math/prim/fun/squared_distance.hpp>
+#include <stan/math/prim/fun/gp_exp_quad_cov.hpp>
 #include <cmath>
 #include <type_traits>
 #include <vector>
@@ -41,8 +44,6 @@ template <typename T_x, typename T_sigma, require_st_arithmetic<T_x>* = nullptr,
           require_stan_scalar_t<T_sigma>* = nullptr>
 inline Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> gp_periodic_cov(
     const std::vector<T_x>& x, const T_sigma sigma, const var l, const var p) {
-  using std::exp;
-  using std::sin;
   const char* fun = "gp_periodic_cov";
   check_positive(fun, "signal standard deviation", sigma);
   check_positive(fun, "length-scale", l);
diff --git a/stan/math/rev/fun/grad_inc_beta.hpp b/stan/math/rev/fun/grad_inc_beta.hpp
index aa39574d4e3..e91ad18bac3 100644
--- a/stan/math/rev/fun/grad_inc_beta.hpp
+++ b/stan/math/rev/fun/grad_inc_beta.hpp
@@ -7,15 +7,16 @@
 #include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/rev/fun/fabs.hpp>
 #include <stan/math/rev/fun/floor.hpp>
-#include <stan/math/rev/fun/value_of_rec.hpp>
+#include <stan/math/rev/fun/hypergeometric_2F1.hpp>
 #include <stan/math/rev/fun/inc_beta.hpp>
 #include <stan/math/rev/fun/lgamma.hpp>
 #include <stan/math/rev/fun/log.hpp>
 #include <stan/math/rev/fun/log1m.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/prim/fun/grad_2F1.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
-#include <stan/math/rev/fun/hypergeometric_2F1.hpp>
+#include <stan/math/prim/fun/grad_inc_beta.hpp>
+
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/hypergeometric_1F0.hpp b/stan/math/rev/fun/hypergeometric_1F0.hpp
index 74e62fef728..10774fdc915 100644
--- a/stan/math/rev/fun/hypergeometric_1F0.hpp
+++ b/stan/math/rev/fun/hypergeometric_1F0.hpp
@@ -1,12 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_HYPERGEOMETRIC_1F0_HPP
 #define STAN_MATH_REV_FUN_HYPERGEOMETRIC_1F0_HPP
 
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/log1m.hpp>
+#include <stan/math/rev/fun/inv.hpp>
+#include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/hypergeometric_1F0.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
-#include <stan/math/prim/fun/log1m.hpp>
-#include <stan/math/prim/fun/inv.hpp>
-#include <stan/math/rev/core.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/hypergeometric_2F1.hpp b/stan/math/rev/fun/hypergeometric_2F1.hpp
index 3b57a66790d..17b72518656 100644
--- a/stan/math/rev/fun/hypergeometric_2F1.hpp
+++ b/stan/math/rev/fun/hypergeometric_2F1.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_REV_FUN_HYPERGEOMETRIC_2F1_HPP
 #define STAN_MATH_REV_FUN_HYPERGEOMETRIC_2F1_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/hypergeometric_2F1.hpp>
+#include <stan/math/rev/meta.hpp>
 #include <stan/math/prim/fun/grad_2F1.hpp>
+#include <stan/math/prim/fun/hypergeometric_2F1.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/hypergeometric_pFq.hpp b/stan/math/rev/fun/hypergeometric_pFq.hpp
index 15c5616e17e..140c24adc05 100644
--- a/stan/math/rev/fun/hypergeometric_pFq.hpp
+++ b/stan/math/rev/fun/hypergeometric_pFq.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_REV_FUN_HYPERGEOMETRIC_PFQ_HPP
 #define STAN_MATH_REV_FUN_HYPERGEOMETRIC_PFQ_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/hypergeometric_pFq.hpp>
+#include <stan/math/rev/meta.hpp>
 #include <stan/math/prim/fun/grad_pFq.hpp>
+#include <stan/math/prim/fun/hypergeometric_pFq.hpp>
 
 namespace stan {
 namespace math {
@@ -35,15 +35,15 @@ inline var hypergeometric_pFq(const Ta& a, const Tb& b, const Tz& z) {
       pfq_val, [arena_a, arena_b, z, pfq_val](auto& vi) mutable {
         auto grad_tuple = grad_pFq<grad_a, grad_b, grad_z>(
             pfq_val, arena_a.val(), arena_b.val(), value_of(z));
-        if (grad_a) {
+        if constexpr (grad_a) {
           forward_as<promote_scalar_t<var, Ta>>(arena_a).adj()
               += vi.adj() * std::get<0>(grad_tuple);
         }
-        if (grad_b) {
+        if constexpr (grad_b) {
           forward_as<promote_scalar_t<var, Tb>>(arena_b).adj()
               += vi.adj() * std::get<1>(grad_tuple);
         }
-        if (grad_z) {
+        if constexpr (grad_z) {
           forward_as<promote_scalar_t<var, Tz>>(z).adj()
               += vi.adj() * std::get<2>(grad_tuple);
         }
diff --git a/stan/math/rev/fun/inc_beta.hpp b/stan/math/rev/fun/inc_beta.hpp
index 57d91ef06fc..be8a65b7b6a 100644
--- a/stan/math/rev/fun/inc_beta.hpp
+++ b/stan/math/rev/fun/inc_beta.hpp
@@ -3,10 +3,11 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/beta.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/rev/fun/pow.hpp>
-#include <stan/math/prim/fun/beta.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 #include <stan/math/prim/fun/grad_reg_inc_beta.hpp>
+#include <stan/math/prim/fun/inc_beta.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/initialize_fill.hpp b/stan/math/rev/fun/initialize_fill.hpp
index 3f16ba77210..6ca5c63d9e8 100644
--- a/stan/math/rev/fun/initialize_fill.hpp
+++ b/stan/math/rev/fun/initialize_fill.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/initialize_fill.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/inv_cloglog.hpp b/stan/math/rev/fun/inv_cloglog.hpp
index 78d58737932..80789ba01b1 100644
--- a/stan/math/rev/fun/inv_cloglog.hpp
+++ b/stan/math/rev/fun/inv_cloglog.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/prim/fun/inv_cloglog.hpp>
 #include <cmath>
 
diff --git a/stan/math/rev/fun/inv_erfc.hpp b/stan/math/rev/fun/inv_erfc.hpp
index ef91b1af29f..4ecdcaae4d7 100644
--- a/stan/math/rev/fun/inv_erfc.hpp
+++ b/stan/math/rev/fun/inv_erfc.hpp
@@ -3,10 +3,10 @@
 
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/fun/square.hpp>
+#include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/inv_erfc.hpp>
-#include <stan/math/prim/fun/square.hpp>
-#include <stan/math/prim/fun/exp.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/inv_inc_beta.hpp b/stan/math/rev/fun/inv_inc_beta.hpp
index 097c0383adf..d3139f94e46 100644
--- a/stan/math/rev/fun/inv_inc_beta.hpp
+++ b/stan/math/rev/fun/inv_inc_beta.hpp
@@ -3,17 +3,20 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/fabs.hpp>
+#include <stan/math/rev/fun/inc_beta.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/hypergeometric_pFq.hpp>
+#include <stan/math/rev/fun/log.hpp>
+#include <stan/math/rev/fun/log_diff_exp.hpp>
+#include <stan/math/rev/fun/lbeta.hpp>
+#include <stan/math/rev/fun/lgamma.hpp>
+#include <stan/math/rev/fun/sum.hpp>
+#include <stan/math/prim/fun/is_any_nan.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/inv_inc_beta.hpp>
-#include <stan/math/prim/fun/inc_beta.hpp>
-#include <stan/math/prim/fun/exp.hpp>
-#include <stan/math/prim/fun/log.hpp>
-#include <stan/math/prim/fun/log_diff_exp.hpp>
-#include <stan/math/prim/fun/lbeta.hpp>
-#include <stan/math/prim/fun/lgamma.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 #include <stan/math/prim/fun/hypergeometric_3F2.hpp>
-#include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/inv_inc_beta.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/inv_sqrt.hpp b/stan/math/rev/fun/inv_sqrt.hpp
index 3135779ed2a..22811e6e189 100644
--- a/stan/math/rev/fun/inv_sqrt.hpp
+++ b/stan/math/rev/fun/inv_sqrt.hpp
@@ -3,8 +3,10 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/inv_sqrt.hpp>
 #include <stan/math/rev/fun/to_arena.hpp>
+#include <stan/math/rev/fun/inv.hpp>
+#include <stan/math/rev/fun/sqrt.hpp>
+#include <stan/math/prim/fun/inv_sqrt.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/inverse.hpp b/stan/math/rev/fun/inverse.hpp
index 655c871fb7b..4d34df0175c 100644
--- a/stan/math/rev/fun/inverse.hpp
+++ b/stan/math/rev/fun/inverse.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/inverse.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/lambert_w.hpp b/stan/math/rev/fun/lambert_w.hpp
index 6399a384e9a..f7aafc7c4a2 100644
--- a/stan/math/rev/fun/lambert_w.hpp
+++ b/stan/math/rev/fun/lambert_w.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/boost_policy.hpp>
-#include <stan/math/prim/fun/exp.hpp>
 #include <stan/math/prim/fun/lambert_w.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/lbeta.hpp b/stan/math/rev/fun/lbeta.hpp
index 633af8cf1f3..e5a8b01f8b8 100644
--- a/stan/math/rev/fun/lbeta.hpp
+++ b/stan/math/rev/fun/lbeta.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/lbeta.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/ldexp.hpp b/stan/math/rev/fun/ldexp.hpp
index e95f8f8d397..c8ada462e41 100644
--- a/stan/math/rev/fun/ldexp.hpp
+++ b/stan/math/rev/fun/ldexp.hpp
@@ -1,8 +1,8 @@
 #ifndef STAN_MATH_REV_FUN_LDEXP_HPP
 #define STAN_MATH_REV_FUN_LDEXP_HPP
 
-#include <stan/math/prim/fun/ldexp.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/ldexp.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/lgamma.hpp b/stan/math/rev/fun/lgamma.hpp
index 7afe24991a5..1215f331ba8 100644
--- a/stan/math/rev/fun/lgamma.hpp
+++ b/stan/math/rev/fun/lgamma.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/lgamma.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/lmgamma.hpp b/stan/math/rev/fun/lmgamma.hpp
index 8e608f69205..0af915010a8 100644
--- a/stan/math/rev/fun/lmgamma.hpp
+++ b/stan/math/rev/fun/lmgamma.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/lmgamma.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/lmultiply.hpp b/stan/math/rev/fun/lmultiply.hpp
index 2cf2e0becb1..348fdb2fd4d 100644
--- a/stan/math/rev/fun/lmultiply.hpp
+++ b/stan/math/rev/fun/lmultiply.hpp
@@ -6,10 +6,10 @@
 #include <stan/math/rev/fun/log.hpp>
 #include <stan/math/rev/fun/elt_multiply.hpp>
 #include <stan/math/rev/fun/multiply.hpp>
+#include <stan/math/rev/fun/multiply_log.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/lmultiply.hpp>
-#include <stan/math/prim/fun/multiply_log.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/lmultiply.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log.hpp b/stan/math/rev/fun/log.hpp
index 91259f0569f..ac22788aa96 100644
--- a/stan/math/rev/fun/log.hpp
+++ b/stan/math/rev/fun/log.hpp
@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_REV_FUN_LOG_HPP
 #define STAN_MATH_REV_FUN_LOG_HPP
 
-#include <stan/math/prim/fun/log.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/functor/apply_scalar_unary.hpp>
@@ -13,6 +12,7 @@
 #include <stan/math/rev/fun/is_nan.hpp>
 #include <stan/math/rev/fun/norm.hpp>
 #include <stan/math/rev/fun/sqrt.hpp>
+#include <stan/math/prim/fun/log.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log10.hpp b/stan/math/rev/fun/log10.hpp
index d037bae30b7..82d7884bce7 100644
--- a/stan/math/rev/fun/log10.hpp
+++ b/stan/math/rev/fun/log10.hpp
@@ -1,14 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_LOG10_HPP
 #define STAN_MATH_REV_FUN_LOG10_HPP
 
-#include <stan/math/prim/core.hpp>
-#include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/log10.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/atan2.hpp>
 #include <stan/math/rev/fun/hypot.hpp>
 #include <stan/math/rev/fun/log.hpp>
+#include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/log10.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/log1m_exp.hpp b/stan/math/rev/fun/log1m_exp.hpp
index 80c45440fb7..4288b945563 100644
--- a/stan/math/rev/fun/log1m_exp.hpp
+++ b/stan/math/rev/fun/log1m_exp.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/expm1.hpp>
+#include <stan/math/rev/fun/expm1.hpp>
 #include <stan/math/prim/fun/log1m_exp.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log1m_inv_logit.hpp b/stan/math/rev/fun/log1m_inv_logit.hpp
index 7592707cf98..382878317f3 100644
--- a/stan/math/rev/fun/log1m_inv_logit.hpp
+++ b/stan/math/rev/fun/log1m_inv_logit.hpp
@@ -2,9 +2,9 @@
 #define STAN_MATH_REV_FUN_LOG1M_INV_LOGIT_HPP
 
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/prim/fun/log1m_inv_logit.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/log1m_inv_logit.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log1p_exp.hpp b/stan/math/rev/fun/log1p_exp.hpp
index 4a73c220ee9..f2b24bba3e5 100644
--- a/stan/math/rev/fun/log1p_exp.hpp
+++ b/stan/math/rev/fun/log1p_exp.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log1p_exp.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log2.hpp b/stan/math/rev/fun/log2.hpp
index 05ee0f3db1d..ba9f3faf0f3 100644
--- a/stan/math/rev/fun/log2.hpp
+++ b/stan/math/rev/fun/log2.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/log2.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/log2.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log_determinant.hpp b/stan/math/rev/fun/log_determinant.hpp
index 978714bff4f..5e4b7a442ec 100644
--- a/stan/math/rev/fun/log_determinant.hpp
+++ b/stan/math/rev/fun/log_determinant.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_LOG_DETERMINANT_HPP
 #define STAN_MATH_REV_FUN_LOG_DETERMINANT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/log_determinant.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log_determinant_ldlt.hpp b/stan/math/rev/fun/log_determinant_ldlt.hpp
index 0059a02fb54..aea6ad030b5 100644
--- a/stan/math/rev/fun/log_determinant_ldlt.hpp
+++ b/stan/math/rev/fun/log_determinant_ldlt.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_LOG_DETERMINANT_LDLT_HPP
 #define STAN_MATH_REV_FUN_LOG_DETERMINANT_LDLT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/LDLT_factor.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/log_determinant_ldlt.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log_determinant_spd.hpp b/stan/math/rev/fun/log_determinant_spd.hpp
index b87d06fce7a..d94538b92e1 100644
--- a/stan/math/rev/fun/log_determinant_spd.hpp
+++ b/stan/math/rev/fun/log_determinant_spd.hpp
@@ -1,14 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_LOG_DETERMINANT_SPD_HPP
 #define STAN_MATH_REV_FUN_LOG_DETERMINANT_SPD_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
+#include <stan/math/rev/fun/log.hpp>
+#include <stan/math/rev/fun/sum.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/log.hpp>
-#include <stan/math/prim/fun/sum.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/log_determinant_spd.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log_diff_exp.hpp b/stan/math/rev/fun/log_diff_exp.hpp
index aa8c0034ad9..edab7204bab 100644
--- a/stan/math/rev/fun/log_diff_exp.hpp
+++ b/stan/math/rev/fun/log_diff_exp.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/expm1.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/expm1.hpp>
 #include <stan/math/prim/fun/log_diff_exp.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log_falling_factorial.hpp b/stan/math/rev/fun/log_falling_factorial.hpp
index b7bf742c864..c3a0a52caaf 100644
--- a/stan/math/rev/fun/log_falling_factorial.hpp
+++ b/stan/math/rev/fun/log_falling_factorial.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
 #include <stan/math/prim/fun/log_falling_factorial.hpp>
 
diff --git a/stan/math/rev/fun/log_inv_logit.hpp b/stan/math/rev/fun/log_inv_logit.hpp
index 2e3ac0a80a9..0fdc2dc5627 100644
--- a/stan/math/rev/fun/log_inv_logit.hpp
+++ b/stan/math/rev/fun/log_inv_logit.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log_inv_logit.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log_inv_logit_diff.hpp b/stan/math/rev/fun/log_inv_logit_diff.hpp
index 0bce4ec01f6..132c5d2c85b 100644
--- a/stan/math/rev/fun/log_inv_logit_diff.hpp
+++ b/stan/math/rev/fun/log_inv_logit_diff.hpp
@@ -3,10 +3,10 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/expm1.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
+#include <stan/math/rev/fun/inv.hpp>
 #include <stan/math/prim/fun/log_inv_logit_diff.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
-#include <stan/math/prim/fun/inv.hpp>
-#include <stan/math/prim/fun/expm1.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log_mix.hpp b/stan/math/rev/fun/log_mix.hpp
index 55ba70e2544..586d2287937 100644
--- a/stan/math/rev/fun/log_mix.hpp
+++ b/stan/math/rev/fun/log_mix.hpp
@@ -3,9 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
-#include <stan/math/prim/fun/log_mix.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/rev/functor/partials_propagator.hpp>
+#include <stan/math/prim/fun/log_mix.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log_rising_factorial.hpp b/stan/math/rev/fun/log_rising_factorial.hpp
index efbc130c083..d1b048f84fd 100644
--- a/stan/math/rev/fun/log_rising_factorial.hpp
+++ b/stan/math/rev/fun/log_rising_factorial.hpp
@@ -4,7 +4,6 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/digamma.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
 #include <stan/math/prim/fun/log_rising_factorial.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/log_softmax.hpp b/stan/math/rev/fun/log_softmax.hpp
index ac616a6b78a..d41a567156b 100644
--- a/stan/math/rev/fun/log_softmax.hpp
+++ b/stan/math/rev/fun/log_softmax.hpp
@@ -1,15 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_LOG_SOFTMAX_HPP
 #define STAN_MATH_REV_FUN_LOG_SOFTMAX_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
+#include <stan/math/rev/fun/softmax.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/log_softmax.hpp>
-#include <stan/math/prim/fun/softmax.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/log_softmax.hpp>
 #include <cmath>
 #include <vector>
 
diff --git a/stan/math/rev/fun/log_sum_exp.hpp b/stan/math/rev/fun/log_sum_exp.hpp
index 62b82907aa4..69299560616 100644
--- a/stan/math/rev/fun/log_sum_exp.hpp
+++ b/stan/math/rev/fun/log_sum_exp.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_LOG_SUM_EXP_HPP
 #define STAN_MATH_REV_FUN_LOG_SUM_EXP_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log_sum_exp.hpp>
 #include <cmath>
 #include <vector>
diff --git a/stan/math/rev/fun/logit.hpp b/stan/math/rev/fun/logit.hpp
index 10aaf8b0545..eb88c303687 100644
--- a/stan/math/rev/fun/logit.hpp
+++ b/stan/math/rev/fun/logit.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/fun/square.hpp>
 #include <stan/math/prim/fun/logit.hpp>
-#include <stan/math/prim/fun/square.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/matrix_power.hpp b/stan/math/rev/fun/matrix_power.hpp
index bba92fd1e0f..a8cfa2a7392 100644
--- a/stan/math/rev/fun/matrix_power.hpp
+++ b/stan/math/rev/fun/matrix_power.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_MATRIX_POWER_HPP
 #define STAN_MATH_REV_FUN_MATRIX_POWER_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/matrix_power.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/mdivide_left.hpp b/stan/math/rev/fun/mdivide_left.hpp
index 8c0c88d8ed5..45b5d06c081 100644
--- a/stan/math/rev/fun/mdivide_left.hpp
+++ b/stan/math/rev/fun/mdivide_left.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_MDIVIDE_LEFT_HPP
 #define STAN_MATH_REV_FUN_MDIVIDE_LEFT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/rev/core/chainable_object.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/mdivide_left.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/mdivide_left_ldlt.hpp b/stan/math/rev/fun/mdivide_left_ldlt.hpp
index 5c40c81c6d2..235131cc678 100644
--- a/stan/math/rev/fun/mdivide_left_ldlt.hpp
+++ b/stan/math/rev/fun/mdivide_left_ldlt.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_MDIVIDE_LEFT_LDLT_HPP
 #define STAN_MATH_REV_FUN_MDIVIDE_LEFT_LDLT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/LDLT_factor.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/mdivide_left_ldlt.hpp>
 #include <memory>
 
 namespace stan {
diff --git a/stan/math/rev/fun/mdivide_left_spd.hpp b/stan/math/rev/fun/mdivide_left_spd.hpp
index 58a4486235c..982575a1a6f 100644
--- a/stan/math/rev/fun/mdivide_left_spd.hpp
+++ b/stan/math/rev/fun/mdivide_left_spd.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_MDIVIDE_LEFT_SPD_HPP
 #define STAN_MATH_REV_FUN_MDIVIDE_LEFT_SPD_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/mdivide_left_spd.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/mdivide_left_tri.hpp b/stan/math/rev/fun/mdivide_left_tri.hpp
index 925b3e5944a..2572811438c 100644
--- a/stan/math/rev/fun/mdivide_left_tri.hpp
+++ b/stan/math/rev/fun/mdivide_left_tri.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/mdivide_left_tri.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/multiply.hpp b/stan/math/rev/fun/multiply.hpp
index a2c1348896a..4f2902c9075 100644
--- a/stan/math/rev/fun/multiply.hpp
+++ b/stan/math/rev/fun/multiply.hpp
@@ -4,7 +4,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
-#include <stan/math/prim/fun.hpp>
+#include <stan/math/rev/fun/value_of.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/multiply_log.hpp b/stan/math/rev/fun/multiply_log.hpp
index 5b8850d0f66..293cb1856cb 100644
--- a/stan/math/rev/fun/multiply_log.hpp
+++ b/stan/math/rev/fun/multiply_log.hpp
@@ -7,8 +7,8 @@
 #include <stan/math/rev/fun/elt_multiply.hpp>
 #include <stan/math/rev/fun/multiply.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/multiply_log.hpp>
 #include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/multiply_log.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp b/stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp
index 5e4d6c42c42..5ac9494c0c0 100644
--- a/stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp
+++ b/stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp
@@ -1,12 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_MULTIPLY_LOWER_TRI_SELF_TRANSPOSE_HPP
 #define STAN_MATH_REV_FUN_MULTIPLY_LOWER_TRI_SELF_TRANSPOSE_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/dot_product.hpp>
 #include <stan/math/rev/fun/dot_self.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/multiply_lower_tri_self_transpose.hpp>
 
diff --git a/stan/math/rev/fun/norm.hpp b/stan/math/rev/fun/norm.hpp
index 846f2a1651a..e92e4965ab6 100644
--- a/stan/math/rev/fun/norm.hpp
+++ b/stan/math/rev/fun/norm.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_REV_FUN_NORM_HPP
 #define STAN_MATH_REV_FUN_NORM_HPP
 
-#include <stan/math/prim/fun/norm.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/square.hpp>
+#include <stan/math/prim/fun/norm.hpp>
 #include <complex>
 
 namespace stan {
diff --git a/stan/math/rev/fun/norm1.hpp b/stan/math/rev/fun/norm1.hpp
index bc63b6d42c4..0bf8c9fa334 100644
--- a/stan/math/rev/fun/norm1.hpp
+++ b/stan/math/rev/fun/norm1.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/sign.hpp>
+#include <stan/math/prim/fun/norm1.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/norm2.hpp b/stan/math/rev/fun/norm2.hpp
index b06cc3c48c2..f3599c1e693 100644
--- a/stan/math/rev/fun/norm2.hpp
+++ b/stan/math/rev/fun/norm2.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_NORM2_HPP
 #define STAN_MATH_REV_FUN_NORM2_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/norm2.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/owens_t.hpp b/stan/math/rev/fun/owens_t.hpp
index 74308076900..581f099ff07 100644
--- a/stan/math/rev/fun/owens_t.hpp
+++ b/stan/math/rev/fun/owens_t.hpp
@@ -3,11 +3,11 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/erf.hpp>
+#include <stan/math/rev/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/erf.hpp>
 #include <stan/math/prim/fun/eval.hpp>
 #include <stan/math/prim/fun/owens_t.hpp>
-#include <stan/math/prim/fun/square.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/polar.hpp b/stan/math/rev/fun/polar.hpp
index d2c73bf835b..16c0636dc2f 100644
--- a/stan/math/rev/fun/polar.hpp
+++ b/stan/math/rev/fun/polar.hpp
@@ -1,15 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_POLAR_HPP
 #define STAN_MATH_REV_FUN_POLAR_HPP
 
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/is_inf.hpp>
+#include <stan/math/rev/fun/cos.hpp>
+#include <stan/math/rev/fun/sin.hpp>
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/polar.hpp>
 #include <stan/math/prim/fun/isinf.hpp>
 #include <stan/math/prim/fun/isfinite.hpp>
 #include <stan/math/prim/fun/is_inf.hpp>
-#include <stan/math/prim/fun/sin.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/rev/fun/is_inf.hpp>
-#include <stan/math/rev/fun/sin.hpp>
+#include <stan/math/prim/fun/polar.hpp>
 #include <complex>
 #include <type_traits>
 
diff --git a/stan/math/rev/fun/pow.hpp b/stan/math/rev/fun/pow.hpp
index 669f53908b4..139baa51447 100644
--- a/stan/math/rev/fun/pow.hpp
+++ b/stan/math/rev/fun/pow.hpp
@@ -1,17 +1,9 @@
 #ifndef STAN_MATH_REV_FUN_POW_HPP
 #define STAN_MATH_REV_FUN_POW_HPP
 
-#include <stan/math/prim/core.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/constants.hpp>
-#include <stan/math/prim/fun/copysign.hpp>
-#include <stan/math/prim/fun/is_any_nan.hpp>
-#include <stan/math/prim/fun/isnan.hpp>
-#include <stan/math/prim/fun/is_nan.hpp>
-#include <stan/math/prim/fun/pow.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/rev/fun/inv.hpp>
 #include <stan/math/rev/fun/inv_sqrt.hpp>
 #include <stan/math/rev/fun/inv_square.hpp>
@@ -20,6 +12,16 @@
 #include <stan/math/rev/fun/sqrt.hpp>
 #include <stan/math/rev/fun/square.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
+#include <stan/math/prim/core.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/copysign.hpp>
+#include <stan/math/prim/fun/is_any_nan.hpp>
+#include <stan/math/prim/fun/isnan.hpp>
+#include <stan/math/prim/fun/is_nan.hpp>
+#include <stan/math/prim/fun/pow.hpp>
+
 #include <cmath>
 #include <complex>
 #include <type_traits>
diff --git a/stan/math/rev/fun/proj.hpp b/stan/math/rev/fun/proj.hpp
index ceb83db8bfa..9831780bdd0 100644
--- a/stan/math/rev/fun/proj.hpp
+++ b/stan/math/rev/fun/proj.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_REV_FUN_PROJ_HPP
 #define STAN_MATH_REV_FUN_PROJ_HPP
 
-#include <stan/math/prim/fun/proj.hpp>
-#include <stan/math/prim/fun/is_inf.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/is_inf.hpp>
+#include <stan/math/prim/fun/proj.hpp>
+#include <stan/math/prim/fun/is_inf.hpp>
 #include <complex>
 
 namespace stan {
diff --git a/stan/math/rev/fun/quad_form.hpp b/stan/math/rev/fun/quad_form.hpp
index 431e30b3f79..e2da4e01bae 100644
--- a/stan/math/rev/fun/quad_form.hpp
+++ b/stan/math/rev/fun/quad_form.hpp
@@ -4,11 +4,11 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/to_var_value.hpp>
+#include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/quad_form.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/quad_form.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/quad_form_sym.hpp b/stan/math/rev/fun/quad_form_sym.hpp
index b9fee7da3b7..4c4f0257f8e 100644
--- a/stan/math/rev/fun/quad_form_sym.hpp
+++ b/stan/math/rev/fun/quad_form_sym.hpp
@@ -1,12 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_QUAD_FORM_SYM_HPP
 #define STAN_MATH_REV_FUN_QUAD_FORM_SYM_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/quad_form.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/rev/fun/quad_form.hpp>
+#include <stan/math/prim/fun/quad_form_sym.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/read_corr_L.hpp b/stan/math/rev/fun/read_corr_L.hpp
index dcfdde602d3..3512f4d0692 100644
--- a/stan/math/rev/fun/read_corr_L.hpp
+++ b/stan/math/rev/fun/read_corr_L.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_REV_FUN_READ_CORR_L_HPP
 #define STAN_MATH_REV_FUN_READ_CORR_L_HPP
 
-#include <stan/math/prim/fun/read_corr_L.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/operator_multiplication.hpp>
+#include <stan/math/prim/fun/read_corr_L.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/read_corr_matrix.hpp b/stan/math/rev/fun/read_corr_matrix.hpp
index a5d8281740d..ee56dec9883 100644
--- a/stan/math/rev/fun/read_corr_matrix.hpp
+++ b/stan/math/rev/fun/read_corr_matrix.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_REV_FUN_READ_CORR_MATRIX_HPP
 #define STAN_MATH_REV_FUN_READ_CORR_MATRIX_HPP
 
-#include <stan/math/rev/core.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/read_corr_L.hpp>
-#include <stan/math/prim/fun/multiply_lower_tri_self_transpose.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/read_corr_L.hpp>
+#include <stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/read_cov_L.hpp b/stan/math/rev/fun/read_cov_L.hpp
index d4e7b4da8ce..cc33adf8b38 100644
--- a/stan/math/rev/fun/read_cov_L.hpp
+++ b/stan/math/rev/fun/read_cov_L.hpp
@@ -3,11 +3,11 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/log.hpp>
-#include <stan/math/prim/fun/read_cov_L.hpp>
+#include <stan/math/rev/fun/log.hpp>
 #include <stan/math/rev/fun/read_corr_L.hpp>
-#include <stan/math/prim/fun/sum.hpp>
+#include <stan/math/rev/fun/sum.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/read_cov_L.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/read_cov_matrix.hpp b/stan/math/rev/fun/read_cov_matrix.hpp
index 3885441079d..46609964bc2 100644
--- a/stan/math/rev/fun/read_cov_matrix.hpp
+++ b/stan/math/rev/fun/read_cov_matrix.hpp
@@ -1,12 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_READ_COV_MATRIX_HPP
 #define STAN_MATH_REV_FUN_READ_COV_MATRIX_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/read_corr_L.hpp>
 #include <stan/math/rev/fun/read_cov_L.hpp>
 #include <stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp>
 #include <stan/math/rev/fun/rows_dot_product.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/read_cov_matrix.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/rising_factorial.hpp b/stan/math/rev/fun/rising_factorial.hpp
index 98e7549694b..ec95ac455b8 100644
--- a/stan/math/rev/fun/rising_factorial.hpp
+++ b/stan/math/rev/fun/rising_factorial.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/rising_factorial.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/rows_dot_product.hpp b/stan/math/rev/fun/rows_dot_product.hpp
index 61a014c8356..2abc0fef8fb 100644
--- a/stan/math/rev/fun/rows_dot_product.hpp
+++ b/stan/math/rev/fun/rows_dot_product.hpp
@@ -1,12 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_ROWS_DOT_PRODUCT_HPP
 #define STAN_MATH_REV_FUN_ROWS_DOT_PRODUCT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/rev/fun/dot_product.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/rows_dot_product.hpp>
 #include <type_traits>
 
diff --git a/stan/math/rev/fun/rows_dot_self.hpp b/stan/math/rev/fun/rows_dot_self.hpp
index a24084d99fa..7cccd0bbb23 100644
--- a/stan/math/rev/fun/rows_dot_self.hpp
+++ b/stan/math/rev/fun/rows_dot_self.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_ROWS_DOT_SELF_HPP
 #define STAN_MATH_REV_FUN_ROWS_DOT_SELF_HPP
 
-#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/dot_self.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/rows_dot_self.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/sd.hpp b/stan/math/rev/fun/sd.hpp
index 76494763766..e3db2d1651f 100644
--- a/stan/math/rev/fun/sd.hpp
+++ b/stan/math/rev/fun/sd.hpp
@@ -1,12 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_SD_HPP
 #define STAN_MATH_REV_FUN_SD_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/inv_sqrt.hpp>
+#include <stan/math/rev/fun/sqrt.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/inv_sqrt.hpp>
+#include <stan/math/prim/fun/sd.hpp>
 #include <cmath>
 #include <vector>
 
diff --git a/stan/math/rev/fun/sin.hpp b/stan/math/rev/fun/sin.hpp
index 2022fb3eeb2..f0da3889d8a 100644
--- a/stan/math/rev/fun/sin.hpp
+++ b/stan/math/rev/fun/sin.hpp
@@ -1,15 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_SIN_HPP
 #define STAN_MATH_REV_FUN_SIN_HPP
 
-#include <stan/math/prim/fun/cos.hpp>
-#include <stan/math/prim/fun/isfinite.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/sin.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/is_inf.hpp>
 #include <stan/math/rev/fun/cosh.hpp>
 #include <stan/math/rev/fun/sinh.hpp>
+#include <stan/math/prim/fun/isfinite.hpp>
+#include <stan/math/prim/fun/isinf.hpp>
+#include <stan/math/prim/fun/sin.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/singular_values.hpp b/stan/math/rev/fun/singular_values.hpp
index 111e4800da0..0cd703eff41 100644
--- a/stan/math/rev/fun/singular_values.hpp
+++ b/stan/math/rev/fun/singular_values.hpp
@@ -2,9 +2,9 @@
 #define STAN_MATH_REV_FUN_SINGULAR_VALUES_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err/check_nonzero_size.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/err/check_nonzero_size.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/sinh.hpp b/stan/math/rev/fun/sinh.hpp
index 1e8aa4fbe50..1322f6c1b88 100644
--- a/stan/math/rev/fun/sinh.hpp
+++ b/stan/math/rev/fun/sinh.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_SINH_HPP
 #define STAN_MATH_REV_FUN_SINH_HPP
 
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/prim/core.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/isinf.hpp>
 #include <stan/math/prim/fun/sinh.hpp>
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/rev/fun/exp.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/softmax.hpp b/stan/math/rev/fun/softmax.hpp
index 4d8b98a1170..a1bf786e826 100644
--- a/stan/math/rev/fun/softmax.hpp
+++ b/stan/math/rev/fun/softmax.hpp
@@ -1,15 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_SOFTMAX_HPP
 #define STAN_MATH_REV_FUN_SOFTMAX_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/core/reverse_pass_callback.hpp>
 #include <stan/math/rev/core/arena_matrix.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/softmax.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/softmax.hpp>
 #include <tuple>
 #include <vector>
 
diff --git a/stan/math/rev/fun/sqrt.hpp b/stan/math/rev/fun/sqrt.hpp
index cbecd2c6934..c4d40696cfc 100644
--- a/stan/math/rev/fun/sqrt.hpp
+++ b/stan/math/rev/fun/sqrt.hpp
@@ -1,12 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_SQRT_HPP
 #define STAN_MATH_REV_FUN_SQRT_HPP
 
-#include <stan/math/prim/fun/sqrt.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/atan2.hpp>
 #include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/hypot.hpp>
+#include <stan/math/rev/fun/sin.hpp>
+#include <stan/math/prim/fun/sqrt.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/square.hpp b/stan/math/rev/fun/square.hpp
index 0d49b24d1e9..972db13264f 100644
--- a/stan/math/rev/fun/square.hpp
+++ b/stan/math/rev/fun/square.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-
+#include <stan/math/prim/fun/square.hpp>
 namespace stan {
 namespace math {
 
diff --git a/stan/math/rev/fun/squared_distance.hpp b/stan/math/rev/fun/squared_distance.hpp
index b539751101f..4fa774f74df 100644
--- a/stan/math/rev/fun/squared_distance.hpp
+++ b/stan/math/rev/fun/squared_distance.hpp
@@ -1,15 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_SQUARED_DISTANCE_HPP
 #define STAN_MATH_REV_FUN_SQUARED_DISTANCE_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/as_column_vector_or_scalar.hpp>
-#include <stan/math/prim/fun/squared_distance.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/squared_distance.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/step.hpp b/stan/math/rev/fun/step.hpp
index b2516a7e115..14956433324 100644
--- a/stan/math/rev/fun/step.hpp
+++ b/stan/math/rev/fun/step.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/step.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/sum.hpp b/stan/math/rev/fun/sum.hpp
index 9f4ba90ec5b..1ab6f3352ca 100644
--- a/stan/math/rev/fun/sum.hpp
+++ b/stan/math/rev/fun/sum.hpp
@@ -11,6 +11,7 @@
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/prim/fun/as_array_or_scalar.hpp>
+#include <stan/math/prim/fun/sum.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/svd.hpp b/stan/math/rev/fun/svd.hpp
index 33ef934cbc9..2ae31c4825f 100644
--- a/stan/math/rev/fun/svd.hpp
+++ b/stan/math/rev/fun/svd.hpp
@@ -2,11 +2,12 @@
 #define STAN_MATH_REV_FUN_SVD_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err/check_nonzero_size.hpp>
-#include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/prim/err/check_nonzero_size.hpp>
+#include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/svd.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/svd_U.hpp b/stan/math/rev/fun/svd_U.hpp
index 6a208e3c6e3..217306bcc68 100644
--- a/stan/math/rev/fun/svd_U.hpp
+++ b/stan/math/rev/fun/svd_U.hpp
@@ -2,11 +2,12 @@
 #define STAN_MATH_REV_FUN_SVD_U_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err/check_nonzero_size.hpp>
-#include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/prim/err/check_nonzero_size.hpp>
+#include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/svd_U.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/svd_V.hpp b/stan/math/rev/fun/svd_V.hpp
index 963c3c71572..6b17929f831 100644
--- a/stan/math/rev/fun/svd_V.hpp
+++ b/stan/math/rev/fun/svd_V.hpp
@@ -2,11 +2,12 @@
 #define STAN_MATH_REV_FUN_SVD_V_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err/check_nonzero_size.hpp>
-#include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/prim/err/check_nonzero_size.hpp>
+#include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/svd_V.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/tan.hpp b/stan/math/rev/fun/tan.hpp
index 564b88447fc..34ed949db7b 100644
--- a/stan/math/rev/fun/tan.hpp
+++ b/stan/math/rev/fun/tan.hpp
@@ -1,13 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_TAN_HPP
 #define STAN_MATH_REV_FUN_TAN_HPP
 
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/tan.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/is_inf.hpp>
 #include <stan/math/rev/fun/sinh.hpp>
 #include <stan/math/rev/fun/tanh.hpp>
+#include <stan/math/prim/fun/isinf.hpp>
+#include <stan/math/prim/fun/tan.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/tanh.hpp b/stan/math/rev/fun/tanh.hpp
index 39eb1bc9579..0ebc7f43f81 100644
--- a/stan/math/rev/fun/tanh.hpp
+++ b/stan/math/rev/fun/tanh.hpp
@@ -1,11 +1,11 @@
 #ifndef STAN_MATH_REV_FUN_TANH_HPP
 #define STAN_MATH_REV_FUN_TANH_HPP
 
-#include <stan/math/prim/fun/tanh.hpp>
-#include <stan/math/prim/fun/cosh.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/cosh.hpp>
 #include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/prim/fun/tanh.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/tcrossprod.hpp b/stan/math/rev/fun/tcrossprod.hpp
index 5762b08ee20..e5beb438c44 100644
--- a/stan/math/rev/fun/tcrossprod.hpp
+++ b/stan/math/rev/fun/tcrossprod.hpp
@@ -1,13 +1,14 @@
 #ifndef STAN_MATH_REV_FUN_TCROSSPROD_HPP
 #define STAN_MATH_REV_FUN_TCROSSPROD_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/rev/fun/dot_product.hpp>
 #include <stan/math/rev/fun/dot_self.hpp>
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/tcrossprod.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/tgamma.hpp b/stan/math/rev/fun/tgamma.hpp
index 67d438f2a53..fa92b350ef4 100644
--- a/stan/math/rev/fun/tgamma.hpp
+++ b/stan/math/rev/fun/tgamma.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/digamma.hpp>
+#include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/prim/fun/tgamma.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/trace.hpp b/stan/math/rev/fun/trace.hpp
index 362e798bf2e..dfeb74c21d0 100644
--- a/stan/math/rev/fun/trace.hpp
+++ b/stan/math/rev/fun/trace.hpp
@@ -2,9 +2,10 @@
 #define STAN_MATH_REV_FUN_TRACE_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/trace.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/trace_gen_inv_quad_form_ldlt.hpp b/stan/math/rev/fun/trace_gen_inv_quad_form_ldlt.hpp
index f88802af48d..ab41f67f7c6 100644
--- a/stan/math/rev/fun/trace_gen_inv_quad_form_ldlt.hpp
+++ b/stan/math/rev/fun/trace_gen_inv_quad_form_ldlt.hpp
@@ -1,11 +1,12 @@
 #ifndef STAN_MATH_REV_FUN_TRACE_GEN_INV_QUAD_FORM_LDLT_HPP
 #define STAN_MATH_REV_FUN_TRACE_GEN_INV_QUAD_FORM_LDLT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/trace_inv_quad_form_ldlt.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/trace_gen_inv_quad_form_ldlt.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/trace_gen_quad_form.hpp b/stan/math/rev/fun/trace_gen_quad_form.hpp
index 13d74683ba2..2c0294fe202 100644
--- a/stan/math/rev/fun/trace_gen_quad_form.hpp
+++ b/stan/math/rev/fun/trace_gen_quad_form.hpp
@@ -1,14 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_TRACE_GEN_QUAD_FORM_HPP
 #define STAN_MATH_REV_FUN_TRACE_GEN_QUAD_FORM_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/fun/trace_gen_quad_form.hpp>
 #include <type_traits>
 
diff --git a/stan/math/rev/fun/trace_inv_quad_form_ldlt.hpp b/stan/math/rev/fun/trace_inv_quad_form_ldlt.hpp
index 207e029768c..9f52759f544 100644
--- a/stan/math/rev/fun/trace_inv_quad_form_ldlt.hpp
+++ b/stan/math/rev/fun/trace_inv_quad_form_ldlt.hpp
@@ -1,14 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_TRACE_INV_QUAD_FORM_LDLT_HPP
 #define STAN_MATH_REV_FUN_TRACE_INV_QUAD_FORM_LDLT_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/LDLT_factor.hpp>
 #include <stan/math/rev/core/typedefs.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/trace_inv_quad_form_ldlt.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/trace_quad_form.hpp b/stan/math/rev/fun/trace_quad_form.hpp
index 6b9ceb8ce0a..832d511fe94 100644
--- a/stan/math/rev/fun/trace_quad_form.hpp
+++ b/stan/math/rev/fun/trace_quad_form.hpp
@@ -1,16 +1,15 @@
 #ifndef STAN_MATH_REV_FUN_TRACE_QUAD_FORM_HPP
 #define STAN_MATH_REV_FUN_TRACE_QUAD_FORM_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/fun/to_var_value.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/trace_quad_form.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/fun/trace_quad_form.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/variance.hpp b/stan/math/rev/fun/variance.hpp
index 4ee2dc47c85..f10356af71e 100644
--- a/stan/math/rev/fun/variance.hpp
+++ b/stan/math/rev/fun/variance.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/fun/variance.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/test/unit/math/mix/fun/conj_test.cpp b/test/unit/math/mix/fun/conj_test.cpp
index 2c753ab862c..359e1b0437a 100644
--- a/test/unit/math/mix/fun/conj_test.cpp
+++ b/test/unit/math/mix/fun/conj_test.cpp
@@ -1,4 +1,3 @@
-#include <stan/math/prim.hpp>
 #include <test/unit/math/test_ad.hpp>
 #include <complex>
 #include <vector>