Add tuple support to apply_scalar_unary for autodiff

Add tuple specialization to apply_scalar_unary so that vectorized
math functions (exp, sin, cos, etc.) automatically work on tuples.
Also extend require_ad_container_t to accept tuples containing
autodiff types, and add is_autodiff support for tuples.

Fixes #3041

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: nsiccha

stan/math/prim/functor/apply_scalar_unary.hpp

@@ -4,11 +4,13 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_complex.hpp>
+#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/holder.hpp>
 #include <stan/math/prim/meta/require_generics.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_vector_like.hpp>
 #include <stan/math/prim/meta/plain_type.hpp>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -206,6 +208,36 @@ struct apply_scalar_unary<F, T, require_std_vector_t<T>> {
   }
 };
 
+/**
+ * Template specialization for vectorized functions applying to
+ * tuple arguments.  Each element of the tuple is processed
+ * recursively through apply_scalar_unary, allowing heterogeneous
+ * element types.
+ *
+ * @tparam F Type of function defining static apply function.
+ * @tparam T Tuple type.
+ */
+template <typename F, typename T>
+struct apply_scalar_unary<F, T, require_tuple_t<T>> {
+  template <typename TT, size_t... Is>
+  static inline auto apply_impl(TT&& x, std::index_sequence<Is...>) {
+    return std::make_tuple(
+        apply_scalar_unary<
+            F, std::tuple_element_t<Is, std::decay_t<T>>>::
+            apply(std::get<Is>(std::forward<TT>(x)))...);
+  }
+
+  template <typename TT>
+  static inline auto apply(TT&& x) {
+    return apply_impl(
+        std::forward<TT>(x),
+        std::make_index_sequence<std::tuple_size_v<std::decay_t<T>>>());
+  }
+
+  using return_t = std::decay_t<decltype(
+      apply_scalar_unary<F, T>::apply(std::declval<T>()))>;
+};
+
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/prim/meta/is_autodiff.hpp

@@ -8,10 +8,12 @@
 #include <stan/math/prim/meta/is_fvar.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_var.hpp>
+#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/require_helpers.hpp>
 #include <stan/math/prim/meta/scalar_type.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <complex>
+#include <tuple>
 #include <type_traits>
 
 namespace stan {
@@ -46,6 +48,17 @@ template <typename T>
 struct is_autodiff<T, require_eigen_t<T>>
     : bool_constant<is_autodiff<typename std::decay_t<T>::Scalar>::value> {};
 
+template <typename Tuple, typename = void>
+struct is_tuple_autodiff : std::false_type {};
+
+template <typename... Ts>
+struct is_tuple_autodiff<std::tuple<Ts...>, void>
+    : bool_constant<(is_autodiff<Ts>::value || ...)> {};
+
+template <typename T>
+struct is_autodiff<T, math::require_tuple_t<T>>
+    : is_tuple_autodiff<std::decay_t<T>> {};
+
 }  // namespace internal
 
 /**

stan/math/prim/meta/is_container.hpp

@@ -5,6 +5,7 @@
 #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_tuple.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>
@@ -99,9 +100,11 @@ using require_not_container_st
 /*! and holds a base type that satisfies @ref is_autodiff_scalar */
 /*! @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_scalar<base_type_t<T>>>;
+using require_ad_container_t = require_t<math::disjunction<
+    math::conjunction<math::disjunction<is_eigen<T>, is_std_vector<T>>,
+                      is_autodiff_scalar<base_type_t<T>>>,
+    math::conjunction<math::is_tuple<T>,
+                      internal::is_autodiff<std::decay_t<T>>>>>;
 /*! @} */
 
 }  // namespace stan