From f87e167540737b6b7f189ee0b25f040d76f4a4a7 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 5 Nov 2024 17:38:54 -0500
Subject: [PATCH 01/19] testing encapsulation of std complex

---
 stan/math/prim/fun/abs.hpp         |  8 ++-
 stan/math/prim/meta.hpp            |  1 +
 stan/math/prim/meta/base_type.hpp  | 13 +----
 stan/math/prim/meta/is_complex.hpp | 18 +++++++
 stan/math/prim/meta/is_real.hpp    | 79 ++++++++++++++++++++++++++++++
 5 files changed, 106 insertions(+), 13 deletions(-)
 create mode 100644 stan/math/prim/meta/is_real.hpp

diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 317fd6a846d..0bea6e321e0 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -34,7 +34,13 @@ 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) {
+  using std::hypot;
+  return hypot(x.real(), x.imag());
+}
+
+template <typename T, require_complex_bt<is_autodiff, T>* = nullptr>
 inline auto abs(T x) {
   return hypot(x.real(), x.imag());
 }
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..eb70e7592b0 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,7 @@ 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..2a7d77d39f1 100644
--- a/stan/math/prim/meta/is_complex.hpp
+++ b/stan/math/prim/meta/is_complex.hpp
@@ -1,6 +1,7 @@
 #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/scalar_type.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <stan/math/prim/meta/require_helpers.hpp>
@@ -55,6 +56,18 @@ 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>;
+};
+
 /*! \ingroup require_stan_scalar_complex */
 /*! \defgroup complex_types complex  */
 /*! \addtogroup complex_types */
@@ -107,6 +120,11 @@ 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 `T` is complex and it's @ref base_type satisfies a given type trait */
+/*! @tparam T A type with a valid overload of @ref base_type available */
+template <template <class...> typename Check, typename T>
+using require_complex_bt = require_t<stan::math::conjunction<Check<base_type_t<std::decay_t<T>>>, is_complex<std::decay_t<T>>>>;
 /*! @} */
 
 /**
diff --git a/stan/math/prim/meta/is_real.hpp b/stan/math/prim/meta/is_real.hpp
new file mode 100644
index 00000000000..61747066944
--- /dev/null
+++ b/stan/math/prim/meta/is_real.hpp
@@ -0,0 +1,79 @@
+#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
+ * @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>>...>;
+/*! @} */
+
+
+}
+
+#endif

From 2f225e2d88839ee90611c86a1b948b48694b9ebe Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 6 Nov 2024 17:58:37 -0500
Subject: [PATCH 02/19] fix all headers in rev

---
 stan/math/fwd/fun/acos.hpp                    |  4 +--
 stan/math/fwd/fun/acosh.hpp                   |  5 ++-
 stan/math/fwd/fun/asin.hpp                    |  5 ++-
 stan/math/fwd/fun/asinh.hpp                   |  3 +-
 stan/math/fwd/fun/atan.hpp                    |  3 +-
 stan/math/fwd/fun/atan2.hpp                   |  5 +--
 stan/math/fwd/fun/atanh.hpp                   |  2 +-
 stan/math/fwd/fun/beta.hpp                    |  2 +-
 stan/math/fwd/fun/cbrt.hpp                    |  2 +-
 stan/math/fwd/fun/ceil.hpp                    |  1 -
 stan/math/fwd/fun/cos.hpp                     |  3 +-
 stan/math/fwd/fun/cosh.hpp                    |  3 +-
 stan/math/fwd/fun/erf.hpp                     |  2 +-
 stan/math/fwd/fun/inv.hpp                     |  2 +-
 stan/math/fwd/fun/sin.hpp                     |  3 +-
 stan/math/fwd/fun/sinh.hpp                    |  5 ++-
 stan/math/fwd/fun/softmax.hpp                 |  2 +-
 stan/math/fwd/fun/sqrt.hpp                    |  5 +--
 stan/math/fwd/fun/tan.hpp                     |  3 +-
 stan/math/fwd/fun/tanh.hpp                    |  1 -
 stan/math/mix/fun/typedefs.hpp                |  2 +-
 stan/math/mix/functor/derivative.hpp          |  2 +-
 .../functor/finite_diff_grad_hessian_auto.hpp |  2 +-
 stan/math/mix/functor/grad_hessian.hpp        |  2 +-
 .../mix/functor/grad_tr_mat_times_hessian.hpp |  4 +--
 stan/math/mix/functor/gradient_dot_vector.hpp |  2 +-
 stan/math/mix/functor/hessian.hpp             |  2 +-
 .../math/mix/functor/hessian_times_vector.hpp |  2 +-
 stan/math/mix/functor/partial_derivative.hpp  |  2 +-
 stan/math/mix/meta.hpp                        |  9 ++---
 stan/math/prim/fun/abs.hpp                    | 14 ++------
 stan/math/prim/fun/acos.hpp                   | 19 ++++++----
 stan/math/prim/fun/acosh.hpp                  | 36 ++++++++-----------
 stan/math/prim/fun/arg.hpp                    |  4 +--
 stan/math/prim/fun/asin.hpp                   | 19 ++++++----
 stan/math/prim/fun/asinh.hpp                  | 21 ++++++++---
 stan/math/prim/fun/atan.hpp                   | 22 +++++++-----
 stan/math/prim/fun/atanh.hpp                  | 26 +++++++-------
 stan/math/prim/fun/cos.hpp                    | 19 ++++++----
 stan/math/prim/fun/cosh.hpp                   | 19 ++++++----
 stan/math/prim/fun/exp.hpp                    | 20 +++++++----
 stan/math/prim/fun/floor.hpp                  | 18 ++++++----
 stan/math/prim/fun/gp_periodic_cov.hpp        |  4 ---
 stan/math/prim/fun/inv_cloglog.hpp            | 17 ++++-----
 stan/math/prim/fun/inv_sqrt.hpp               | 20 +++++------
 stan/math/prim/fun/log.hpp                    | 18 ++++++----
 stan/math/prim/fun/log10.hpp                  | 18 +++++++---
 stan/math/prim/fun/logit.hpp                  | 16 ++++-----
 stan/math/prim/fun/matrix_exp_2x2.hpp         |  4 ---
 stan/math/prim/fun/polar.hpp                  |  5 ++-
 stan/math/prim/fun/sin.hpp                    | 19 ++++++----
 stan/math/prim/fun/sinh.hpp                   | 19 ++++++----
 stan/math/prim/fun/sqrt.hpp                   | 19 ++++++----
 stan/math/prim/fun/square.hpp                 | 10 +++---
 stan/math/prim/fun/tan.hpp                    | 20 +++++++----
 stan/math/prim/fun/tanh.hpp                   | 21 ++++++-----
 stan/math/prim/fun/trigamma.hpp               |  2 --
 stan/math/prim/meta/is_complex.hpp            | 13 ++++---
 stan/math/prim/meta/is_container.hpp          | 18 ++++++++++
 stan/math/prim/prob/cauchy_lccdf.hpp          |  3 +-
 stan/math/prim/prob/cauchy_lcdf.hpp           |  3 +-
 stan/math/prim/prob/wiener_lpdf.hpp           |  8 ++---
 stan/math/rev/fun/Phi_approx.hpp              |  2 +-
 stan/math/rev/fun/abs.hpp                     |  2 +-
 stan/math/rev/fun/acos.hpp                    |  3 +-
 stan/math/rev/fun/acosh.hpp                   |  8 ++---
 stan/math/rev/fun/asin.hpp                    |  4 +--
 stan/math/rev/fun/asinh.hpp                   | 10 +++---
 stan/math/rev/fun/atan.hpp                    |  7 ++--
 stan/math/rev/fun/atanh.hpp                   |  2 +-
 stan/math/rev/fun/beta.hpp                    |  2 +-
 stan/math/rev/fun/binary_log_loss.hpp         |  2 +-
 stan/math/rev/fun/cholesky_decompose.hpp      |  8 ++---
 stan/math/rev/fun/columns_dot_product.hpp     |  4 +--
 stan/math/rev/fun/columns_dot_self.hpp        |  4 +--
 stan/math/rev/fun/cos.hpp                     |  7 ++--
 stan/math/rev/fun/cosh.hpp                    |  2 +-
 stan/math/rev/fun/cov_exp_quad.hpp            |  4 +--
 stan/math/rev/fun/diag_post_multiply.hpp      |  2 +-
 stan/math/rev/fun/diag_pre_multiply.hpp       |  2 +-
 stan/math/rev/fun/digamma.hpp                 |  2 +-
 stan/math/rev/fun/dot_product.hpp             |  7 ++--
 stan/math/rev/fun/dot_self.hpp                |  3 +-
 stan/math/rev/fun/eigendecompose_sym.hpp      |  5 ++-
 stan/math/rev/fun/eigenvalues_sym.hpp         |  2 +-
 stan/math/rev/fun/elt_multiply.hpp            |  4 +--
 stan/math/rev/fun/erf.hpp                     |  2 +-
 stan/math/rev/fun/exp.hpp                     |  8 ++---
 stan/math/rev/fun/falling_factorial.hpp       |  2 +-
 stan/math/rev/fun/fft.hpp                     |  1 -
 stan/math/rev/fun/gamma_p.hpp                 |  4 +--
 stan/math/rev/fun/gamma_q.hpp                 |  7 ++--
 stan/math/rev/fun/generalized_inverse.hpp     |  4 +--
 stan/math/rev/fun/gp_exp_quad_cov.hpp         |  4 +--
 stan/math/rev/fun/gp_periodic_cov.hpp         | 12 +++----
 stan/math/rev/fun/grad_inc_beta.hpp           |  6 ++--
 stan/math/rev/fun/hypergeometric_1F0.hpp      |  8 ++---
 stan/math/rev/fun/hypergeometric_2F1.hpp      |  2 +-
 stan/math/rev/fun/hypergeometric_pFq.hpp      |  2 +-
 stan/math/rev/fun/inc_beta.hpp                |  4 +--
 stan/math/rev/fun/inv_cloglog.hpp             |  1 +
 stan/math/rev/fun/inv_erfc.hpp                |  4 +--
 stan/math/rev/fun/inv_inc_beta.hpp            | 21 ++++++-----
 stan/math/rev/fun/inv_sqrt.hpp                |  4 ++-
 stan/math/rev/fun/lambert_w.hpp               |  2 +-
 stan/math/rev/fun/lbeta.hpp                   |  2 +-
 stan/math/rev/fun/ldexp.hpp                   |  2 +-
 stan/math/rev/fun/lgamma.hpp                  |  2 +-
 stan/math/rev/fun/lmgamma.hpp                 |  2 +-
 stan/math/rev/fun/lmultiply.hpp               |  4 +--
 stan/math/rev/fun/log.hpp                     |  2 +-
 stan/math/rev/fun/log10.hpp                   |  5 ++-
 stan/math/rev/fun/log1m_exp.hpp               |  2 +-
 stan/math/rev/fun/log1m_inv_logit.hpp         |  2 +-
 stan/math/rev/fun/log1p_exp.hpp               |  2 +-
 stan/math/rev/fun/log2.hpp                    |  2 +-
 stan/math/rev/fun/log_determinant_spd.hpp     |  4 +--
 stan/math/rev/fun/log_diff_exp.hpp            |  2 +-
 stan/math/rev/fun/log_falling_factorial.hpp   |  2 +-
 stan/math/rev/fun/log_inv_logit.hpp           |  2 +-
 stan/math/rev/fun/log_inv_logit_diff.hpp      |  6 ++--
 stan/math/rev/fun/log_mix.hpp                 |  3 +-
 stan/math/rev/fun/log_rising_factorial.hpp    |  1 -
 stan/math/rev/fun/log_softmax.hpp             |  6 ++--
 stan/math/rev/fun/log_sum_exp.hpp             |  4 +--
 stan/math/rev/fun/logit.hpp                   |  2 +-
 stan/math/rev/fun/multiply.hpp                |  2 +-
 stan/math/rev/fun/multiply_log.hpp            |  2 +-
 stan/math/rev/fun/owens_t.hpp                 |  4 +--
 stan/math/rev/fun/polar.hpp                   | 10 +++---
 stan/math/rev/fun/pow.hpp                     | 20 ++++++-----
 stan/math/rev/fun/quad_form.hpp               |  2 +-
 stan/math/rev/fun/read_corr_matrix.hpp        |  4 +--
 stan/math/rev/fun/read_cov_L.hpp              |  2 +-
 stan/math/rev/fun/rising_factorial.hpp        |  2 +-
 stan/math/rev/fun/rows_dot_product.hpp        |  2 +-
 stan/math/rev/fun/rows_dot_self.hpp           |  4 +--
 stan/math/rev/fun/sd.hpp                      |  3 +-
 stan/math/rev/fun/sin.hpp                     |  8 ++---
 stan/math/rev/fun/softmax.hpp                 |  4 +--
 stan/math/rev/fun/sqrt.hpp                    |  3 +-
 stan/math/rev/fun/square.hpp                  |  2 +-
 stan/math/rev/fun/squared_distance.hpp        |  2 +-
 stan/math/rev/fun/svd.hpp                     |  4 +--
 stan/math/rev/fun/svd_U.hpp                   |  4 +--
 stan/math/rev/fun/tan.hpp                     |  4 +--
 stan/math/rev/fun/tanh.hpp                    |  4 +--
 stan/math/rev/fun/tgamma.hpp                  |  2 +-
 stan/math/rev/fun/trace.hpp                   |  2 +-
 stan/math/rev/fun/trace_gen_quad_form.hpp     |  1 -
 stan/math/rev/fun/trace_quad_form.hpp         |  5 ++-
 151 files changed, 499 insertions(+), 442 deletions(-)

diff --git a/stan/math/fwd/fun/acos.hpp b/stan/math/fwd/fun/acos.hpp
index 75f0561578c..a173dfac287 100644
--- a/stan/math/fwd/fun/acos.hpp
+++ b/stan/math/fwd/fun/acos.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/acos.hpp>
 #include <cmath>
 #include <complex>
