Add tuple overloads for deep_copy_vars, save_varis, accumulate_adjoints

These three functions handle var, vector<var>, Eigen<var>, and arithmetic
types but not tuples. With STAN_THREADS=true, reduce_sum passes tuple
arguments through these functions, causing compilation failures.

Add tuple overloads that unpack the tuple via stan::math::apply and
recursively process each element.

Fixes #3041

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

Author: nsiccha

stan/math/rev/core/accumulate_adjoints.hpp

@@ -2,9 +2,11 @@
 #define STAN_MATH_REV_CORE_ACCUMULATE_ADJOINTS_HPP
 
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
 
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -35,6 +37,9 @@ inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args);
 
 inline double* accumulate_adjoints(double* dest);
 
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
+inline double* accumulate_adjoints(double* dest, Tuple&& x, Pargs&&... args);
+
 /**
  * Accumulate adjoints from x into storage pointed to by dest,
  *   increment the adjoint storage pointer,
@@ -147,6 +152,20 @@ inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args) {
  */
 inline double* accumulate_adjoints(double* dest) { return dest; }
 
+/**
+ * Unpack a tuple and accumulate adjoints from each element.
+ */
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
+inline double* accumulate_adjoints(double* dest, Tuple&& x, Pargs&&... args) {
+  dest = stan::math::apply(
+      [dest](auto&&... inner_args) {
+        return accumulate_adjoints(
+            dest, std::forward<decltype(inner_args)>(inner_args)...);
+      },
+      std::forward<Tuple>(x));
+  return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
+}
+
 }  // namespace math
 }  // namespace stan
 

stan/math/rev/core/deep_copy_vars.hpp

@@ -2,9 +2,11 @@
 #define STAN_MATH_REV_CORE_DEEP_COPY_VARS_HPP
 
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
 
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -81,6 +83,24 @@ inline auto deep_copy_vars(EigT&& arg) {
       .eval();
 }
 
+/**
+ * Copy the vars in a tuple but reallocate new varis for them.
+ * Non-var elements are forwarded unchanged.
+ *
+ * @tparam Tuple A std::tuple type
+ * @param arg A tuple potentially containing vars
+ * @return A new tuple with deep-copied vars
+ */
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
+inline auto deep_copy_vars(Tuple&& arg) {
+  return stan::math::apply(
+      [](auto&&... args) {
+        return std::make_tuple(deep_copy_vars(
+            std::forward<decltype(args)>(args))...);
+      },
+      std::forward<Tuple>(arg));
+}
+
 }  // namespace math
 }  // namespace stan
 

stan/math/rev/core/save_varis.hpp

@@ -3,9 +3,11 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
 
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -35,6 +37,9 @@ inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args);
 
 inline vari** save_varis(vari** dest);
 
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
+inline vari** save_varis(vari** dest, Tuple&& x, Pargs&&... args);
+
 /**
  * Save the vari pointer in x into the memory pointed to by dest,
  *   increment the dest storage pointer,
@@ -143,6 +148,19 @@ inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args) {
  */
 inline vari** save_varis(vari** dest) { return dest; }
 
+/**
+ * Unpack a tuple and save the varis of each element.
+ */
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
+inline vari** save_varis(vari** dest, Tuple&& x, Pargs&&... args) {
+  dest = stan::math::apply(
+      [dest](auto&&... inner_args) {
+        return save_varis(dest, std::forward<decltype(inner_args)>(inner_args)...);
+      },
+      std::forward<Tuple>(x));
+  return save_varis(dest, std::forward<Pargs>(args)...);
+}
+
 }  // namespace math
 }  // namespace stan