Add sequence Cholesky solver (#1396)

Summary:

Add a separate `SequenceCholeskySolver` for sequence problems where the existing online-QR solver is too expensive.

The new solver accumulates compact banded normal equations online, packs frame-local and universal columns contiguously before `J^T J`, supports chunked multithreaded accumulation with deterministic boundary and sequence-error handling, and solves the banded system with block LDLT by default. A scalar banded LDLT path remains user-switchable for debugging and benchmarking. Compact normal-equation accumulation defaults to double precision so float error functions can still evaluate residuals and Jacobians in float without losing precision before the double LDLT solve.

This diff also extracts shared sequence-solver helpers into `SequenceSolverBase`, exposes read-only `SequenceSolverFunction` accessors needed by the solver, wires the new solver into Momentum build/fwd generation, adds solver timing counters for normal-equation accumulation and linear solve, and adds a benchmark target that compares QR, block LDLT, scalar LDLT behavior, chunk size, `J^T J` packing, double normal-equation accumulation, and 93-joint larger-character cases.

Reviewed By: cstollmeta

Differential Revision: D105035576

Author: cdtwigg

cmake/build_variables.bzl

@@ -442,6 +442,8 @@ character_sequence_solver_public_headers = [
     "character_sequence_solver/multipose_solver_function.h",
     "character_sequence_solver/multipose_solver.h",
     "character_sequence_solver/sequence_error_function.h",
+    "character_sequence_solver/sequence_cholesky_solver.h",
+    "character_sequence_solver/sequence_solver_base.h",
     "character_sequence_solver/sequence_solver_function.h",
     "character_sequence_solver/sequence_solver.h",
     "character_sequence_solver/state_sequence_error_function.h",
@@ -456,6 +458,7 @@ character_sequence_solver_sources = [
     "character_sequence_solver/model_parameters_sequence_error_function.cpp",
     "character_sequence_solver/multipose_solver_function.cpp",
     "character_sequence_solver/multipose_solver.cpp",
+    "character_sequence_solver/sequence_cholesky_solver.cpp",
     "character_sequence_solver/sequence_solver_function.cpp",
     "character_sequence_solver/sequence_solver.cpp",
     "character_sequence_solver/state_sequence_error_function.cpp",

momentum/character_sequence_solver/fwd.h

@@ -24,6 +24,26 @@ using MultiposeSolverOptions_const_p = ::std::shared_ptr<const MultiposeSolverOp
 using MultiposeSolverOptions_const_u = ::std::unique_ptr<const MultiposeSolverOptions>;
 using MultiposeSolverOptions_const_w = ::std::weak_ptr<const MultiposeSolverOptions>;
 
+struct SequenceCholeskySolverOptions;
+
+using SequenceCholeskySolverOptions_p = ::std::shared_ptr<SequenceCholeskySolverOptions>;
+using SequenceCholeskySolverOptions_u = ::std::unique_ptr<SequenceCholeskySolverOptions>;
+using SequenceCholeskySolverOptions_w = ::std::weak_ptr<SequenceCholeskySolverOptions>;
+using SequenceCholeskySolverOptions_const_p =
+    ::std::shared_ptr<const SequenceCholeskySolverOptions>;
+using SequenceCholeskySolverOptions_const_u =
+    ::std::unique_ptr<const SequenceCholeskySolverOptions>;
+using SequenceCholeskySolverOptions_const_w = ::std::weak_ptr<const SequenceCholeskySolverOptions>;
+
+struct SequenceSolverOptionsBase;
+
+using SequenceSolverOptionsBase_p = ::std::shared_ptr<SequenceSolverOptionsBase>;
+using SequenceSolverOptionsBase_u = ::std::unique_ptr<SequenceSolverOptionsBase>;
+using SequenceSolverOptionsBase_w = ::std::weak_ptr<SequenceSolverOptionsBase>;
+using SequenceSolverOptionsBase_const_p = ::std::shared_ptr<const SequenceSolverOptionsBase>;
+using SequenceSolverOptionsBase_const_u = ::std::unique_ptr<const SequenceSolverOptionsBase>;
+using SequenceSolverOptionsBase_const_w = ::std::weak_ptr<const SequenceSolverOptionsBase>;
+
 struct SequenceSolverOptions;
 
 using SequenceSolverOptions_p = ::std::shared_ptr<SequenceSolverOptions>;
@@ -196,6 +216,44 @@ using MultiposeSolverFunctiond_const_p = ::std::shared_ptr<const MultiposeSolver
 using MultiposeSolverFunctiond_const_u = ::std::unique_ptr<const MultiposeSolverFunctiond>;
 using MultiposeSolverFunctiond_const_w = ::std::weak_ptr<const MultiposeSolverFunctiond>;
 
+template <typename T>
+class SequenceCholeskySolverT;
+using SequenceCholeskySolver = SequenceCholeskySolverT<float>;
+using SequenceCholeskySolverd = SequenceCholeskySolverT<double>;
+
+using SequenceCholeskySolver_p = ::std::shared_ptr<SequenceCholeskySolver>;
+using SequenceCholeskySolver_u = ::std::unique_ptr<SequenceCholeskySolver>;
+using SequenceCholeskySolver_w = ::std::weak_ptr<SequenceCholeskySolver>;
+using SequenceCholeskySolver_const_p = ::std::shared_ptr<const SequenceCholeskySolver>;
+using SequenceCholeskySolver_const_u = ::std::unique_ptr<const SequenceCholeskySolver>;
+using SequenceCholeskySolver_const_w = ::std::weak_ptr<const SequenceCholeskySolver>;
+
+using SequenceCholeskySolverd_p = ::std::shared_ptr<SequenceCholeskySolverd>;
+using SequenceCholeskySolverd_u = ::std::unique_ptr<SequenceCholeskySolverd>;
+using SequenceCholeskySolverd_w = ::std::weak_ptr<SequenceCholeskySolverd>;
+using SequenceCholeskySolverd_const_p = ::std::shared_ptr<const SequenceCholeskySolverd>;
+using SequenceCholeskySolverd_const_u = ::std::unique_ptr<const SequenceCholeskySolverd>;
+using SequenceCholeskySolverd_const_w = ::std::weak_ptr<const SequenceCholeskySolverd>;
+
+template <typename T>
+class SequenceSolverBaseT;
+using SequenceSolverBase = SequenceSolverBaseT<float>;
+using SequenceSolverBased = SequenceSolverBaseT<double>;
+
+using SequenceSolverBase_p = ::std::shared_ptr<SequenceSolverBase>;
+using SequenceSolverBase_u = ::std::unique_ptr<SequenceSolverBase>;
+using SequenceSolverBase_w = ::std::weak_ptr<SequenceSolverBase>;
+using SequenceSolverBase_const_p = ::std::shared_ptr<const SequenceSolverBase>;
+using SequenceSolverBase_const_u = ::std::unique_ptr<const SequenceSolverBase>;
+using SequenceSolverBase_const_w = ::std::weak_ptr<const SequenceSolverBase>;
+
+using SequenceSolverBased_p = ::std::shared_ptr<SequenceSolverBased>;
+using SequenceSolverBased_u = ::std::unique_ptr<SequenceSolverBased>;
+using SequenceSolverBased_w = ::std::weak_ptr<SequenceSolverBased>;
+using SequenceSolverBased_const_p = ::std::shared_ptr<const SequenceSolverBased>;
+using SequenceSolverBased_const_u = ::std::unique_ptr<const SequenceSolverBased>;
+using SequenceSolverBased_const_w = ::std::weak_ptr<const SequenceSolverBased>;
+
 template <typename T>
 class SequenceSolverT;
 using SequenceSolver = SequenceSolverT<float>;