@@ -13,8 +13,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..5e871990275 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/square.hpp>
+#include <stan/math/fwd/fun/sqrt.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..0e3f2c93cbf 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/square.hpp>
+#include <stan/math/fwd/fun/sqrt.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..348294c6f52 100644
--- a/stan/math/fwd/fun/asinh.hpp
+++ b/stan/math/fwd/fun/asinh.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.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 +13,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..d60acc18a71 100644
--- a/stan/math/fwd/fun/atan.hpp
+++ b/stan/math/fwd/fun/atan.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.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 +13,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..40f9ec2a8ee 100644
--- a/stan/math/fwd/fun/atan2.hpp
+++ b/stan/math/fwd/fun/atan2.hpp
@@ -3,7 +3,7 @@
 
 #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 <cmath>
 
 namespace stan {
@@ -11,7 +11,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 +18,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..2294aca4836 100644
--- a/stan/math/fwd/fun/atanh.hpp
+++ b/stan/math/fwd/fun/atanh.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/square.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..94cfd35d257 100644
--- a/stan/math/fwd/fun/ceil.hpp
+++ b/stan/math/fwd/fun/ceil.hpp
@@ -10,7 +10,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/cos.hpp b/stan/math/fwd/fun/cos.hpp
index 0cfe38166b8..32a9c43ff6d 100644
--- a/stan/math/fwd/fun/cos.hpp
+++ b/stan/math/fwd/fun/cos.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/sin.hpp>
 #include <stan/math/prim/fun/cos.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +13,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/erf.hpp b/stan/math/fwd/fun/erf.hpp
index 6e88c092c0a..6ab0b8982a0 100644
--- a/stan/math/fwd/fun/erf.hpp
+++ b/stan/math/fwd/fun/erf.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.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 {
diff --git a/stan/math/fwd/fun/inv.hpp b/stan/math/fwd/fun/inv.hpp
index b5b2531f4fe..26154d5a1aa 100644
--- a/stan/math/fwd/fun/inv.hpp
+++ b/stan/math/fwd/fun/inv.hpp
@@ -3,7 +3,7 @@
 
 #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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/fwd/fun/sin.hpp b/stan/math/fwd/fun/sin.hpp
index c938cf4948d..bdeb1f1872e 100644
--- a/stan/math/fwd/fun/sin.hpp
+++ b/stan/math/fwd/fun/sin.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
 #include <stan/math/prim/fun/sin.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +13,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..4c9a558b094 100644
--- a/stan/math/fwd/fun/sinh.hpp
+++ b/stan/math/fwd/fun/sinh.hpp
@@ -1,9 +1,10 @@
 #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/prim/fun/sinh.hpp>
 #include <complex>
 
 namespace stan {
@@ -11,8 +12,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..fa03499112b 100644
--- a/stan/math/fwd/fun/softmax.hpp
+++ b/stan/math/fwd/fun/softmax.hpp
@@ -1,9 +1,9 @@
 #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>
diff --git a/stan/math/fwd/fun/sqrt.hpp b/stan/math/fwd/fun/sqrt.hpp
index aa8fa0abc5c..b7723e0b8de 100644
--- a/stan/math/fwd/fun/sqrt.hpp
+++ b/stan/math/fwd/fun/sqrt.hpp
@@ -3,10 +3,8 @@
 
 #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/inv_sqrt.hpp>
-#include <stan/math/fwd/fun/sqrt.hpp>
+#include <stan/math/prim/fun/sqrt.hpp>
 #include <cmath>
 #include <complex>
 
@@ -15,7 +13,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/tan.hpp b/stan/math/fwd/fun/tan.hpp
index 503ca10e2ef..358546208b1 100644
--- a/stan/math/fwd/fun/tan.hpp
+++ b/stan/math/fwd/fun/tan.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
+#include <stan/math/fwd/fun/tan.hpp>
 #include <stan/math/prim/fun/tan.hpp>
 #include <cmath>
 #include <complex>
@@ -12,8 +13,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/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..a0fd3787a86 100644
--- a/stan/math/mix/meta.hpp
+++ b/stan/math/mix/meta.hpp
@@ -3,16 +3,17 @@
 
 #include <stan/math/prim/meta/ad_promotable.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/rev/core.hpp>
-#include <stan/math/rev/meta/is_var.hpp>
-#include <stan/math/rev/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 0bea6e321e0..88d66271088 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -36,14 +36,9 @@ inline T abs(T x) {
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
 inline auto abs(T x) {
-  using std::hypot;
-  return hypot(x.real(), x.imag());
+  return std::hypot(x.real(), x.imag());
 }
 
-template <typename T, require_complex_bt<is_autodiff, T>* = nullptr>
-inline auto abs(T x) {
-  return hypot(x.real(), x.imag());
-}
 
 /**
  * Return elementwise absolute value of the specified real-valued
@@ -68,10 +63,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);
 }
@@ -85,7 +77,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..4fa93200d2b 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -18,6 +18,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto acos(const T x) {
+  return std::acos(x);
+}
+
+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 +38,6 @@ namespace math {
 struct acos_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::acos;
     return acos(x);
   }
 };
@@ -41,11 +50,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 +64,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..4f7c0da9968 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -23,7 +23,8 @@ namespace math {
  * @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 {
@@ -36,26 +37,12 @@ inline double acosh(double x) {
   }
 }
 
-/**
- * Integer version of acosh.
- *
- * @param[in] x 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);
 }
 
+
 /**
  * Structure to wrap acosh() so it can be vectorized.
  */
@@ -83,13 +70,18 @@ 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);
 }
 
+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..beb80855880 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -16,6 +16,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto asin(const T x) {
+  return std::asin(x);
+}
+
+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 +36,6 @@ namespace math {
 struct asin_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::asin;
     return asin(x);
   }
 };
@@ -39,11 +48,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 +62,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..5fb99da668e 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -19,6 +19,15 @@
 
 namespace stan {
 namespace math {
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto asinh(const T x) {
+  return std::asinh(x);
+}
+
+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 +39,6 @@ namespace math {
 struct asinh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::asinh;
     return asinh(x);
   }
 };
@@ -43,13 +51,18 @@ 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);
 }
 
+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..570e90ab8e6 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,17 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto atan(const T x) {
+  return std::atan(x);
+}
+
+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 +35,6 @@ namespace math {
 struct atan_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::atan;
     return atan(x);
   }
 };
@@ -37,11 +47,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 +61,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..5bf34ea22ea 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -24,7 +24,8 @@ namespace math {
  * @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 {
@@ -32,16 +33,8 @@ inline double atanh(double x) {
     return std::atanh(x);
   }
 }
-
-/**
- * Integer version of atanh.
- *
- * @param[in] x Argument.
- * @return Inverse hyperbolic tangent of the argument.
- * @throw std::domain_error If argument is less than 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 +65,18 @@ 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);
 }
 
+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/cos.hpp b/stan/math/prim/fun/cos.hpp
index 33046c6d180..ed342e706a8 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -13,6 +13,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto cos(const T x) {
+  return std::cos(x);
+}
+
+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 +33,6 @@ namespace math {
 struct cos_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::cos;
     return cos(x);
   }
 };
@@ -36,11 +45,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 +59,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..9d769122021 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -12,6 +12,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto cosh(const T x) {
+  return std::cosh(x);
+}
+
+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 +32,6 @@ namespace math {
 struct cosh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::cosh;
     return cosh(x);
   }
 };
@@ -35,11 +44,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 +58,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..e2401e73102 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -11,6 +11,17 @@
 
 namespace stan {
 namespace math {
+
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto exp(const T x) {
+  return std::exp(x);
+}
+
+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 +36,6 @@ struct exp_fun {
    */
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::exp;
     return exp(x);
   }
 };
@@ -39,11 +49,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 +63,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/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..529990bd974 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -45,8 +45,13 @@ 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));
+}
+
+template <typename T, require_complex_t<T>* = nullptr>
+inline auto inv_cloglog(const T& x) {
   return 1. - exp(-exp(x));
 }
 
@@ -71,11 +76,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 +90,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..1509d1abde9 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -16,6 +16,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto log(const T x) {
+  return std::log(x);
+}
+
+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 +39,6 @@ struct log_fun {
    */
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::log;
     return log(x);
   }
 };
@@ -44,10 +53,7 @@ struct log_fun {
  * @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>
+    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 +67,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..25fe5945c8a 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -12,6 +12,17 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto log10(const T x) {
+  return std::log10(x);
+}
+
+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 +33,6 @@ namespace math {
 struct log10_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::log10;
     return log10(x);
   }
 };
@@ -35,9 +45,7 @@ struct log10_fun {
  * @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>
+    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 +59,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..97c33baf91c 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,8 @@ 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.
@@ -84,10 +85,7 @@ struct logit_fun {
  * @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>
+    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 +102,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..a55e84ccbea 100644
--- a/stan/math/prim/fun/matrix_exp_2x2.hpp
+++ b/stan/math/prim/fun/matrix_exp_2x2.hpp
@@ -24,10 +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;
diff --git a/stan/math/prim/fun/polar.hpp b/stan/math/prim/fun/polar.hpp
index 9ba15ee3aae..70eaf3df390 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()};
   }
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index b4b92206da9..4e39699bbe7 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -13,6 +13,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto sin(const T x) {
+  return std::sin(x);
+}
+
+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 +33,6 @@ namespace math {
 struct sin_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::sin;
     return sin(x);
   }
 };
@@ -35,10 +44,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 +58,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 +74,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..06f5c1325b7 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -11,6 +11,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto sinh(const T x) {
+  return std::sinh(x);
+}
+
+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 +31,6 @@ namespace math {
 struct sinh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::sinh;
     return sinh(x);
   }
 };
@@ -33,11 +42,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 +56,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..2856f912260 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -11,6 +11,16 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto sqrt(const T x) {
+  return std::sqrt(x);
+}
+
+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 +31,6 @@ namespace math {
 struct sqrt_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::sqrt;
     return sqrt(x);
   }
 };
@@ -33,11 +42,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 +56,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..e273944cc40 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -23,7 +23,8 @@ 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.
@@ -47,10 +48,7 @@ struct square_fun {
  * @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>
+    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 +62,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..57742fdebf8 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -13,6 +13,17 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto tan(const T x) {
+  return std::tan(x);
+}
+
+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 +34,6 @@ namespace math {
 struct tan_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::tan;
     return tan(x);
   }
 };
@@ -35,11 +45,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 +59,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..0587d500d88 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -13,6 +13,17 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto tanh(const T x) {
+  return std::tanh(x);
+}
+
+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 +34,6 @@ namespace math {
 struct tanh_fun {
   template <typename T>
   static inline auto fun(const T& x) {
-    using std::tanh;
     return tanh(x);
   }
 };
@@ -35,11 +45,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 +59,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 +75,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..c6c65f3dd77 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -35,8 +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;
diff --git a/stan/math/prim/meta/is_complex.hpp b/stan/math/prim/meta/is_complex.hpp
index 2a7d77d39f1..f10e56756e0 100644
--- a/stan/math/prim/meta/is_complex.hpp
+++ b/stan/math/prim/meta/is_complex.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_PRIM_META_IS_COMPLEX_HPP
 
 #include <stan/math/prim/meta/conjunction.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>
@@ -121,10 +122,14 @@ template <typename T>
 using require_not_st_complex
     = require_not_t<is_complex<scalar_type_t<std::decay_t<T>>>>;
 
-/*! \brief Require `T` is complex and it's @ref base_type satisfies a given type trait */
-/*! @tparam T A type with a valid overload of @ref base_type available */
-template <template <class...> typename Check, typename T>
-using require_complex_bt = require_t<stan::math::conjunction<Check<base_type_t<std::decay_t<T>>>, is_complex<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..c22b6506aa2 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,16 @@ 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 */
@@ -82,6 +94,12 @@ using require_not_container_st
                                               TypeCheck, 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
 
 #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..d423606cec0 100644
--- a/stan/math/rev/fun/Phi_approx.hpp
+++ b/stan/math/rev/fun/Phi_approx.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>
 
 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..7b6e6f67b9b 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,8 @@
 #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/rev/fun/asin.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..61c8ea7163a 100644
--- a/stan/math/rev/fun/acosh.hpp
+++ b/stan/math/rev/fun/acosh.hpp
@@ -1,10 +1,6 @@
 #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>
@@ -15,6 +11,10 @@
 #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/isnan.hpp>
+#include <stan/math/prim/fun/acosh.hpp>
 #include <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/asin.hpp b/stan/math/rev/fun/asin.hpp
index fec7015e488..a87c5ec28d4 100644
--- a/stan/math/rev/fun/asin.hpp
+++ b/stan/math/rev/fun/asin.hpp
@@ -1,13 +1,13 @@
 #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/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..7013f457353 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,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/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 <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/atan.hpp b/stan/math/rev/fun/atan.hpp
index a00cb9a5604..703bad9ac20 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,9 @@
 #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/isinf.hpp>
+#include <stan/math/prim/fun/isnan.hpp>
+#include <stan/math/prim/fun/atan.hpp>
 #include <cmath>
 #include <complex>
 
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..a6a8c654b8d 100644
--- a/stan/math/rev/fun/binary_log_loss.hpp
+++ b/stan/math/rev/fun/binary_log_loss.hpp
@@ -3,7 +3,7 @@
 
 #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 <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/cholesky_decompose.hpp b/stan/math/rev/fun/cholesky_decompose.hpp
index c192dba731b..2fc57db47c3 100644
--- a/stan/math/rev/fun/cholesky_decompose.hpp
+++ b/stan/math/rev/fun/cholesky_decompose.hpp
@@ -1,13 +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/typedefs.hpp>
+#include <stan/math/prim/fun/cholesky_decompose.hpp>
 #include <stan/math/prim/fun/value_of_rec.hpp>
 #include <stan/math/prim/err/check_pos_definite.hpp>
 #include <stan/math/prim/err/check_square.hpp>
diff --git a/stan/math/rev/fun/columns_dot_product.hpp b/stan/math/rev/fun/columns_dot_product.hpp
index baa7ffe8e77..da16b2698ef 100644
--- a/stan/math/rev/fun/columns_dot_product.hpp
+++ b/stan/math/rev/fun/columns_dot_product.hpp
@@ -2,12 +2,12 @@
 #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/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 <stan/math/prim/fun/Eigen.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..465ffee2cfd 100644
--- a/stan/math/rev/fun/columns_dot_self.hpp
+++ b/stan/math/rev/fun/columns_dot_self.hpp
@@ -1,11 +1,11 @@
 #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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/cos.hpp b/stan/math/rev/fun/cos.hpp
index 4b48a5e5fe4..18ca87ba81f 100644
--- a/stan/math/rev/fun/cos.hpp
+++ b/stan/math/rev/fun/cos.hpp
@@ -1,15 +1,14 @@
 #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/isinf.hpp>
+#include <stan/math/prim/fun/isfinite.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..b5d089679d7 100644
--- a/stan/math/rev/fun/cov_exp_quad.hpp
+++ b/stan/math/rev/fun/cov_exp_quad.hpp
@@ -5,9 +5,9 @@
 #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/rev/fun/squared_distance.hpp>
+#include <stan/math/rev/fun/exp.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/squared_distance.hpp>
-#include <stan/math/prim/fun/exp.hpp>
 #include <type_traits>
 #include <vector>
 #include <cmath>
diff --git a/stan/math/rev/fun/diag_post_multiply.hpp b/stan/math/rev/fun/diag_post_multiply.hpp
index ff826eee68b..79679080bd9 100644
--- a/stan/math/rev/fun/diag_post_multiply.hpp
+++ b/stan/math/rev/fun/diag_post_multiply.hpp
@@ -2,8 +2,8 @@
 #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>
 
 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..e22acfff75a 100644
--- a/stan/math/rev/fun/diag_pre_multiply.hpp
+++ b/stan/math/rev/fun/diag_pre_multiply.hpp
@@ -2,8 +2,8 @@
 #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>
 
 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/dot_product.hpp b/stan/math/rev/fun/dot_product.hpp
index 02b87424968..4ff408d3064 100644
--- a/stan/math/rev/fun/dot_product.hpp
+++ b/stan/math/rev/fun/dot_product.hpp
@@ -3,17 +3,14 @@
 
 #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 <type_traits>
 #include <vector>
 
diff --git a/stan/math/rev/fun/dot_self.hpp b/stan/math/rev/fun/dot_self.hpp
index c318c99ee1d..c9eecd372e6 100644
--- a/stan/math/rev/fun/dot_self.hpp
+++ b/stan/math/rev/fun/dot_self.hpp
@@ -3,10 +3,9 @@
 
 #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 <vector>
 
 namespace stan {
diff --git a/stan/math/rev/fun/eigendecompose_sym.hpp b/stan/math/rev/fun/eigendecompose_sym.hpp
index 9c7c41cf014..b6c3a2dc9ff 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/rev/fun/value_of_rec.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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/eigenvalues_sym.hpp b/stan/math/rev/fun/eigenvalues_sym.hpp
index bfb5287deb5..8c318763fea 100644
--- a/stan/math/rev/fun/eigenvalues_sym.hpp
+++ b/stan/math/rev/fun/eigenvalues_sym.hpp
@@ -5,11 +5,11 @@
 #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/rev/fun/value_of_rec.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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/elt_multiply.hpp b/stan/math/rev/fun/elt_multiply.hpp
index 6e593c44524..4c227458d1e 100644
--- a/stan/math/rev/fun/elt_multiply.hpp
+++ b/stan/math/rev/fun/elt_multiply.hpp
@@ -2,11 +2,11 @@
 #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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/erf.hpp b/stan/math/rev/fun/erf.hpp
index 5fd831618b2..5826f1927b7 100644
--- a/stan/math/rev/fun/erf.hpp
+++ b/stan/math/rev/fun/erf.hpp
@@ -3,8 +3,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/erf.hpp>
+#include <stan/math/prim/fun/constants.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/exp.hpp b/stan/math/rev/fun/exp.hpp
index 5f04d8917d2..22b032c7b2b 100644
--- a/stan/math/rev/fun/exp.hpp
+++ b/stan/math/rev/fun/exp.hpp
@@ -3,14 +3,14 @@
 
 #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/isinf.hpp>
+#include <stan/math/prim/fun/isfinite.hpp>
+#include <stan/math/prim/fun/exp.hpp>
 #include <cmath>
 #include <complex>
 
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/fft.hpp b/stan/math/rev/fun/fft.hpp
index 797950b3056..072332eaeb1 100644
--- a/stan/math/rev/fun/fft.hpp
+++ b/stan/math/rev/fun/fft.hpp
@@ -6,7 +6,6 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/prim/fun/fft.hpp>
 #include <stan/math/prim/fun/to_complex.hpp>
-#include <Eigen/Dense>
 #include <complex>
 #include <type_traits>
 #include <vector>
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..b3d5a15711c 100644
--- a/stan/math/rev/fun/generalized_inverse.hpp
+++ b/stan/math/rev/fun/generalized_inverse.hpp
@@ -1,11 +1,11 @@
 #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/rev/fun/inverse.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/rev/fun/inverse.hpp>
+#include <stan/math/prim/fun/add_diag.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..e5770be9bc1 100644
--- a/stan/math/rev/fun/gp_exp_quad_cov.hpp
+++ b/stan/math/rev/fun/gp_exp_quad_cov.hpp
@@ -4,11 +4,11 @@
 #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 <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..c6ab4cac4e4 100644
--- a/stan/math/rev/fun/gp_periodic_cov.hpp
+++ b/stan/math/rev/fun/gp_periodic_cov.hpp
@@ -1,15 +1,17 @@
 #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 <cmath>
 #include <type_traits>
 #include <vector>
@@ -41,8 +43,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..228e1e42429 100644
--- a/stan/math/rev/fun/grad_inc_beta.hpp
+++ b/stan/math/rev/fun/grad_inc_beta.hpp
@@ -7,15 +7,15 @@
 #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/value_of.hpp>
+#include <stan/math/rev/fun/value_of_rec.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/prim/fun/grad_2F1.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
-#include <stan/math/rev/fun/hypergeometric_2F1.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..6b1843698f8 100644
--- a/stan/math/rev/fun/hypergeometric_2F1.hpp
+++ b/stan/math/rev/fun/hypergeometric_2F1.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/hypergeometric_2F1.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..5d3b14496d1 100644
--- a/stan/math/rev/fun/hypergeometric_pFq.hpp
+++ b/stan/math/rev/fun/hypergeometric_pFq.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/hypergeometric_pFq.hpp>
+#include <stan/math/rev/fun/hypergeometric_pFq.hpp>
 #include <stan/math/prim/fun/grad_pFq.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/inc_beta.hpp b/stan/math/rev/fun/inc_beta.hpp
index 57d91ef06fc..dde94ee1e71 100644
--- a/stan/math/rev/fun/inc_beta.hpp
+++ b/stan/math/rev/fun/inc_beta.hpp
@@ -3,9 +3,9 @@
 
 #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 <cmath>
 
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/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..daa1ec4a7c1 100644
--- a/stan/math/rev/fun/log1m_inv_logit.hpp
+++ b/stan/math/rev/fun/log1m_inv_logit.hpp
@@ -2,8 +2,8 @@
 #define STAN_MATH_REV_FUN_LOG1M_INV_LOGIT_HPP
 
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log1m_inv_logit.hpp>
-#include <stan/math/prim/fun/inv_logit.hpp>
 #include <stan/math/rev/core.hpp>
 
 namespace stan {
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_spd.hpp b/stan/math/rev/fun/log_determinant_spd.hpp
index b87d06fce7a..32a3b1c2c41 100644
--- a/stan/math/rev/fun/log_determinant_spd.hpp
+++ b/stan/math/rev/fun/log_determinant_spd.hpp
@@ -4,10 +4,10 @@
 #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>
 
 namespace stan {
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..273adc97b2e 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/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/rev/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..deefd2a249c 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/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/rev/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/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/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/quad_form.hpp b/stan/math/rev/fun/quad_form.hpp
index 431e30b3f79..8eac63206dc 100644
--- a/stan/math/rev/fun/quad_form.hpp
+++ b/stan/math/rev/fun/quad_form.hpp
@@ -6,9 +6,9 @@
 #include <stan/math/rev/fun/to_var_value.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/read_corr_matrix.hpp b/stan/math/rev/fun/read_corr_matrix.hpp
index a5d8281740d..01064313c40 100644
--- a/stan/math/rev/fun/read_corr_matrix.hpp
+++ b/stan/math/rev/fun/read_corr_matrix.hpp
@@ -3,8 +3,8 @@
 
 #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/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..5c7905aaead 100644
--- a/stan/math/rev/fun/read_cov_L.hpp
+++ b/stan/math/rev/fun/read_cov_L.hpp
@@ -4,10 +4,10 @@
 #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/read_corr_L.hpp>
 #include <stan/math/prim/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/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..e8739d92559 100644
--- a/stan/math/rev/fun/rows_dot_self.hpp
+++ b/stan/math/rev/fun/rows_dot_self.hpp
@@ -1,11 +1,11 @@
 #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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/sd.hpp b/stan/math/rev/fun/sd.hpp
index 76494763766..068d30b6fd6 100644
--- a/stan/math/rev/fun/sd.hpp
+++ b/stan/math/rev/fun/sd.hpp
@@ -6,7 +6,8 @@
 #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/rev/fun/inv_sqrt.hpp>
+#include <stan/math/rev/fun/sqrt.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/softmax.hpp b/stan/math/rev/fun/softmax.hpp
index 4d8b98a1170..c1d8ca20ec2 100644
--- a/stan/math/rev/fun/softmax.hpp
+++ b/stan/math/rev/fun/softmax.hpp
@@ -1,15 +1,15 @@
 #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..109266dd0e4 100644
--- a/stan/math/rev/fun/squared_distance.hpp
+++ b/stan/math/rev/fun/squared_distance.hpp
@@ -6,10 +6,10 @@
 #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/svd.hpp b/stan/math/rev/fun/svd.hpp
index 33ef934cbc9..a5ffbc96d3c 100644
--- a/stan/math/rev/fun/svd.hpp
+++ b/stan/math/rev/fun/svd.hpp
@@ -2,11 +2,11 @@
 #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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/svd_U.hpp b/stan/math/rev/fun/svd_U.hpp
index 6a208e3c6e3..ebc218d571c 100644
--- a/stan/math/rev/fun/svd_U.hpp
+++ b/stan/math/rev/fun/svd_U.hpp
@@ -2,11 +2,11 @@
 #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>
 
 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/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..71d97f69fed 100644
--- a/stan/math/rev/fun/trace.hpp
+++ b/stan/math/rev/fun/trace.hpp
@@ -2,9 +2,9 @@
 #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>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/trace_gen_quad_form.hpp b/stan/math/rev/fun/trace_gen_quad_form.hpp
index 13d74683ba2..f36af382d63 100644
--- a/stan/math/rev/fun/trace_gen_quad_form.hpp
+++ b/stan/math/rev/fun/trace_gen_quad_form.hpp
@@ -8,7 +8,6 @@
 #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_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 {

From 68c36811242caf6e1dfe21c97d5f7a3ba3d58c14 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Thu, 7 Nov 2024 15:26:48 -0500
Subject: [PATCH 03/19] add docs for all new functions

---
 stan/math/prim/fun/acos.hpp          | 14 +++++
 stan/math/prim/fun/acosh.hpp         | 10 +++-
 stan/math/prim/fun/asin.hpp          | 14 +++++
 stan/math/prim/fun/asinh.hpp         | 14 +++++
 stan/math/prim/fun/atan.hpp          | 14 +++++
 stan/math/prim/fun/atanh.hpp         | 13 ++++-
 stan/math/prim/fun/conj.hpp          | 78 ++++++++++++++++++++++------
 stan/math/prim/fun/cos.hpp           | 14 +++++
 stan/math/prim/fun/cosh.hpp          | 14 +++++
 stan/math/prim/fun/exp.hpp           | 18 +++++++
 stan/math/prim/fun/log.hpp           | 14 +++++
 stan/math/prim/fun/log10.hpp         | 14 +++++
 stan/math/prim/fun/norm.hpp          |  2 +-
 stan/math/prim/fun/polar.hpp         | 15 ++----
 stan/math/prim/fun/pow.hpp           | 56 +++++++++++++++-----
 stan/math/prim/fun/proj.hpp          |  2 +-
 stan/math/prim/fun/sin.hpp           | 14 +++++
 stan/math/prim/fun/sinh.hpp          | 14 +++++
 stan/math/prim/fun/sqrt.hpp          | 14 +++++
 stan/math/prim/fun/tan.hpp           | 14 +++++
 stan/math/prim/fun/tanh.hpp          | 14 +++++
 stan/math/prim/meta/is_complex.hpp   | 45 +++++++++++++++-
 test/unit/math/mix/fun/conj_test.cpp |  1 -
 23 files changed, 374 insertions(+), 48 deletions(-)

diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 4fa93200d2b..1efa76b5174 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -18,11 +18,25 @@
 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);
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 4f7c0da9968..9a87841b060 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -19,7 +19,7 @@ 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.
  */
@@ -37,6 +37,14 @@ inline double acosh(const T x) {
   }
 }
 
+/**
+ * Return the inverse hyperbolic cosine of the specified value.
+ * Returns nan for nan argument.
+ *
+ * @param[in] x `complex<Arithmetic>` Argument.
+ * @return Inverse hyperbolic cosine of the argument.
+ * @throw std::domain_error If argument is less than 1.
+ */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
 inline auto acosh(const T x) {
   return std::acosh(x);
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index beb80855880..3a9fb5d84a2 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -16,11 +16,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the arc sine of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 5fb99da668e..4e1c15e2e8e 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -19,11 +19,25 @@
 
 namespace stan {
 namespace math {
+/**
+ * Return the hyperbolic arc sine of the arithmetic argument.
+ *
+ * @tparam V An arithmetic type
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 570e90ab8e6..7201a15e7bf 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -14,11 +14,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the arc tangent of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index 5bf34ea22ea..e53d03a6cef 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -20,7 +20,7 @@ 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].
  */
@@ -33,6 +33,17 @@ inline double atanh(const T x) {
     return std::atanh(x);
   }
 }
+
+/**
+ * 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 `complex<Arithmetic>` Argument.
+ * @return Inverse hyperbolic tangent of the argument.
+ * @throw std::domain_error If argument is not in [-1, 1].
+ */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
 inline auto atanh(const T x) {
   return std::atanh(x);
diff --git a/stan/math/prim/fun/conj.hpp b/stan/math/prim/fun/conj.hpp
index 49a569e757c..2c63ba49fc6 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,7 +14,7 @@ namespace math {
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
-template <typename V>
+template <typename V, require_arithmetic_t<V>* = nullptr>
 inline std::complex<V> conj(const std::complex<V>& z) {
   return std::conj(z);
 }
@@ -22,13 +22,51 @@ inline std::complex<V> conj(const std::complex<V>& z) {
 /**
  * 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 arithmetic 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();
+template <typename Eig, require_eigen_vt<is_complex_arithmetic, Eig>* = nullptr>
+inline auto conj(Eig&& z) {
+  return make_holder([](auto&& z_inner) {
+    return z_inner.unaryExpr([](auto&& z_i) {
+      return stan::math::conj(z_i);
+    });
+  }, std::forward<Eig>(z));
+}
+
+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
+
+/**
+ * Return the complex conjugate the Eigen object.
+ *
+ * @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_ad, Eig>* = nullptr>
+inline auto conj(Eig&& z) {
+  return make_holder([](auto&& z_inner) {
+    return z_inner.unaryExpr([](auto&& z_i) {
+      /*
+       * clang 19.1 libstdc++ has a non restricted template for conj
+       * which causes an ambiguous lookup compiler error.
+       */
+      return internal::complex_conj(z_i);
+    });
+  }, std::forward<Eig>(z));
 }
 
 /**
@@ -38,27 +76,33 @@ inline auto conj(const Eig& z) {
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
-template <typename StdVec, require_std_vector_st<is_complex, StdVec>* = nullptr>
+template <typename StdVec, require_std_vector_st<is_complex_arithmetic, 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] = stan::math::conj(z[i]);
+  }
   return result;
 }
 
-namespace internal {
 /**
- * Return the complex conjugate the complex argument.
+ * Return the complex conjugate the vector with complex scalar components.
  *
- * @tparam V value type of argument
+ * @tparam StdVec A `std::vector` type with complex scalar type
  * @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()};
+template <typename StdVec, require_std_vector_st<is_complex_ad, StdVec>* = nullptr>
+inline auto conj(const StdVec& z) {
+  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] = internal::complex_conj(z[i]);
+  }
+  return result;
 }
-}  // namespace internal
+
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index ed342e706a8..ded04c8c258 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -13,11 +13,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the cosine of the arithmetic argument.
+ *
+ * @tparam T An arithmetic argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index 9d769122021..d06742294bc 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -12,11 +12,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the hyperbolic cosine of the arithmetic argument.
+ *
+ * @tparam V An arithmetic type
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index e2401e73102..b0d569f9edf 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -12,11 +12,29 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the natural (base e) exponentiation of the specified
+ * complex argument.
+ *
+ * @tparam V `Arithmetic` type
+ * @param z 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 z 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);
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 1509d1abde9..e111f09040d 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -16,11 +16,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the natural logarithm of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 25fe5945c8a..4072ef0efb0 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -12,11 +12,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the base 10 logarithm of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
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 70eaf3df390..f8fe035f007 100644
--- a/stan/math/prim/fun/polar.hpp
+++ b/stan/math/prim/fun/polar.hpp
@@ -35,18 +35,9 @@ 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) {
-  return internal::complex_polar(static_cast<double>(r),
-                                 static_cast<double>(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));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
index 95809bd8830..34f95299b98 100644
--- a/stan/math/prim/fun/pow.hpp
+++ b/stan/math/prim/fun/pow.hpp
@@ -33,42 +33,71 @@ 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 +108,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 4e39699bbe7..ca7e6e90878 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -13,11 +13,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the sine of the complex argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index 06f5c1325b7..eb026e77666 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -11,11 +11,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the hyperbolic sine of the arithmetic argument.
+ *
+ * @tparam V An arithmetic argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index 2856f912260..9d5d7ed748d 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -11,11 +11,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the square root of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index 57742fdebf8..9314a1e4ea0 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -13,11 +13,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the tangent of the arithmetic argument.
+ *
+ * @tparam V value type of argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index 0587d500d88..a7fd785c2b7 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -13,11 +13,25 @@
 namespace stan {
 namespace math {
 
+/**
+ * Return the hyperbolic tangent of the arithmetic argument.
+ *
+ * @tparam V `Arithmetic` argument
+ * @param[in] z 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] z 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);
diff --git a/stan/math/prim/meta/is_complex.hpp b/stan/math/prim/meta/is_complex.hpp
index f10e56756e0..01eb71e8ed9 100644
--- a/stan/math/prim/meta/is_complex.hpp
+++ b/stan/math/prim/meta/is_complex.hpp
@@ -2,6 +2,7 @@
 #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>
@@ -29,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`.
@@ -45,6 +46,7 @@ struct is_complex<
     T, std::enable_if_t<internal::is_complex_impl<std::decay_t<T>>::value>>
     : std::true_type {};
 
+
 /** \ingroup type_trait
  *
  * Template metaprogram defining the scalar type for values
@@ -69,6 +71,46 @@ 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 */
@@ -130,6 +172,7 @@ using require_not_st_complex
 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/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>

From 58fdd146d364878154d520438df6fe30d71ad62f Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Thu, 7 Nov 2024 16:35:23 -0500
Subject: [PATCH 04/19] fix conj

---
 stan/math/fwd/fun/conj.hpp  | 18 ----------------
 stan/math/prim/fun/conj.hpp | 42 ++++++++++++++++---------------------
 stan/math/rev/fun/conj.hpp  | 16 --------------
 3 files changed, 18 insertions(+), 58 deletions(-)

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/prim/fun/conj.hpp b/stan/math/prim/fun/conj.hpp
index 2c63ba49fc6..8c47f62ce42 100644
--- a/stan/math/prim/fun/conj.hpp
+++ b/stan/math/prim/fun/conj.hpp
@@ -14,11 +14,23 @@ namespace math {
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
-template <typename V, require_arithmetic_t<V>* = nullptr>
-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.
  *
@@ -30,25 +42,11 @@ template <typename Eig, require_eigen_vt<is_complex_arithmetic, Eig>* = nullptr>
 inline auto conj(Eig&& z) {
   return make_holder([](auto&& z_inner) {
     return z_inner.unaryExpr([](auto&& z_i) {
-      return stan::math::conj(z_i);
+      return conj(z_i);
     });
   }, std::forward<Eig>(z));
 }
 
-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
-
 /**
  * Return the complex conjugate the Eigen object.
  *
@@ -60,11 +58,7 @@ template <typename Eig, require_eigen_vt<is_complex_ad, Eig>* = nullptr>
 inline auto conj(Eig&& z) {
   return make_holder([](auto&& z_inner) {
     return z_inner.unaryExpr([](auto&& z_i) {
-      /*
-       * clang 19.1 libstdc++ has a non restricted template for conj
-       * which causes an ambiguous lookup compiler error.
-       */
-      return internal::complex_conj(z_i);
+      return conj(z_i);
     });
   }, std::forward<Eig>(z));
 }
@@ -81,7 +75,7 @@ inline auto conj(const StdVec& z) {
   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] = stan::math::conj(z[i]);
+    result[i] = conj(z[i]);
   }
   return result;
 }
@@ -98,7 +92,7 @@ inline auto conj(const StdVec& z) {
   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] = internal::complex_conj(z[i]);
+    result[i] = conj(z[i]);
   }
   return result;
 }
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

From 19689947af80693fe6845382c24e7b29f1fa2c8d Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Thu, 7 Nov 2024 18:25:22 -0500
Subject: [PATCH 05/19] fix complex conj

---
 stan/math/prim/fun/conj.hpp | 35 ++---------------------------------
 1 file changed, 2 insertions(+), 33 deletions(-)

diff --git a/stan/math/prim/fun/conj.hpp b/stan/math/prim/fun/conj.hpp
index 8c47f62ce42..6017a41632e 100644
--- a/stan/math/prim/fun/conj.hpp
+++ b/stan/math/prim/fun/conj.hpp
@@ -31,21 +31,6 @@ 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` with an inner complex arithmetic type.
- * @param[in] z argument
- * @return complex conjugate of the argument
- */
-template <typename Eig, require_eigen_vt<is_complex_arithmetic, Eig>* = nullptr>
-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));
-}
 
 /**
  * Return the complex conjugate the Eigen object.
@@ -54,7 +39,7 @@ inline auto conj(Eig&& z) {
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
-template <typename Eig, require_eigen_vt<is_complex_ad, Eig>* = nullptr>
+template <typename Eig, require_eigen_vt<is_complex, Eig>* = nullptr>
 inline auto conj(Eig&& z) {
   return make_holder([](auto&& z_inner) {
     return z_inner.unaryExpr([](auto&& z_i) {
@@ -70,7 +55,7 @@ inline auto conj(Eig&& z) {
  * @param[in] z argument
  * @return complex conjugate of the argument
  */
-template <typename StdVec, require_std_vector_st<is_complex_arithmetic, StdVec>* = nullptr>
+template <typename StdVec, require_std_vector_st<is_complex, StdVec>* = nullptr>
 inline auto conj(const StdVec& z) {
   const auto z_size = z.size();
   promote_scalar_t<scalar_type_t<StdVec>, StdVec> result(z_size);
@@ -80,22 +65,6 @@ inline auto conj(const StdVec& z) {
   return result;
 }
 
-/**
- * Return the complex conjugate the vector with complex scalar components.
- *
- * @tparam StdVec A `std::vector` type with complex scalar type
- * @param[in] z argument
- * @return complex conjugate of the argument
- */
-template <typename StdVec, require_std_vector_st<is_complex_ad, StdVec>* = nullptr>
-inline auto conj(const StdVec& z) {
-  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 math
 }  // namespace stan

From d0b650c2c8085b9fe1dd2986d1fdece44628c2cd Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 8 Nov 2024 10:59:26 -0500
Subject: [PATCH 06/19] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/mix/meta.hpp                |  1 -
 stan/math/prim/fun/abs.hpp            |  1 -
 stan/math/prim/fun/acosh.hpp          |  2 --
 stan/math/prim/fun/asinh.hpp          |  1 -
 stan/math/prim/fun/atan.hpp           |  1 -
 stan/math/prim/fun/atanh.hpp          |  1 -
 stan/math/prim/fun/conj.hpp           | 15 ++++++-------
 stan/math/prim/fun/log.hpp            |  3 +--
 stan/math/prim/fun/log10.hpp          |  4 +---
 stan/math/prim/fun/logit.hpp          |  7 +++---
 stan/math/prim/fun/matrix_exp_2x2.hpp |  1 -
 stan/math/prim/fun/polar.hpp          |  3 ++-
 stan/math/prim/fun/pow.hpp            |  8 ++++---
 stan/math/prim/fun/sin.hpp            |  2 +-
 stan/math/prim/fun/square.hpp         |  7 +++---
 stan/math/prim/fun/tan.hpp            |  1 -
 stan/math/prim/fun/tanh.hpp           |  1 -
 stan/math/prim/fun/trigamma.hpp       |  1 -
 stan/math/prim/meta/base_type.hpp     |  2 --
 stan/math/prim/meta/is_complex.hpp    | 32 ++++++++++++---------------
 stan/math/prim/meta/is_container.hpp  | 12 +++++-----
 stan/math/prim/meta/is_real.hpp       | 23 ++++++++-----------
 22 files changed, 53 insertions(+), 76 deletions(-)

diff --git a/stan/math/mix/meta.hpp b/stan/math/mix/meta.hpp
index a0fd3787a86..f0622433c71 100644
--- a/stan/math/mix/meta.hpp
+++ b/stan/math/mix/meta.hpp
@@ -12,7 +12,6 @@
 #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/prim/meta.hpp>
 
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 88d66271088..fca073133ec 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -39,7 +39,6 @@ inline auto abs(T x) {
   return std::hypot(x.real(), x.imag());
 }
 
-
 /**
  * Return elementwise absolute value of the specified real-valued
  * container.
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 9a87841b060..4cdc2930571 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -50,7 +50,6 @@ inline auto acosh(const T x) {
   return std::acosh(x);
 }
 
-
 /**
  * Structure to wrap acosh() so it can be vectorized.
  */
@@ -89,7 +88,6 @@ inline auto acosh(const Container& x) {
   return apply_scalar_unary<acosh_fun, Container>::apply(x);
 }
 
-
 namespace internal {
 
 /**
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 4e1c15e2e8e..77d044ff729 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -76,7 +76,6 @@ 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 7201a15e7bf..0b65df28a59 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -38,7 +38,6 @@ inline auto atan(const T x) {
   return std::atan(x);
 }
 
-
 /**
  * Structure to wrap \c atan() so it can be vectorized.
  *
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index e53d03a6cef..aeb88d2203a 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -87,7 +87,6 @@ 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 6017a41632e..ebb9ac28222 100644
--- a/stan/math/prim/fun/conj.hpp
+++ b/stan/math/prim/fun/conj.hpp
@@ -31,21 +31,21 @@ 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` with an inner complex autodiff type.
+ * @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(Eig&& z) {
-  return make_holder([](auto&& z_inner) {
-    return z_inner.unaryExpr([](auto&& z_i) {
-      return conj(z_i);
-    });
-  }, std::forward<Eig>(z));
+  return make_holder(
+      [](auto&& z_inner) {
+        return z_inner.unaryExpr([](auto&& z_i) { return conj(z_i); });
+      },
+      std::forward<Eig>(z));
 }
 
 /**
@@ -65,7 +65,6 @@ inline auto conj(const StdVec& z) {
   return result;
 }
 
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index e111f09040d..69ca62d1794 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -66,8 +66,7 @@ struct log_fun {
  * @param[in] x container
  * @return Elementwise application of natural log to the argument.
  */
-template <
-    typename Container, require_ad_container_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);
 }
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 4072ef0efb0..afda3e6fd32 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -36,7 +36,6 @@ inline auto log10(const T x) {
   return std::log10(x);
 }
 
-
 /**
  * Structure to wrap log10() so it can be vectorized.
  *
@@ -58,8 +57,7 @@ struct log10_fun {
  * @param x container
  * @return Log base-10 applied to each value in x.
  */
-template <
-    typename Container, require_ad_container_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);
 }
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index 97c33baf91c..3f6f7ce7a8c 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -55,7 +55,9 @@ inline double logit(const T u) {
  * @return log odds of argument
  */
 template <typename T, require_integral_t<T>* = nullptr>
-inline double logit(const T u) { return logit(static_cast<double>(u)); }
+inline double logit(const T u) {
+  return logit(static_cast<double>(u));
+}
 
 /**
  * Structure to wrap logit() so it can be vectorized.
@@ -84,8 +86,7 @@ struct logit_fun {
  * @param x container
  * @return elementwise logit of container elements
  */
-template <
-    typename Container, require_ad_container_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);
 }
diff --git a/stan/math/prim/fun/matrix_exp_2x2.hpp b/stan/math/prim/fun/matrix_exp_2x2.hpp
index a55e84ccbea..8f020bf71c3 100644
--- a/stan/math/prim/fun/matrix_exp_2x2.hpp
+++ b/stan/math/prim/fun/matrix_exp_2x2.hpp
@@ -24,7 +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 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/polar.hpp b/stan/math/prim/fun/polar.hpp
index f8fe035f007..e894cc9d203 100644
--- a/stan/math/prim/fun/polar.hpp
+++ b/stan/math/prim/fun/polar.hpp
@@ -37,7 +37,8 @@ inline complex_return_t<U, V> complex_polar(const U& r, const V& 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));
+  return internal::complex_polar(static_cast<double>(r),
+                                 static_cast<double>(theta));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
index 34f95299b98..2cb708c7f5c 100644
--- a/stan/math/prim/fun/pow.hpp
+++ b/stan/math/prim/fun/pow.hpp
@@ -96,8 +96,10 @@ inline auto pow(const T1& a, const T2& b) {
  * Returns the elementwise raising of the first argument to the power of the
  * second argument. One type must be a `Container` type.
  *
- * @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`
+ * @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
@@ -108,7 +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
+      // 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/sin.hpp b/stan/math/prim/fun/sin.hpp
index ca7e6e90878..889e05e4c59 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -88,7 +88,7 @@ namespace internal {
  */
 template <typename V>
 inline std::complex<V> complex_sin(const std::complex<V>& z) {
-    using namespace stan::math;
+  using namespace stan::math;
   return neg_i_times(sinh(i_times(z)));
 }
 }  // namespace internal
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index e273944cc40..cb14bd77c8b 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -24,7 +24,9 @@ namespace math {
  * @return Square of input.
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
-inline double square(const T x) { return std::pow(x, 2); }
+inline double square(const T x) {
+  return std::pow(x, 2);
+}
 
 /**
  * Structure to wrap square() so that it can be vectorized.
@@ -47,8 +49,7 @@ struct square_fun {
  * @param x container
  * @return Each value in x squared.
  */
-template <
-    typename Container, require_ad_container_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);
 }
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index 9314a1e4ea0..f81e1f9295b 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -37,7 +37,6 @@ inline auto tan(const T x) {
   return std::tan(x);
 }
 
-
 /**
  * Structure to wrap `tan()` so that it can be vectorized.
  *
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index a7fd785c2b7..aba1f2062cc 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -37,7 +37,6 @@ inline auto tanh(const T x) {
   return std::tanh(x);
 }
 
-
 /**
  * Structure to wrap `tanh()` so that it can be vectorized.
  *
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index c6c65f3dd77..9a30daab99b 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -35,7 +35,6 @@ namespace math {
  */
 template <typename T>
 inline T trigamma_impl(const T& x) {
-
   double small = 0.0001;
   double large = 5.0;
   T value;
diff --git a/stan/math/prim/meta/base_type.hpp b/stan/math/prim/meta/base_type.hpp
index eb70e7592b0..26f52e875f5 100644
--- a/stan/math/prim/meta/base_type.hpp
+++ b/stan/math/prim/meta/base_type.hpp
@@ -52,7 +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>;
 };
 
-
-
 }  // namespace stan
 #endif
diff --git a/stan/math/prim/meta/is_complex.hpp b/stan/math/prim/meta/is_complex.hpp
index 01eb71e8ed9..2ccbbc97d8d 100644
--- a/stan/math/prim/meta/is_complex.hpp
+++ b/stan/math/prim/meta/is_complex.hpp
@@ -46,7 +46,6 @@ struct is_complex<
     T, std::enable_if_t<internal::is_complex_impl<std::decay_t<T>>::value>>
     : std::true_type {};
 
-
 /** \ingroup type_trait
  *
  * Template metaprogram defining the scalar type for values
@@ -72,9 +71,9 @@ struct base_type<T, std::enable_if_t<is_complex<T>::value>> {
 };
 
 /**
- * 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
+ * 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
@@ -85,17 +84,16 @@ 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 >>
+    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`.
+ * `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
@@ -104,11 +102,9 @@ 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 >>
+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 */
@@ -170,8 +166,8 @@ using require_not_st_complex
 /*! @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>>>;
+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 c22b6506aa2..899ca961b83 100644
--- a/stan/math/prim/meta/is_container.hpp
+++ b/stan/math/prim/meta/is_container.hpp
@@ -79,9 +79,8 @@ using require_container_st
 /*! @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...>>;
+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` */
@@ -95,10 +94,9 @@ using require_not_container_st
 /*! @} */
 
 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>>>;
+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
index 61747066944..81694d44cea 100644
--- a/stan/math/prim/meta/is_real.hpp
+++ b/stan/math/prim/meta/is_real.hpp
@@ -21,16 +21,15 @@ namespace stan {
  * @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> {};
+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 */
@@ -44,20 +43,17 @@ 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>>>;
+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>>...>;
+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>>...>;
+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 */
@@ -73,7 +69,6 @@ using require_any_not_real_t
     = require_any_not_t<is_real<std::decay_t<Types>>...>;
 /*! @} */
 
-
-}
+}  // namespace stan
 
 #endif

From c7892d62ab7fbcc951df08caaf2ba1de06dd54fa Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Fri, 8 Nov 2024 15:29:24 -0500
Subject: [PATCH 07/19] fix double header includes

---
 stan/math/rev/fun/acos.hpp               | 1 -
 stan/math/rev/fun/acosh.hpp              | 2 +-
 stan/math/rev/fun/asin.hpp               | 1 -
 stan/math/rev/fun/eigendecompose_sym.hpp | 1 -
 stan/math/rev/fun/eigenvalues_sym.hpp    | 1 -
 stan/math/rev/fun/exp.hpp                | 1 -
 stan/math/rev/fun/grad_inc_beta.hpp      | 3 +--
 7 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/stan/math/rev/fun/acos.hpp b/stan/math/rev/fun/acos.hpp
index 7b6e6f67b9b..33d54df935a 100644
--- a/stan/math/rev/fun/acos.hpp
+++ b/stan/math/rev/fun/acos.hpp
@@ -9,7 +9,6 @@
 #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/rev/fun/asin.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 61c8ea7163a..51a5c924693 100644
--- a/stan/math/rev/fun/acosh.hpp
+++ b/stan/math/rev/fun/acosh.hpp
@@ -3,7 +3,6 @@
 
 #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>
@@ -11,6 +10,7 @@
 #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>
diff --git a/stan/math/rev/fun/asin.hpp b/stan/math/rev/fun/asin.hpp
index a87c5ec28d4..d306d9679b1 100644
--- a/stan/math/rev/fun/asin.hpp
+++ b/stan/math/rev/fun/asin.hpp
@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_REV_FUN_ASIN_HPP
 #define STAN_MATH_REV_FUN_ASIN_HPP
 
-#include <stan/math/rev/fun/abs.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/abs.hpp>
diff --git a/stan/math/rev/fun/eigendecompose_sym.hpp b/stan/math/rev/fun/eigendecompose_sym.hpp
index b6c3a2dc9ff..933c5c79843 100644
--- a/stan/math/rev/fun/eigendecompose_sym.hpp
+++ b/stan/math/rev/fun/eigendecompose_sym.hpp
@@ -5,7 +5,6 @@
 #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_rec.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>
diff --git a/stan/math/rev/fun/eigenvalues_sym.hpp b/stan/math/rev/fun/eigenvalues_sym.hpp
index 8c318763fea..c15e403eab7 100644
--- a/stan/math/rev/fun/eigenvalues_sym.hpp
+++ b/stan/math/rev/fun/eigenvalues_sym.hpp
@@ -5,7 +5,6 @@
 #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/rev/fun/value_of_rec.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>
diff --git a/stan/math/rev/fun/exp.hpp b/stan/math/rev/fun/exp.hpp
index 22b032c7b2b..0f370bea105 100644
--- a/stan/math/rev/fun/exp.hpp
+++ b/stan/math/rev/fun/exp.hpp
@@ -6,7 +6,6 @@
 #include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/is_inf.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/isinf.hpp>
 #include <stan/math/prim/fun/isfinite.hpp>
diff --git a/stan/math/rev/fun/grad_inc_beta.hpp b/stan/math/rev/fun/grad_inc_beta.hpp
index 228e1e42429..14b81dbfa21 100644
--- a/stan/math/rev/fun/grad_inc_beta.hpp
+++ b/stan/math/rev/fun/grad_inc_beta.hpp
@@ -9,12 +9,11 @@
 #include <stan/math/rev/fun/floor.hpp>
 #include <stan/math/rev/fun/hypergeometric_2F1.hpp>
 #include <stan/math/rev/fun/inc_beta.hpp>
-#include <stan/math/rev/fun/value_of.hpp>
-#include <stan/math/rev/fun/value_of_rec.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 <cmath>
 

From cd5441100630f59cd89207b157435534f47f4279 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Fri, 8 Nov 2024 16:18:48 -0500
Subject: [PATCH 08/19] fix docs

---
 stan/math/prim/fun/asin.hpp  | 4 ++--
 stan/math/prim/fun/asinh.hpp | 4 ++--
 stan/math/prim/fun/atan.hpp  | 4 ++--
 stan/math/prim/fun/cos.hpp   | 4 ++--
 stan/math/prim/fun/cosh.hpp  | 4 ++--
 stan/math/prim/fun/exp.hpp   | 4 ++--
 stan/math/prim/fun/log.hpp   | 4 ++--
 stan/math/prim/fun/log10.hpp | 4 ++--
 stan/math/prim/fun/sin.hpp   | 4 ++--
 stan/math/prim/fun/sinh.hpp  | 4 ++--
 stan/math/prim/fun/sqrt.hpp  | 4 ++--
 stan/math/prim/fun/tan.hpp   | 4 ++--
 stan/math/prim/fun/tanh.hpp  | 4 ++--
 13 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index 3a9fb5d84a2..f620a24d2af 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -20,7 +20,7 @@ namespace math {
  * Return the arc sine of the arithmetic argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return arc sine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -32,7 +32,7 @@ inline auto asin(const T x) {
  * Return the arc sine of the complex argument.
  *
  * @tparam V `complex<Arithmetic> argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return arc sine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 77d044ff729..ebb5bff9282 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -23,7 +23,7 @@ namespace math {
  * Return the hyperbolic arc sine of the arithmetic argument.
  *
  * @tparam V An arithmetic type
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic arc sine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -35,7 +35,7 @@ inline auto asinh(const T x) {
  * Return the hyperbolic arc sine of the complex argument.
  *
  * @tparam V a complex type with inner arithmetic type.
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic arc sine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 0b65df28a59..9e7099b7d43 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -18,7 +18,7 @@ namespace math {
  * Return the arc tangent of the arithmetic argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return arc tangent of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -30,7 +30,7 @@ inline auto atan(const T x) {
  * Return the arc tangent of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return arc tangent of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index ded04c8c258..0a3b044ccdc 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -17,7 +17,7 @@ namespace math {
  * Return the cosine of the arithmetic argument.
  *
  * @tparam T An arithmetic argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return cosine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -29,7 +29,7 @@ inline auto cos(const T x) {
  * Return the cosine of the complex argument.
  *
  * @tparam T `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return cosine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index d06742294bc..ae60c233a68 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -16,7 +16,7 @@ namespace math {
  * Return the hyperbolic cosine of the arithmetic argument.
  *
  * @tparam V An arithmetic type
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic cosine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -28,7 +28,7 @@ inline auto cosh(const T x) {
  * Return the hyperbolic cosine of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` type of argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic cosine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index b0d569f9edf..d12d82cb556 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -17,7 +17,7 @@ namespace math {
  * complex argument.
  *
  * @tparam V `Arithmetic` type
- * @param z input
+ * @param x input
  * @return natural exponentiation of specified number
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -30,7 +30,7 @@ inline auto exp(const T x) {
  * complex argument.
  *
  * @tparam V `complex<Arithmetic>` type
- * @param z complex number
+ * @param x complex number
  * @return natural exponentiation of specified complex number
  * @see documentation for `std::complex` for boundary condition and
  * branch cut details
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 69ca62d1794..8216cee2aa6 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -20,7 +20,7 @@ namespace math {
  * Return the natural logarithm of the arithmetic argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return natural logarithm of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -32,7 +32,7 @@ inline auto log(const T x) {
  * Return the natural logarithm of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return natural logarithm of the argument
  */
 template <typename T, require_complex_t<T>* = nullptr>
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index afda3e6fd32..f7d81343ea5 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -16,7 +16,7 @@ namespace math {
  * Return the base 10 logarithm of the arithmetic argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return base 10 logarithm of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -28,7 +28,7 @@ inline auto log10(const T x) {
  * Return the base 10 logarithm of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return base 10 logarithm of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index 889e05e4c59..a0145dd4c6b 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -17,7 +17,7 @@ namespace math {
  * Return the sine of the complex argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return sine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -29,7 +29,7 @@ inline auto sin(const T x) {
  * Return the sine of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return sine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index eb026e77666..e3e55fa7477 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -15,7 +15,7 @@ namespace math {
  * Return the hyperbolic sine of the arithmetic argument.
  *
  * @tparam V An arithmetic argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic sine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -27,7 +27,7 @@ inline auto sinh(const T x) {
  * Return the hyperbolic sine of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic sine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index 9d5d7ed748d..3e1620d2a61 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -15,7 +15,7 @@ namespace math {
  * Return the square root of the arithmetic argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return square root of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -27,7 +27,7 @@ inline auto sqrt(const T x) {
  * Return the square root of the complex argument.
  *
  * @tparam V `complex<Aritmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return square root of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index f81e1f9295b..373672eb0c8 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -17,7 +17,7 @@ namespace math {
  * Return the tangent of the arithmetic argument.
  *
  * @tparam V value type of argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return tangent of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -29,7 +29,7 @@ inline auto tan(const T x) {
  * Return the tangent of the complex argument.
  *
  * @tparam V `complex<Arithmetic> argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return tangent of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index aba1f2062cc..1ae3faff087 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -17,7 +17,7 @@ namespace math {
  * Return the hyperbolic tangent of the arithmetic argument.
  *
  * @tparam V `Arithmetic` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic tangent of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
@@ -29,7 +29,7 @@ inline auto tanh(const T x) {
  * Return the hyperbolic tangent of the complex argument.
  *
  * @tparam V `complex<Arithmetic>` argument
- * @param[in] z argument
+ * @param[in] x argument
  * @return hyperbolic tangent of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>

From 37a5e7172fc8838684bbf59d5b426aceb1fe554b Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 11 Nov 2024 11:27:22 -0500
Subject: [PATCH 09/19] update fwd includes

---
 stan/math/fwd/fun/inv_sqrt.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stan/math/fwd/fun/inv_sqrt.hpp b/stan/math/fwd/fun/inv_sqrt.hpp
index 40625094d37..3cca38d538f 100644
--- a/stan/math/fwd/fun/inv_sqrt.hpp
+++ b/stan/math/fwd/fun/inv_sqrt.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/prim/fun/inv_sqrt.hpp>
 #include <cmath>
 
 namespace stan {

From 83cf7d74cde7eaaf2fceff05a2496b6dae7a30ac Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 11 Nov 2024 17:05:36 -0500
Subject: [PATCH 10/19] update includes for fwd to always prefer fwd version
 before prim version.

---
 stan/math/fwd/fun/Phi.hpp                     |  4 +--
 stan/math/fwd/fun/Phi_approx.hpp              |  5 ++--
 stan/math/fwd/fun/abs.hpp                     |  4 +--
 stan/math/fwd/fun/acos.hpp                    |  1 +
 stan/math/fwd/fun/acosh.hpp                   |  2 +-
 stan/math/fwd/fun/asin.hpp                    |  2 +-
 stan/math/fwd/fun/asinh.hpp                   |  1 +
 stan/math/fwd/fun/atan.hpp                    |  1 +
 stan/math/fwd/fun/atan2.hpp                   |  1 +
 stan/math/fwd/fun/atanh.hpp                   |  2 ++
 stan/math/fwd/fun/ceil.hpp                    |  1 +
 stan/math/fwd/fun/cos.hpp                     |  1 +
 stan/math/fwd/fun/determinant.hpp             |  4 +--
 stan/math/fwd/fun/digamma.hpp                 |  2 +-
 stan/math/fwd/fun/erf.hpp                     |  2 +-
 stan/math/fwd/fun/erfc.hpp                    |  4 +--
 stan/math/fwd/fun/exp.hpp                     |  3 ++-
 stan/math/fwd/fun/exp2.hpp                    |  2 +-
 stan/math/fwd/fun/expm1.hpp                   |  3 ++-
 stan/math/fwd/fun/fabs.hpp                    |  7 +++--
 stan/math/fwd/fun/falling_factorial.hpp       |  3 +--
 stan/math/fwd/fun/floor.hpp                   |  2 +-
 stan/math/fwd/fun/fmax.hpp                    |  2 +-
 stan/math/fwd/fun/fmin.hpp                    |  2 +-
 stan/math/fwd/fun/fmod.hpp                    |  9 +++----
 stan/math/fwd/fun/gamma_p.hpp                 | 12 +++------
 stan/math/fwd/fun/gamma_q.hpp                 | 26 +++++--------------
 stan/math/fwd/fun/grad_inc_beta.hpp           |  4 +--
 stan/math/fwd/fun/hypergeometric_1F0.hpp      |  7 +++--
 stan/math/fwd/fun/hypergeometric_2F1.hpp      |  3 ++-
 stan/math/fwd/fun/hypergeometric_pFq.hpp      |  4 ++-
 stan/math/fwd/fun/hypot.hpp                   |  3 ---
 stan/math/fwd/fun/inc_beta.hpp                |  7 +++--
 stan/math/fwd/fun/inv.hpp                     |  1 +
 stan/math/fwd/fun/inv_Phi.hpp                 |  4 +--
 stan/math/fwd/fun/inv_cloglog.hpp             |  2 +-
 stan/math/fwd/fun/inv_erfc.hpp                |  4 +--
 stan/math/fwd/fun/inv_inc_beta.hpp            | 19 ++++++++------
 stan/math/fwd/fun/inv_logit.hpp               |  2 --
 stan/math/fwd/fun/inv_sqrt.hpp                |  1 -
 stan/math/fwd/fun/inv_square.hpp              |  3 ++-
 stan/math/fwd/fun/inverse.hpp                 |  7 +++--
 stan/math/fwd/fun/lambert_w.hpp               |  1 +
 stan/math/fwd/fun/lbeta.hpp                   |  2 +-
 stan/math/fwd/fun/lgamma.hpp                  |  2 +-
 stan/math/fwd/fun/lmgamma.hpp                 |  3 +--
 stan/math/fwd/fun/lmultiply.hpp               |  4 +--
 stan/math/fwd/fun/log.hpp                     |  4 ++-
 stan/math/fwd/fun/log10.hpp                   |  3 +--
 stan/math/fwd/fun/log1m_exp.hpp               |  1 -
 stan/math/fwd/fun/log1m_inv_logit.hpp         |  2 +-
 stan/math/fwd/fun/log1p_exp.hpp               |  2 +-
 stan/math/fwd/fun/log_determinant.hpp         |  4 +--
 stan/math/fwd/fun/log_diff_exp.hpp            |  2 +-
 stan/math/fwd/fun/log_falling_factorial.hpp   |  1 -
 stan/math/fwd/fun/log_inv_logit.hpp           |  3 +--
 stan/math/fwd/fun/log_inv_logit_diff.hpp      |  6 ++---
 stan/math/fwd/fun/log_mix.hpp                 |  3 +--
 stan/math/fwd/fun/log_rising_factorial.hpp    |  2 +-
 stan/math/fwd/fun/log_softmax.hpp             |  5 ++--
 stan/math/fwd/fun/log_sum_exp.hpp             |  8 +++---
 stan/math/fwd/fun/logit.hpp                   |  4 +--
 stan/math/fwd/fun/mdivide_left.hpp            |  5 ++--
 stan/math/fwd/fun/mdivide_left_ldlt.hpp       |  4 +--
 stan/math/fwd/fun/mdivide_left_tri_low.hpp    |  9 ++++---
 stan/math/fwd/fun/mdivide_right.hpp           |  5 ++--
 stan/math/fwd/fun/mdivide_right_tri_low.hpp   |  9 ++++---
 stan/math/fwd/fun/multiply.hpp                |  6 ++---
 stan/math/fwd/fun/multiply_log.hpp            |  4 +--
 .../fun/multiply_lower_tri_self_transpose.hpp |  3 ++-
 stan/math/fwd/fun/norm.hpp                    |  1 +
 stan/math/fwd/fun/norm1.hpp                   |  5 ++--
 stan/math/fwd/fun/norm2.hpp                   |  4 +--
 stan/math/fwd/fun/owens_t.hpp                 | 11 +++-----
 stan/math/fwd/fun/polar.hpp                   |  3 +++
 stan/math/fwd/fun/pow.hpp                     | 18 ++++---------
 stan/math/fwd/fun/proj.hpp                    |  1 +
 stan/math/fwd/fun/rising_factorial.hpp        |  2 +-
 stan/math/fwd/fun/round.hpp                   |  2 +-
 stan/math/fwd/fun/sin.hpp                     |  1 +
 stan/math/fwd/fun/sinh.hpp                    |  1 +
 stan/math/fwd/fun/softmax.hpp                 |  3 +--
 stan/math/fwd/fun/sqrt.hpp                    |  3 +++
 stan/math/fwd/fun/sum.hpp                     |  2 +-
 stan/math/fwd/fun/tan.hpp                     |  3 ++-
 stan/math/fwd/fun/tcrossprod.hpp              |  5 ++--
 stan/math/fwd/fun/tgamma.hpp                  |  2 +-
 stan/math/fwd/fun/to_fvar.hpp                 |  2 +-
 stan/math/fwd/fun/trace_quad_form.hpp         |  8 +++---
 stan/math/fwd/fun/trigamma.hpp                |  4 +++
 stan/math/fwd/fun/value_of.hpp                |  2 +-
 stan/math/fwd/fun/value_of_rec.hpp            |  2 +-
 92 files changed, 177 insertions(+), 194 deletions(-)

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 a173dfac287..e92b5525b79 100644
--- a/stan/math/fwd/fun/acos.hpp
+++ b/stan/math/fwd/fun/acos.hpp
@@ -3,6 +3,7 @@
 
 #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/acos.hpp>
 #include <cmath>
diff --git a/stan/math/fwd/fun/acosh.hpp b/stan/math/fwd/fun/acosh.hpp
index 5e871990275..fccf9a0b51f 100644
--- a/stan/math/fwd/fun/acosh.hpp
+++ b/stan/math/fwd/fun/acosh.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/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/acosh.hpp>
 #include <cmath>
 #include <complex>
diff --git a/stan/math/fwd/fun/asin.hpp b/stan/math/fwd/fun/asin.hpp
index 0e3f2c93cbf..ecf7fa26918 100644
--- a/stan/math/fwd/fun/asin.hpp
+++ b/stan/math/fwd/fun/asin.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/fwd/fun/sqrt.hpp>
+#include <stan/math/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/asin.hpp>
 #include <cmath>
 #include <complex>
diff --git a/stan/math/fwd/fun/asinh.hpp b/stan/math/fwd/fun/asinh.hpp
index 348294c6f52..bdd74be74d3 100644
--- a/stan/math/fwd/fun/asinh.hpp
+++ b/stan/math/fwd/fun/asinh.hpp
@@ -3,6 +3,7 @@
 
 #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 <cmath>
diff --git a/stan/math/fwd/fun/atan.hpp b/stan/math/fwd/fun/atan.hpp
index d60acc18a71..2e42c89dfb8 100644
--- a/stan/math/fwd/fun/atan.hpp
+++ b/stan/math/fwd/fun/atan.hpp
@@ -3,6 +3,7 @@
 
 #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 <cmath>
diff --git a/stan/math/fwd/fun/atan2.hpp b/stan/math/fwd/fun/atan2.hpp
index 40f9ec2a8ee..94bee5b263a 100644
--- a/stan/math/fwd/fun/atan2.hpp
+++ b/stan/math/fwd/fun/atan2.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/square.hpp>
+#include <stan/math/prim/fun/atan2.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/fwd/fun/atanh.hpp b/stan/math/fwd/fun/atanh.hpp
index 2294aca4836..04b95144eac 100644
--- a/stan/math/fwd/fun/atanh.hpp
+++ b/stan/math/fwd/fun/atanh.hpp
@@ -3,7 +3,9 @@
 
 #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 <cmath>
 #include <complex>
diff --git a/stan/math/fwd/fun/ceil.hpp b/stan/math/fwd/fun/ceil.hpp
index 94cfd35d257..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 {
diff --git a/stan/math/fwd/fun/cos.hpp b/stan/math/fwd/fun/cos.hpp
index 32a9c43ff6d..19be59e91de 100644
--- a/stan/math/fwd/fun/cos.hpp
+++ b/stan/math/fwd/fun/cos.hpp
@@ -4,6 +4,7 @@
 #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>
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 6ab0b8982a0..2ed906da5f8 100644
--- a/stan/math/fwd/fun/erf.hpp
+++ b/stan/math/fwd/fun/erf.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/fwd/fun/square.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/erf.hpp>
@@ -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..25a6f0d541e 100644
--- a/stan/math/fwd/fun/expm1.hpp
+++ b/stan/math/fwd/fun/expm1.hpp
@@ -4,6 +4,8 @@
 #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 +13,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..d48f0526c05 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/rev/fun/log1m.hpp>
+#include <stan/math/rev/fun/inv.hpp>
+#include <stan/math/rev/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 26154d5a1aa..3d0cd3108a5 100644
--- a/stan/math/fwd/fun/inv.hpp
+++ b/stan/math/fwd/fun/inv.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.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 3cca38d538f..f66fcb5156f 100644
--- a/stan/math/fwd/fun/inv_sqrt.hpp
+++ b/stan/math/fwd/fun/inv_sqrt.hpp
@@ -11,7 +11,6 @@ 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));
 }
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..13a132f8ff1 100644
--- a/stan/math/fwd/fun/log_mix.hpp
+++ b/stan/math/fwd/fun/log_mix.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>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/log_mix.hpp>
 #include <cmath>
 #include <type_traits>
@@ -28,7 +28,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..ecd9c727d57 100644
--- a/stan/math/fwd/fun/multiply.hpp
+++ b/stan/math/fwd/fun/multiply.hpp
@@ -1,12 +1,12 @@
 #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>
 
 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 bdeb1f1872e..a208ff190be 100644
--- a/stan/math/fwd/fun/sin.hpp
+++ b/stan/math/fwd/fun/sin.hpp
@@ -3,6 +3,7 @@
 
 #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>
diff --git a/stan/math/fwd/fun/sinh.hpp b/stan/math/fwd/fun/sinh.hpp
index 4c9a558b094..15c114ec7ab 100644
--- a/stan/math/fwd/fun/sinh.hpp
+++ b/stan/math/fwd/fun/sinh.hpp
@@ -4,6 +4,7 @@
 #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>
 
diff --git a/stan/math/fwd/fun/softmax.hpp b/stan/math/fwd/fun/softmax.hpp
index fa03499112b..3625332ddf2 100644
--- a/stan/math/fwd/fun/softmax.hpp
+++ b/stan/math/fwd/fun/softmax.hpp
@@ -4,9 +4,8 @@
 #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/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 b7723e0b8de..81d0f187423 100644
--- a/stan/math/fwd/fun/sqrt.hpp
+++ b/stan/math/fwd/fun/sqrt.hpp
@@ -3,7 +3,10 @@
 
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/cos.hpp>
 #include <stan/math/fwd/fun/inv_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>
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 358546208b1..b19cd576969 100644
--- a/stan/math/fwd/fun/tan.hpp
+++ b/stan/math/fwd/fun/tan.hpp
@@ -3,7 +3,8 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
-#include <stan/math/fwd/fun/tan.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>
diff --git a/stan/math/fwd/fun/tcrossprod.hpp b/stan/math/fwd/fun/tcrossprod.hpp
index f25b4036576..464ca1df1c1 100644
--- a/stan/math/fwd/fun/tcrossprod.hpp
+++ b/stan/math/fwd/fun/tcrossprod.hpp
@@ -1,11 +1,12 @@
 #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>
+#include <stan/math/prim/fun/multiply.hpp>
 
 namespace stan {
 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 {

From c15aeaee7d75d0ba2086d50ca951d73ecb055435 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 11 Nov 2024 17:12:39 -0500
Subject: [PATCH 11/19] update includes for fwd to always prefer fwd version
 before prim version.

---
 stan/math/fwd/fun/expm1.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stan/math/fwd/fun/expm1.hpp b/stan/math/fwd/fun/expm1.hpp
index 25a6f0d541e..86a0b146f1d 100644
--- a/stan/math/fwd/fun/expm1.hpp
+++ b/stan/math/fwd/fun/expm1.hpp
@@ -1,7 +1,6 @@
 #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>

From 9a6a4ec58a9795ea69b3bfac433b2ee7969a7797 Mon Sep 17 00:00:00 2001
From: Brian Ward <bward@flatironinstitute.org>
Date: Thu, 14 Nov 2024 12:30:09 -0500
Subject: [PATCH 12/19] Docstring duplication and edits

---
 stan/math/prim/fun/acosh.hpp         | 10 ++++++++++
 stan/math/prim/fun/asinh.hpp         |  8 ++++++++
 stan/math/prim/fun/atanh.hpp         | 10 ++++++++++
 stan/math/prim/fun/inv_cloglog.hpp   | 13 +++++++++++++
 stan/math/prim/meta/is_container.hpp |  5 ++++-
 stan/math/prim/meta/is_real.hpp      |  3 ++-
 6 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 4cdc2930571..5580e9e1e73 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -82,6 +82,16 @@ 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) {
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index ebb5bff9282..ab72065efae 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -70,6 +70,14 @@ 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) {
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index aeb88d2203a..fdf6c4df9b5 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -81,6 +81,16 @@ 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) {
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 529990bd974..f197d49c24e 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -50,6 +50,19 @@ 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));
diff --git a/stan/math/prim/meta/is_container.hpp b/stan/math/prim/meta/is_container.hpp
index 899ca961b83..25479694f6b 100644
--- a/stan/math/prim/meta/is_container.hpp
+++ b/stan/math/prim/meta/is_container.hpp
@@ -91,12 +91,15 @@ 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
index 81694d44cea..1f7aaccab41 100644
--- a/stan/math/prim/meta/is_real.hpp
+++ b/stan/math/prim/meta/is_real.hpp
@@ -16,7 +16,8 @@
 namespace stan {
 
 /**
- * Checks if decayed type is a var, fvar, or arithmetic
+ * 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
  */

From 2bc815cf3cdd93f0bf60cf2de0f40f9868549efb Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Thu, 14 Nov 2024 17:10:01 -0500
Subject: [PATCH 13/19] update header includes

---
 stan/math/fwd/fun/hypergeometric_1F0.hpp  | 6 +++---
 stan/math/fwd/fun/inv_sqrt.hpp            | 3 ++-
 stan/math/fwd/fun/log_mix.hpp             | 1 +
 stan/math/fwd/fun/tcrossprod.hpp          | 9 +++++++--
 stan/math/rev/fun/asinh.hpp               | 2 --
 stan/math/rev/fun/atan.hpp                | 2 --
 stan/math/rev/fun/columns_dot_product.hpp | 2 +-
 stan/math/rev/fun/cos.hpp                 | 2 --
 stan/math/rev/fun/exp.hpp                 | 2 --
 stan/math/rev/fun/hypergeometric_pFq.hpp  | 2 +-
 10 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/stan/math/fwd/fun/hypergeometric_1F0.hpp b/stan/math/fwd/fun/hypergeometric_1F0.hpp
index d48f0526c05..b304d5c8381 100644
--- a/stan/math/fwd/fun/hypergeometric_1F0.hpp
+++ b/stan/math/fwd/fun/hypergeometric_1F0.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.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/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 {
diff --git a/stan/math/fwd/fun/inv_sqrt.hpp b/stan/math/fwd/fun/inv_sqrt.hpp
index f66fcb5156f..eefe580c075 100644
--- a/stan/math/fwd/fun/inv_sqrt.hpp
+++ b/stan/math/fwd/fun/inv_sqrt.hpp
@@ -3,6 +3,7 @@
 
 #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>
 
@@ -12,7 +13,7 @@ namespace math {
 template <typename T>
 inline fvar<T> inv_sqrt(const fvar<T>& x) {
   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/log_mix.hpp b/stan/math/fwd/fun/log_mix.hpp
index 13a132f8ff1..3da901d67d6 100644
--- a/stan/math/fwd/fun/log_mix.hpp
+++ b/stan/math/fwd/fun/log_mix.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/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/log_mix.hpp>
 #include <cmath>
diff --git a/stan/math/fwd/fun/tcrossprod.hpp b/stan/math/fwd/fun/tcrossprod.hpp
index 464ca1df1c1..5e2a116c239 100644
--- a/stan/math/fwd/fun/tcrossprod.hpp
+++ b/stan/math/fwd/fun/tcrossprod.hpp
@@ -6,7 +6,6 @@
 #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/prim/fun/multiply.hpp>
 
 namespace stan {
 namespace math {
@@ -19,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/rev/fun/asinh.hpp b/stan/math/rev/fun/asinh.hpp
index 7013f457353..eab4debaa3c 100644
--- a/stan/math/rev/fun/asinh.hpp
+++ b/stan/math/rev/fun/asinh.hpp
@@ -15,8 +15,6 @@
 #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 <cmath>
 #include <complex>
 
diff --git a/stan/math/rev/fun/atan.hpp b/stan/math/rev/fun/atan.hpp
index 703bad9ac20..b1f1a88a722 100644
--- a/stan/math/rev/fun/atan.hpp
+++ b/stan/math/rev/fun/atan.hpp
@@ -11,8 +11,6 @@
 #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/isinf.hpp>
-#include <stan/math/prim/fun/isnan.hpp>
 #include <stan/math/prim/fun/atan.hpp>
 #include <cmath>
 #include <complex>
diff --git a/stan/math/rev/fun/columns_dot_product.hpp b/stan/math/rev/fun/columns_dot_product.hpp
index da16b2698ef..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/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 <stan/math/prim/fun/Eigen.hpp>
 
 #include <type_traits>
 
diff --git a/stan/math/rev/fun/cos.hpp b/stan/math/rev/fun/cos.hpp
index 18ca87ba81f..4e5b7d7b39d 100644
--- a/stan/math/rev/fun/cos.hpp
+++ b/stan/math/rev/fun/cos.hpp
@@ -6,8 +6,6 @@
 #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/isinf.hpp>
-#include <stan/math/prim/fun/isfinite.hpp>
 #include <stan/math/prim/fun/cos.hpp>
 #include <cmath>
 #include <complex>
diff --git a/stan/math/rev/fun/exp.hpp b/stan/math/rev/fun/exp.hpp
index 0f370bea105..88a9a22a179 100644
--- a/stan/math/rev/fun/exp.hpp
+++ b/stan/math/rev/fun/exp.hpp
@@ -7,8 +7,6 @@
 #include <stan/math/rev/fun/is_inf.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
 #include <stan/math/rev/fun/sin.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/isfinite.hpp>
 #include <stan/math/prim/fun/exp.hpp>
 #include <cmath>
 #include <complex>
diff --git a/stan/math/rev/fun/hypergeometric_pFq.hpp b/stan/math/rev/fun/hypergeometric_pFq.hpp
index 5d3b14496d1..3d5e54238c2 100644
--- a/stan/math/rev/fun/hypergeometric_pFq.hpp
+++ b/stan/math/rev/fun/hypergeometric_pFq.hpp
@@ -1,8 +1,8 @@
 #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/rev/meta.hpp>
 #include <stan/math/rev/fun/hypergeometric_pFq.hpp>
 #include <stan/math/prim/fun/grad_pFq.hpp>
 

From 754547cd0eebb7ba83b73d0ffb4985aa476e82af Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 14 Nov 2024 17:12:14 -0500
Subject: [PATCH 14/19] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/fwd/fun/tcrossprod.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stan/math/fwd/fun/tcrossprod.hpp b/stan/math/fwd/fun/tcrossprod.hpp
index 5e2a116c239..c5fdb3e66b0 100644
--- a/stan/math/fwd/fun/tcrossprod.hpp
+++ b/stan/math/fwd/fun/tcrossprod.hpp
@@ -21,7 +21,7 @@ tcrossprod(const EigMat& m) {
   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}};
+                         EigMat::RowsAtCompileTime>{{ret}};
   } else {
     return ret;
   }

From d6ff92d76ddaefc96bf279db509e77a4994a621b Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Thu, 14 Nov 2024 17:55:25 -0500
Subject: [PATCH 15/19] update header includes

---
 stan/math/fwd/fun/multiply.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stan/math/fwd/fun/multiply.hpp b/stan/math/fwd/fun/multiply.hpp
index ecd9c727d57..cbe365b2860 100644
--- a/stan/math/fwd/fun/multiply.hpp
+++ b/stan/math/fwd/fun/multiply.hpp
@@ -7,6 +7,7 @@
 #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 {

From a2898866eda600ba7188b6c721eeb72325fcc884 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Fri, 15 Nov 2024 14:07:33 -0500
Subject: [PATCH 16/19] fix headers

---
 stan/math/prim/fun/generalized_inverse.hpp              | 1 +
 stan/math/rev/fun/Phi_approx.hpp                        | 1 +
 stan/math/rev/fun/append_col.hpp                        | 2 +-
 stan/math/rev/fun/append_row.hpp                        | 2 +-
 stan/math/rev/fun/asinh.hpp                             | 2 +-
 stan/math/rev/fun/atan2.hpp                             | 1 +
 stan/math/rev/fun/binary_log_loss.hpp                   | 1 +
 stan/math/rev/fun/ceil.hpp                              | 1 +
 stan/math/rev/fun/cholesky_decompose.hpp                | 1 -
 stan/math/rev/fun/columns_dot_product.hpp               | 2 +-
 stan/math/rev/fun/columns_dot_self.hpp                  | 1 +
 stan/math/rev/fun/cov_exp_quad.hpp                      | 3 ++-
 stan/math/rev/fun/csr_matrix_times_vector.hpp           | 3 ++-
 stan/math/rev/fun/determinant.hpp                       | 1 +
 stan/math/rev/fun/diag_post_multiply.hpp                | 1 +
 stan/math/rev/fun/diag_pre_multiply.hpp                 | 1 +
 stan/math/rev/fun/dims.hpp                              | 1 +
 stan/math/rev/fun/dot_product.hpp                       | 3 ++-
 stan/math/rev/fun/dot_self.hpp                          | 3 ++-
 stan/math/rev/fun/eigendecompose_sym.hpp                | 1 +
 stan/math/rev/fun/eigenvalues_sym.hpp                   | 4 +++-
 stan/math/rev/fun/eigenvectors_sym.hpp                  | 3 ++-
 stan/math/rev/fun/elt_divide.hpp                        | 5 +++--
 stan/math/rev/fun/elt_multiply.hpp                      | 1 +
 stan/math/rev/fun/erf.hpp                               | 2 +-
 stan/math/rev/fun/exp.hpp                               | 2 --
 stan/math/rev/fun/exp2.hpp                              | 2 +-
 stan/math/rev/fun/fabs.hpp                              | 1 +
 stan/math/rev/fun/fdim.hpp                              | 1 +
 stan/math/rev/fun/fft.hpp                               | 4 ++--
 stan/math/rev/fun/fill.hpp                              | 1 +
 stan/math/rev/fun/floor.hpp                             | 1 +
 stan/math/rev/fun/fma.hpp                               | 2 +-
 stan/math/rev/fun/fmax.hpp                              | 2 +-
 stan/math/rev/fun/fmin.hpp                              | 2 +-
 stan/math/rev/fun/fmod.hpp                              | 1 +
 stan/math/rev/fun/generalized_inverse.hpp               | 4 +++-
 stan/math/rev/fun/gp_exp_quad_cov.hpp                   | 3 ++-
 stan/math/rev/fun/gp_periodic_cov.hpp                   | 1 +
 stan/math/rev/fun/grad_inc_beta.hpp                     | 2 ++
 stan/math/rev/fun/hypergeometric_2F1.hpp                | 2 +-
 stan/math/rev/fun/hypergeometric_pFq.hpp                | 4 ++--
 stan/math/rev/fun/inc_beta.hpp                          | 1 +
 stan/math/rev/fun/initialize_fill.hpp                   | 1 +
 stan/math/rev/fun/inverse.hpp                           | 1 +
 stan/math/rev/fun/log1m_inv_logit.hpp                   | 2 +-
 stan/math/rev/fun/log_determinant.hpp                   | 3 ++-
 stan/math/rev/fun/log_determinant_ldlt.hpp              | 3 ++-
 stan/math/rev/fun/log_determinant_spd.hpp               | 3 ++-
 stan/math/rev/fun/log_softmax.hpp                       | 2 +-
 stan/math/rev/fun/log_sum_exp.hpp                       | 2 +-
 stan/math/rev/fun/matrix_power.hpp                      | 3 ++-
 stan/math/rev/fun/mdivide_left.hpp                      | 3 ++-
 stan/math/rev/fun/mdivide_left_ldlt.hpp                 | 3 ++-
 stan/math/rev/fun/mdivide_left_spd.hpp                  | 3 ++-
 stan/math/rev/fun/mdivide_left_tri.hpp                  | 1 +
 stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp | 2 +-
 stan/math/rev/fun/norm.hpp                              | 2 +-
 stan/math/rev/fun/norm1.hpp                             | 1 +
 stan/math/rev/fun/norm2.hpp                             | 3 ++-
 stan/math/rev/fun/proj.hpp                              | 4 ++--
 stan/math/rev/fun/quad_form.hpp                         | 2 +-
 stan/math/rev/fun/quad_form_sym.hpp                     | 5 +++--
 stan/math/rev/fun/read_corr_L.hpp                       | 2 +-
 stan/math/rev/fun/read_corr_matrix.hpp                  | 2 +-
 stan/math/rev/fun/read_cov_L.hpp                        | 4 ++--
 stan/math/rev/fun/read_cov_matrix.hpp                   | 3 ++-
 stan/math/rev/fun/rows_dot_self.hpp                     | 1 +
 stan/math/rev/fun/sd.hpp                                | 7 ++++---
 stan/math/rev/fun/singular_values.hpp                   | 2 +-
 stan/math/rev/fun/sinh.hpp                              | 6 +++---
 stan/math/rev/fun/softmax.hpp                           | 2 +-
 stan/math/rev/fun/squared_distance.hpp                  | 2 +-
 stan/math/rev/fun/step.hpp                              | 1 +
 stan/math/rev/fun/sum.hpp                               | 1 +
 stan/math/rev/fun/svd.hpp                               | 1 +
 stan/math/rev/fun/svd_U.hpp                             | 1 +
 stan/math/rev/fun/svd_V.hpp                             | 5 +++--
 stan/math/rev/fun/tcrossprod.hpp                        | 3 ++-
 stan/math/rev/fun/trace.hpp                             | 1 +
 stan/math/rev/fun/trace_gen_inv_quad_form_ldlt.hpp      | 3 ++-
 stan/math/rev/fun/trace_gen_quad_form.hpp               | 2 +-
 stan/math/rev/fun/trace_inv_quad_form_ldlt.hpp          | 3 ++-
 stan/math/rev/fun/variance.hpp                          | 1 +
 84 files changed, 120 insertions(+), 65 deletions(-)

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/rev/fun/Phi_approx.hpp b/stan/math/rev/fun/Phi_approx.hpp
index d423606cec0..0219c92853d 100644
--- a/stan/math/rev/fun/Phi_approx.hpp
+++ b/stan/math/rev/fun/Phi_approx.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.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/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/asinh.hpp b/stan/math/rev/fun/asinh.hpp
index 7013f457353..70abf7566f7 100644
--- a/stan/math/rev/fun/asinh.hpp
+++ b/stan/math/rev/fun/asinh.hpp
@@ -14,9 +14,9 @@
 #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 <stan/math/prim/fun/isinf.hpp>
 #include <stan/math/prim/fun/is_inf.hpp>
+#include <stan/math/prim/fun/asinh.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/binary_log_loss.hpp b/stan/math/rev/fun/binary_log_loss.hpp
index a6a8c654b8d..c521f613d53 100644
--- a/stan/math/rev/fun/binary_log_loss.hpp
+++ b/stan/math/rev/fun/binary_log_loss.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.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 2fc57db47c3..ac0f22e7d03 100644
--- a/stan/math/rev/fun/cholesky_decompose.hpp
+++ b/stan/math/rev/fun/cholesky_decompose.hpp
@@ -8,7 +8,6 @@
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/prim/fun/cholesky_decompose.hpp>
-#include <stan/math/prim/fun/value_of_rec.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 da16b2698ef..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/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 <stan/math/prim/fun/Eigen.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 465ffee2cfd..e21b8a2e313 100644
--- a/stan/math/rev/fun/columns_dot_self.hpp
+++ b/stan/math/rev/fun/columns_dot_self.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/dot_self.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/cov_exp_quad.hpp b/stan/math/rev/fun/cov_exp_quad.hpp
index b5d089679d7..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/rev/fun/squared_distance.hpp>
 #include <stan/math/rev/fun/exp.hpp>
-#include <stan/math/prim/fun/Eigen.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 79679080bd9..f16cb178d05 100644
--- a/stan/math/rev/fun/diag_post_multiply.hpp
+++ b/stan/math/rev/fun/diag_post_multiply.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/fun/Eigen.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 e22acfff75a..9538659f44f 100644
--- a/stan/math/rev/fun/diag_pre_multiply.hpp
+++ b/stan/math/rev/fun/diag_pre_multiply.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/fun/Eigen.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/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 4ff408d3064..76cbc28d793 100644
--- a/stan/math/rev/fun/dot_product.hpp
+++ b/stan/math/rev/fun/dot_product.hpp
@@ -1,6 +1,7 @@
 #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/dot_product.hpp>
@@ -8,9 +9,9 @@
 #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/typedefs.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 c9eecd372e6..47b889fd6df 100644
--- a/stan/math/rev/fun/dot_self.hpp
+++ b/stan/math/rev/fun/dot_self.hpp
@@ -1,11 +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/fun/square.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.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 933c5c79843..17663bd7ce5 100644
--- a/stan/math/rev/fun/eigendecompose_sym.hpp
+++ b/stan/math/rev/fun/eigendecompose_sym.hpp
@@ -8,6 +8,7 @@
 #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/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 c15e403eab7..2d2b6b63056 100644
--- a/stan/math/rev/fun/eigenvalues_sym.hpp
+++ b/stan/math/rev/fun/eigenvalues_sym.hpp
@@ -1,14 +1,16 @@
 #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/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 4c227458d1e..581037f90cb 100644
--- a/stan/math/rev/fun/elt_multiply.hpp
+++ b/stan/math/rev/fun/elt_multiply.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/eval.hpp>
+#include <stan/math/prim/fun/elt_multiply.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/erf.hpp b/stan/math/rev/fun/erf.hpp
index 5826f1927b7..5fd831618b2 100644
--- a/stan/math/rev/fun/erf.hpp
+++ b/stan/math/rev/fun/erf.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/erf.hpp>
 #include <stan/math/prim/fun/constants.hpp>
+#include <stan/math/prim/fun/erf.hpp>
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/exp.hpp b/stan/math/rev/fun/exp.hpp
index 0f370bea105..88a9a22a179 100644
--- a/stan/math/rev/fun/exp.hpp
+++ b/stan/math/rev/fun/exp.hpp
@@ -7,8 +7,6 @@
 #include <stan/math/rev/fun/is_inf.hpp>
 #include <stan/math/rev/fun/is_nan.hpp>
 #include <stan/math/rev/fun/sin.hpp>
-#include <stan/math/prim/fun/isinf.hpp>
-#include <stan/math/prim/fun/isfinite.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/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 072332eaeb1..5250705ef49 100644
--- a/stan/math/rev/fun/fft.hpp
+++ b/stan/math/rev/fun/fft.hpp
@@ -2,10 +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 <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/generalized_inverse.hpp b/stan/math/rev/fun/generalized_inverse.hpp
index b3d5a15711c..7d1057a8c64 100644
--- a/stan/math/rev/fun/generalized_inverse.hpp
+++ b/stan/math/rev/fun/generalized_inverse.hpp
@@ -1,11 +1,13 @@
 #ifndef STAN_MATH_REV_FUN_GENERALIZED_INVERSE_HPP
 #define STAN_MATH_REV_FUN_GENERALIZED_INVERSE_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/Eigen.hpp>
 #include <stan/math/prim/fun/add_diag.hpp>
+#include <stan/math/prim/fun/Eigen.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 e5770be9bc1..6712f9bd6ea 100644
--- a/stan/math/rev/fun/gp_exp_quad_cov.hpp
+++ b/stan/math/rev/fun/gp_exp_quad_cov.hpp
@@ -1,6 +1,7 @@
 #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>
@@ -8,7 +9,7 @@
 #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/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 c6ab4cac4e4..18602d487b5 100644
--- a/stan/math/rev/fun/gp_periodic_cov.hpp
+++ b/stan/math/rev/fun/gp_periodic_cov.hpp
@@ -12,6 +12,7 @@
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/constants.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/grad_inc_beta.hpp b/stan/math/rev/fun/grad_inc_beta.hpp
index 14b81dbfa21..e91ad18bac3 100644
--- a/stan/math/rev/fun/grad_inc_beta.hpp
+++ b/stan/math/rev/fun/grad_inc_beta.hpp
@@ -15,6 +15,8 @@
 #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/grad_inc_beta.hpp>
+
 #include <cmath>
 
 namespace stan {
diff --git a/stan/math/rev/fun/hypergeometric_2F1.hpp b/stan/math/rev/fun/hypergeometric_2F1.hpp
index 6b1843698f8..17b72518656 100644
--- a/stan/math/rev/fun/hypergeometric_2F1.hpp
+++ b/stan/math/rev/fun/hypergeometric_2F1.hpp
@@ -1,8 +1,8 @@
 #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/rev/meta.hpp>
 #include <stan/math/prim/fun/grad_2F1.hpp>
 #include <stan/math/prim/fun/hypergeometric_2F1.hpp>
 
diff --git a/stan/math/rev/fun/hypergeometric_pFq.hpp b/stan/math/rev/fun/hypergeometric_pFq.hpp
index 5d3b14496d1..5b03d1ad0a9 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/rev/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 {
diff --git a/stan/math/rev/fun/inc_beta.hpp b/stan/math/rev/fun/inc_beta.hpp
index dde94ee1e71..be8a65b7b6a 100644
--- a/stan/math/rev/fun/inc_beta.hpp
+++ b/stan/math/rev/fun/inc_beta.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/rev/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 {
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/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/log1m_inv_logit.hpp b/stan/math/rev/fun/log1m_inv_logit.hpp
index daa1ec4a7c1..382878317f3 100644
--- a/stan/math/rev/fun/log1m_inv_logit.hpp
+++ b/stan/math/rev/fun/log1m_inv_logit.hpp
@@ -3,8 +3,8 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/inv_logit.hpp>
-#include <stan/math/prim/fun/log1m_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/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 32a3b1c2c41..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/typedefs.hpp>
+#include <stan/math/prim/fun/log_determinant_spd.hpp>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/fun/log_softmax.hpp b/stan/math/rev/fun/log_softmax.hpp
index 273adc97b2e..d41a567156b 100644
--- a/stan/math/rev/fun/log_softmax.hpp
+++ b/stan/math/rev/fun/log_softmax.hpp
@@ -4,9 +4,9 @@
 #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/rev/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>
diff --git a/stan/math/rev/fun/log_sum_exp.hpp b/stan/math/rev/fun/log_sum_exp.hpp
index deefd2a249c..69299560616 100644
--- a/stan/math/rev/fun/log_sum_exp.hpp
+++ b/stan/math/rev/fun/log_sum_exp.hpp
@@ -5,9 +5,9 @@
 #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/rev/fun/inv_logit.hpp>
 #include <stan/math/prim/fun/log_sum_exp.hpp>
 #include <cmath>
 #include <vector>
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_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/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 8eac63206dc..e2da4e01bae 100644
--- a/stan/math/rev/fun/quad_form.hpp
+++ b/stan/math/rev/fun/quad_form.hpp
@@ -4,10 +4,10 @@
 #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/typedefs.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/fun/quad_form.hpp>
 #include <type_traits>
 
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 01064313c40..ee56dec9883 100644
--- a/stan/math/rev/fun/read_corr_matrix.hpp
+++ b/stan/math/rev/fun/read_corr_matrix.hpp
@@ -1,8 +1,8 @@
 #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/rev/core.hpp>
 #include <stan/math/rev/fun/read_corr_L.hpp>
 #include <stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp>
 
diff --git a/stan/math/rev/fun/read_cov_L.hpp b/stan/math/rev/fun/read_cov_L.hpp
index 5c7905aaead..cc33adf8b38 100644
--- a/stan/math/rev/fun/read_cov_L.hpp
+++ b/stan/math/rev/fun/read_cov_L.hpp
@@ -3,9 +3,9 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
-#include <stan/math/prim/fun/log.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>
 
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/rows_dot_self.hpp b/stan/math/rev/fun/rows_dot_self.hpp
index e8739d92559..7cccd0bbb23 100644
--- a/stan/math/rev/fun/rows_dot_self.hpp
+++ b/stan/math/rev/fun/rows_dot_self.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/dot_self.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 068d30b6fd6..e3db2d1651f 100644
--- a/stan/math/rev/fun/sd.hpp
+++ b/stan/math/rev/fun/sd.hpp
@@ -1,13 +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/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/typedefs.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/typedefs.hpp>
+#include <stan/math/prim/fun/sd.hpp>
 #include <cmath>
 #include <vector>
 
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 c1d8ca20ec2..93da1433cd2 100644
--- a/stan/math/rev/fun/softmax.hpp
+++ b/stan/math/rev/fun/softmax.hpp
@@ -6,9 +6,9 @@
 #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/rev/fun/value_of.hpp>
 #include <stan/math/prim/fun/typedefs.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/squared_distance.hpp b/stan/math/rev/fun/squared_distance.hpp
index 109266dd0e4..4fa774f74df 100644
--- a/stan/math/rev/fun/squared_distance.hpp
+++ b/stan/math/rev/fun/squared_distance.hpp
@@ -1,12 +1,12 @@
 #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/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>
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 a5ffbc96d3c..2ae31c4825f 100644
--- a/stan/math/rev/fun/svd.hpp
+++ b/stan/math/rev/fun/svd.hpp
@@ -7,6 +7,7 @@
 #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 ebc218d571c..217306bcc68 100644
--- a/stan/math/rev/fun/svd_U.hpp
+++ b/stan/math/rev/fun/svd_U.hpp
@@ -7,6 +7,7 @@
 #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/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/trace.hpp b/stan/math/rev/fun/trace.hpp
index 71d97f69fed..dfeb74c21d0 100644
--- a/stan/math/rev/fun/trace.hpp
+++ b/stan/math/rev/fun/trace.hpp
@@ -5,6 +5,7 @@
 #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 f36af382d63..2c0294fe202 100644
--- a/stan/math/rev/fun/trace_gen_quad_form.hpp
+++ b/stan/math/rev/fun/trace_gen_quad_form.hpp
@@ -1,13 +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/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/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 {

From 4c84cfb87c73b7352bceb2c849c20d4fbcf939a4 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Fri, 15 Nov 2024 14:13:48 -0500
Subject: [PATCH 17/19] update headers

---
 stan/math/rev/fun/hypergeometric_pFq.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stan/math/rev/fun/hypergeometric_pFq.hpp b/stan/math/rev/fun/hypergeometric_pFq.hpp
index 5b03d1ad0a9..140c24adc05 100644
--- a/stan/math/rev/fun/hypergeometric_pFq.hpp
+++ b/stan/math/rev/fun/hypergeometric_pFq.hpp
@@ -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);
         }

From 8b26bc564b5023a7355ad90e584e7c40779e384e Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 15 Nov 2024 14:16:41 -0500
Subject: [PATCH 18/19] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/rev/fun/eigenvalues_sym.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stan/math/rev/fun/eigenvalues_sym.hpp b/stan/math/rev/fun/eigenvalues_sym.hpp
index 2d2b6b63056..a74ca07d237 100644
--- a/stan/math/rev/fun/eigenvalues_sym.hpp
+++ b/stan/math/rev/fun/eigenvalues_sym.hpp
@@ -11,7 +11,6 @@
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/prim/fun/eigenvalues_sym.hpp>
 
-
 namespace stan {
 namespace math {
 

From 7cf039a4a6c05349000c28462cbd53bdc1bf33ad Mon Sep 17 00:00:00 2001
From: Brian Ward <bward@flatironinstitute.org>
Date: Fri, 15 Nov 2024 16:51:21 -0500
Subject: [PATCH 19/19] cpplint fix

---
 stan/math/rev/fun/generalized_inverse.hpp | 1 -
 stan/math/rev/fun/softmax.hpp             | 1 -
 2 files changed, 2 deletions(-)

diff --git a/stan/math/rev/fun/generalized_inverse.hpp b/stan/math/rev/fun/generalized_inverse.hpp
index 7d1057a8c64..11c0eb18ada 100644
--- a/stan/math/rev/fun/generalized_inverse.hpp
+++ b/stan/math/rev/fun/generalized_inverse.hpp
@@ -6,7 +6,6 @@
 #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/Eigen.hpp>
 #include <stan/math/prim/fun/generalized_inverse.hpp>
 
 namespace stan {
diff --git a/stan/math/rev/fun/softmax.hpp b/stan/math/rev/fun/softmax.hpp
index 93da1433cd2..a1bf786e826 100644
--- a/stan/math/rev/fun/softmax.hpp
+++ b/stan/math/rev/fun/softmax.hpp
@@ -6,7 +6,6 @@
 #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/rev/fun/value_of.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/softmax.hpp>