diff --git a/include/ceres/problem.h b/include/ceres/problem.h
index add12ea..4c6fd1b 100644
--- a/include/ceres/problem.h
+++ b/include/ceres/problem.h
@@ -1,5 +1,5 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 Google Inc. All rights reserved.
+// Copyright 2023 Google Inc. All rights reserved.
 // http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
@@ -43,6 +43,7 @@
 
 #include "ceres/context.h"
 #include "ceres/internal/disable_warnings.h"
+#include "ceres/internal/export.h"
 #include "ceres/internal/port.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
@@ -52,7 +53,7 @@
 class CostFunction;
 class EvaluationCallback;
 class LossFunction;
-class LocalParameterization;
+class Manifold;
 class Solver;
 struct CRSMatrix;
 
@@ -65,7 +66,7 @@
 
 // A ResidualBlockId is an opaque handle clients can use to remove residual
 // blocks from a Problem after adding them.
-typedef internal::ResidualBlock* ResidualBlockId;
+using ResidualBlockId = internal::ResidualBlock*;
 
 // A class to represent non-linear least squares problems. Such
 // problems have a cost function that is a sum of error terms (known
@@ -78,31 +79,28 @@
 //
 // where
 //
-//   r_ij     is residual number i, component j; the residual is a
-//            function of some subset of the parameters x1...xk. For
-//            example, in a structure from motion problem a residual
-//            might be the difference between a measured point in an
-//            image and the reprojected position for the matching
-//            camera, point pair. The residual would have two
-//            components, error in x and error in y.
+//   r_ij is residual number i, component j; the residual is a function of some
+//        subset of the parameters x1...xk. For example, in a structure from
+//        motion problem a residual might be the difference between a measured
+//        point in an image and the reprojected position for the matching
+//        camera, point pair. The residual would have two components, error in x
+//        and error in y.
 //
-//   loss(y)  is the loss function; for example, squared error or
-//            Huber L1 loss. If loss(y) = y, then the cost function is
-//            non-robustified least squares.
+//   loss(y) is the loss function; for example, squared error or Huber L1
+//           loss. If loss(y) = y, then the cost function is non-robustified
+//           least squares.
 //
-// This class is specifically designed to address the important subset
-// of "sparse" least squares problems, where each component of the
-// residual depends only on a small number number of parameters, even
-// though the total number of residuals and parameters may be very
-// large. This property affords tremendous gains in scale, allowing
-// efficient solving of large problems that are otherwise
-// inaccessible.
+// This class is specifically designed to address the important subset of
+// "sparse" least squares problems, where each component of the residual depends
+// only on a small number number of parameters, even though the total number of
+// residuals and parameters may be very large. This property affords tremendous
+// gains in scale, allowing efficient solving of large problems that are
+// otherwise inaccessible.
 //
 // The canonical example of a sparse least squares problem is
-// "structure-from-motion" (SFM), where the parameters are points and
-// cameras, and residuals are reprojection errors. Typically a single
-// residual will depend only on 9 parameters (3 for the point, 6 for
-// the camera).
+// "structure-from-motion" (SFM), where the parameters are points and cameras,
+// and residuals are reprojection errors. Typically a single residual will
+// depend only on 9 parameters (3 for the point, 6 for the camera).
 //
 // To create a least squares problem, use the AddResidualBlock() and
 // AddParameterBlock() methods, documented below. Here is an example least
@@ -122,38 +120,37 @@
 class CERES_EXPORT Problem {
  public:
   struct CERES_EXPORT Options {
-    // These flags control whether the Problem object owns the cost
-    // functions, loss functions, and parameterizations passed into
-    // the Problem. If set to TAKE_OWNERSHIP, then the problem object
-    // will delete the corresponding cost or loss functions on
-    // destruction. The destructor is careful to delete the pointers
-    // only once, since sharing cost/loss/parameterizations is
-    // allowed.
+    // These flags control whether the Problem object owns the CostFunctions,
+    // LossFunctions, and Manifolds passed into the Problem.
+    //
+    // If set to TAKE_OWNERSHIP, then the problem object will delete the
+    // corresponding object on destruction. The destructor is careful to delete
+    // the pointers only once, since sharing objects is allowed.
     Ownership cost_function_ownership = TAKE_OWNERSHIP;
     Ownership loss_function_ownership = TAKE_OWNERSHIP;
-    Ownership local_parameterization_ownership = TAKE_OWNERSHIP;
+    Ownership manifold_ownership = TAKE_OWNERSHIP;
 
     // If true, trades memory for faster RemoveResidualBlock() and
     // RemoveParameterBlock() operations.
     //
     // By default, RemoveParameterBlock() and RemoveResidualBlock() take time
-    // proportional to the size of the entire problem.  If you only ever remove
+    // proportional to the size of the entire problem. If you only ever remove
     // parameters or residuals from the problem occasionally, this might be
-    // acceptable.  However, if you have memory to spare, enable this option to
+    // acceptable. However, if you have memory to spare, enable this option to
     // make RemoveParameterBlock() take time proportional to the number of
     // residual blocks that depend on it, and RemoveResidualBlock() take (on
     // average) constant time.
     //
-    // The increase in memory usage is twofold: an additional hash set per
+    // The increase in memory usage is two-fold: an additional hash set per
     // parameter block containing all the residuals that depend on the parameter
     // block; and a hash set in the problem containing all residuals.
     bool enable_fast_removal = false;
 
     // By default, Ceres performs a variety of safety checks when constructing
-    // the problem. There is a small but measurable performance penalty to
-    // these checks, typically around 5% of construction time. If you are sure
-    // your problem construction is correct, and 5% of the problem construction
-    // time is truly an overhead you want to avoid, then you can set
+    // the problem. There is a small but measurable performance penalty to these
+    // checks, typically around 5% of construction time. If you are sure your
+    // problem construction is correct, and 5% of the problem construction time
+    // is truly an overhead you want to avoid, then you can set
     // disable_all_safety_checks to true.
     //
     // WARNING: Do not set this to true, unless you are absolutely sure of what
@@ -167,26 +164,23 @@
     // Ceres does NOT take ownership of the pointer.
     Context* context = nullptr;
 
-    // Using this callback interface, Ceres can notify you when it is
-    // about to evaluate the residuals or jacobians. With the
-    // callback, you can share computation between residual blocks by
-    // doing the shared computation in
+    // Using this callback interface, Ceres can notify you when it is about to
+    // evaluate the residuals or jacobians. With the callback, you can share
+    // computation between residual blocks by doing the shared computation in
     // EvaluationCallback::PrepareForEvaluation() before Ceres calls
-    // CostFunction::Evaluate(). It also enables caching results
-    // between a pure residual evaluation and a residual & jacobian
-    // evaluation.
+    // CostFunction::Evaluate(). It also enables caching results between a pure
+    // residual evaluation and a residual & jacobian evaluation.
     //
     // Problem DOES NOT take ownership of the callback.
     //
-    // NOTE: Evaluation callbacks are incompatible with inner
-    // iterations. So calling Solve with
-    // Solver::Options::use_inner_iterations = true on a Problem with
-    // a non-null evaluation callback is an error.
+    // NOTE: Evaluation callbacks are incompatible with inner iterations. So
+    // calling Solve with Solver::Options::use_inner_iterations = true on a
+    // Problem with a non-null evaluation callback is an error.
     EvaluationCallback* evaluation_callback = nullptr;
   };
 
-  // The default constructor is equivalent to the
-  // invocation Problem(Problem::Options()).
+  // The default constructor is equivalent to the invocation
+  // Problem(Problem::Options()).
   Problem();
   explicit Problem(const Options& options);
   Problem(Problem&&);
@@ -197,31 +191,29 @@
 
   ~Problem();
 
-  // Add a residual block to the overall cost function. The cost
-  // function carries with its information about the sizes of the
-  // parameter blocks it expects. The function checks that these match
-  // the sizes of the parameter blocks listed in parameter_blocks. The
-  // program aborts if a mismatch is detected. loss_function can be
-  // nullptr, in which case the cost of the term is just the squared norm
-  // of the residuals.
+  // Add a residual block to the overall cost function. The cost function
+  // carries with its information about the sizes of the parameter blocks it
+  // expects. The function checks that these match the sizes of the parameter
+  // blocks listed in parameter_blocks. The program aborts if a mismatch is
+  // detected. loss_function can be nullptr, in which case the cost of the term
+  // is just the squared norm of the residuals.
   //
-  // The user has the option of explicitly adding the parameter blocks
-  // using AddParameterBlock. This causes additional correctness
-  // checking; however, AddResidualBlock implicitly adds the parameter
-  // blocks if they are not present, so calling AddParameterBlock
-  // explicitly is not required.
+  // The user has the option of explicitly adding the parameter blocks using
+  // AddParameterBlock. This causes additional correctness checking; however,
+  // AddResidualBlock implicitly adds the parameter blocks if they are not
+  // present, so calling AddParameterBlock explicitly is not required.
   //
-  // The Problem object by default takes ownership of the
-  // cost_function and loss_function pointers. These objects remain
-  // live for the life of the Problem object. If the user wishes to
-  // keep control over the destruction of these objects, then they can
+  // The Problem object by default takes ownership of the cost_function and
+  // loss_function pointers (See Problem::Options to override this behaviour).
+  // These objects remain live for the life of the Problem object. If the user
+  // wishes to keep control over the destruction of these objects, then they can
   // do this by setting the corresponding enums in the Options struct.
   //
-  // Note: Even though the Problem takes ownership of cost_function
-  // and loss_function, it does not preclude the user from re-using
-  // them in another residual block. The destructor takes care to call
-  // delete on each cost_function or loss_function pointer only once,
-  // regardless of how many residual blocks refer to them.
+  // Note: Even though the Problem takes ownership of cost_function and
+  // loss_function, it does not preclude the user from re-using them in another
+  // residual block. The destructor takes care to call delete on each
+  // cost_function or loss_function pointer only once, regardless of how many
+  // residual blocks refer to them.
   //
   // Example usage:
   //
@@ -234,8 +226,8 @@
   //   problem.AddResidualBlock(new MyUnaryCostFunction(...), nullptr, x1);
   //   problem.AddResidualBlock(new MyBinaryCostFunction(...), nullptr, x2, x1);
   //
-  // Add a residual block by listing the parameter block pointers
-  // directly instead of wapping them in a container.
+  // Add a residual block by listing the parameter block pointers directly
+  // instead of wapping them in a container.
   template <typename... Ts>
   ResidualBlockId AddResidualBlock(CostFunction* cost_function,
                                    LossFunction* loss_function,
@@ -261,29 +253,32 @@
                                    double* const* const parameter_blocks,
                                    int num_parameter_blocks);
 
-  // Add a parameter block with appropriate size to the problem.
-  // Repeated calls with the same arguments are ignored. Repeated
-  // calls with the same double pointer but a different size results
-  // in undefined behaviour.
+  // Add a parameter block with appropriate size to the problem. Repeated calls
+  // with the same arguments are ignored. Repeated calls with the same double
+  // pointer but a different size will result in a crash.
   void AddParameterBlock(double* values, int size);
 
-  // Add a parameter block with appropriate size and parameterization
-  // to the problem. Repeated calls with the same arguments are
-  // ignored. Repeated calls with the same double pointer but a
-  // different size results in undefined behaviour.
-  void AddParameterBlock(double* values,
-                         int size,
-                         LocalParameterization* local_parameterization);
-
-  // Remove a parameter block from the problem. The parameterization of the
-  // parameter block, if it exists, will persist until the deletion of the
-  // problem (similar to cost/loss functions in residual block removal). Any
-  // residual blocks that depend on the parameter are also removed, as
-  // described above in RemoveResidualBlock().
+  // Add a parameter block with appropriate size and Manifold to the
+  // problem. It is okay for manifold to be nullptr.
   //
-  // If Problem::Options::enable_fast_removal is true, then the
-  // removal is fast (almost constant time). Otherwise, removing a parameter
-  // block will incur a scan of the entire Problem object.
+  // Repeated calls with the same arguments are ignored. Repeated calls
+  // with the same double pointer but a different size results in a crash
+  // (unless Solver::Options::disable_all_safety_checks is set to true).
+  //
+  // Repeated calls with the same double pointer and size but different Manifold
+  // is equivalent to calling SetManifold(manifold), i.e., any previously
+  // associated Manifold object will be replaced with the manifold.
+  void AddParameterBlock(double* values, int size, Manifold* manifold);
+
+  // Remove a parameter block from the problem. The Manifold of the parameter
+  // block, if it exists, will persist until the deletion of the problem
+  // (similar to cost/loss functions in residual block removal). Any residual
+  // blocks that depend on the parameter are also removed, as described above
+  // in RemoveResidualBlock().
+  //
+  // If Problem::Options::enable_fast_removal is true, then the removal is fast
+  // (almost constant time). Otherwise, removing a parameter block will incur a
+  // scan of the entire Problem object.
   //
   // WARNING: Removing a residual or parameter block will destroy the implicit
   // ordering, rendering the jacobian or residuals returned from the solver
@@ -308,35 +303,41 @@
   // Allow the indicated parameter block to vary during optimization.
   void SetParameterBlockVariable(double* values);
 
-  // Returns true if a parameter block is set constant, and false
-  // otherwise. A parameter block may be set constant in two ways:
-  // either by calling SetParameterBlockConstant or by associating a
-  // LocalParameterization with a zero dimensional tangent space with
-  // it.
+  // Returns true if a parameter block is set constant, and false otherwise. A
+  // parameter block may be set constant in two ways: either by calling
+  // SetParameterBlockConstant or by associating a Manifold with a zero
+  // dimensional tangent space with it.
   bool IsParameterBlockConstant(const double* values) const;
 
-  // Set the local parameterization for one of the parameter blocks.
-  // The local_parameterization is owned by the Problem by default. It
-  // is acceptable to set the same parameterization for multiple
-  // parameters; the destructor is careful to delete local
-  // parameterizations only once. Calling SetParameterization with
-  // nullptr will clear any previously set parameterization.
-  void SetParameterization(double* values,
-                           LocalParameterization* local_parameterization);
+  // Set the Manifold for the parameter block. Calling SetManifold with nullptr
+  // will clear any previously set Manifold for the parameter block.
+  //
+  // Repeated calls will result in any previously associated Manifold object to
+  // be replaced with the manifold.
+  //
+  // The manifold is owned by the Problem by default (See Problem::Options to
+  // override this behaviour).
+  //
+  // It is acceptable to set the same Manifold for multiple parameter blocks.
+  void SetManifold(double* values, Manifold* manifold);
 
-  // Get the local parameterization object associated with this
-  // parameter block. If there is no parameterization object
-  // associated then nullptr is returned.
-  const LocalParameterization* GetParameterization(const double* values) const;
+  // Get the Manifold object associated with this parameter block.
+  //
+  // If there is no Manifold object associated then nullptr is returned.
+  const Manifold* GetManifold(const double* values) const;
+
+  // Returns true if a Manifold is associated with this parameter block, false
+  // otherwise.
+  bool HasManifold(const double* values) const;
 
   // Set the lower/upper bound for the parameter at position "index".
   void SetParameterLowerBound(double* values, int index, double lower_bound);
   void SetParameterUpperBound(double* values, int index, double upper_bound);
 
-  // Get the lower/upper bound for the parameter at position
-  // "index". If the parameter is not bounded by the user, then its
-  // lower bound is -std::numeric_limits<double>::max() and upper
-  // bound is std::numeric_limits<double>::max().
+  // Get the lower/upper bound for the parameter at position "index". If the
+  // parameter is not bounded by the user, then its lower bound is
+  // -std::numeric_limits<double>::max() and upper bound is
+  // std::numeric_limits<double>::max().
   double GetParameterLowerBound(const double* values, int index) const;
   double GetParameterUpperBound(const double* values, int index) const;
 
@@ -344,37 +345,37 @@
   // parameter_blocks().size() and parameter_block_sizes().size().
   int NumParameterBlocks() const;
 
-  // The size of the parameter vector obtained by summing over the
-  // sizes of all the parameter blocks.
+  // The size of the parameter vector obtained by summing over the sizes of all
+  // the parameter blocks.
   int NumParameters() const;
 
   // Number of residual blocks in the problem. Always equals
   // residual_blocks().size().
   int NumResidualBlocks() const;
 
-  // The size of the residual vector obtained by summing over the
-  // sizes of all of the residual blocks.
+  // The size of the residual vector obtained by summing over the sizes of all
+  // of the residual blocks.
   int NumResiduals() const;
 
   // The size of the parameter block.
   int ParameterBlockSize(const double* values) const;
 
-  // The size of local parameterization for the parameter block. If
-  // there is no local parameterization associated with this parameter
-  // block, then ParameterBlockLocalSize = ParameterBlockSize.
-  int ParameterBlockLocalSize(const double* values) const;
+  // The dimension of the tangent space of the Manifold for the parameter block.
+  // If there is no Manifold associated with this parameter block, then
+  // ParameterBlockTangentSize = ParameterBlockSize.
+  int ParameterBlockTangentSize(const double* values) const;
 
   // Is the given parameter block present in this problem or not?
   bool HasParameterBlock(const double* values) const;
 
-  // Fills the passed parameter_blocks vector with pointers to the
-  // parameter blocks currently in the problem. After this call,
-  // parameter_block.size() == NumParameterBlocks.
+  // Fills the passed parameter_blocks vector with pointers to the parameter
+  // blocks currently in the problem. After this call, parameter_block.size() ==
+  // NumParameterBlocks.
   void GetParameterBlocks(std::vector<double*>* parameter_blocks) const;
 
-  // Fills the passed residual_blocks vector with pointers to the
-  // residual blocks currently in the problem. After this call,
-  // residual_blocks.size() == NumResidualBlocks.
+  // Fills the passed residual_blocks vector with pointers to the residual
+  // blocks currently in the problem. After this call, residual_blocks.size() ==
+  // NumResidualBlocks.
   void GetResidualBlocks(std::vector<ResidualBlockId>* residual_blocks) const;
 
   // Get all the parameter blocks that depend on the given residual block.
@@ -393,10 +394,10 @@
 
   // Get all the residual blocks that depend on the given parameter block.
   //
-  // If Problem::Options::enable_fast_removal is true, then
-  // getting the residual blocks is fast and depends only on the number of
-  // residual blocks. Otherwise, getting the residual blocks for a parameter
-  // block will incur a scan of the entire Problem object.
+  // If Problem::Options::enable_fast_removal is true, then getting the residual
+  // blocks is fast and depends only on the number of residual
+  // blocks. Otherwise, getting the residual blocks for a parameter block will
+  // incur a scan of the entire Problem object.
   void GetResidualBlocksForParameterBlock(
       const double* values,
       std::vector<ResidualBlockId>* residual_blocks) const;
@@ -404,49 +405,45 @@
   // Options struct to control Problem::Evaluate.
   struct EvaluateOptions {
     // The set of parameter blocks for which evaluation should be
-    // performed. This vector determines the order that parameter
-    // blocks occur in the gradient vector and in the columns of the
-    // jacobian matrix. If parameter_blocks is empty, then it is
-    // assumed to be equal to vector containing ALL the parameter
-    // blocks.  Generally speaking the parameter blocks will occur in
-    // the order in which they were added to the problem. But, this
-    // may change if the user removes any parameter blocks from the
-    // problem.
+    // performed. This vector determines the order that parameter blocks occur
+    // in the gradient vector and in the columns of the jacobian matrix. If
+    // parameter_blocks is empty, then it is assumed to be equal to vector
+    // containing ALL the parameter blocks. Generally speaking the parameter
+    // blocks will occur in the order in which they were added to the
+    // problem. But, this may change if the user removes any parameter blocks
+    // from the problem.
     //
-    // NOTE: This vector should contain the same pointers as the ones
-    // used to add parameter blocks to the Problem. These parameter
-    // block should NOT point to new memory locations. Bad things will
-    // happen otherwise.
+    // NOTE: This vector should contain the same pointers as the ones used to
+    // add parameter blocks to the Problem. These parameter block should NOT
+    // point to new memory locations. Bad things will happen otherwise.
     std::vector<double*> parameter_blocks;
 
-    // The set of residual blocks to evaluate. This vector determines
-    // the order in which the residuals occur, and how the rows of the
-    // jacobian are ordered. If residual_blocks is empty, then it is
-    // assumed to be equal to the vector containing ALL the residual
-    // blocks. Generally speaking the residual blocks will occur in
-    // the order in which they were added to the problem. But, this
-    // may change if the user removes any residual blocks from the
-    // problem.
+    // The set of residual blocks to evaluate. This vector determines the order
+    // in which the residuals occur, and how the rows of the jacobian are
+    // ordered. If residual_blocks is empty, then it is assumed to be equal to
+    // the vector containing ALL the residual blocks. Generally speaking the
+    // residual blocks will occur in the order in which they were added to the
+    // problem. But, this may change if the user removes any residual blocks
+    // from the problem.
     std::vector<ResidualBlockId> residual_blocks;
 
     // Even though the residual blocks in the problem may contain loss
-    // functions, setting apply_loss_function to false will turn off
-    // the application of the loss function to the output of the cost
-    // function. This is of use for example if the user wishes to
-    // analyse the solution quality by studying the distribution of
-    // residuals before and after the solve.
+    // functions, setting apply_loss_function to false will turn off the
+    // application of the loss function to the output of the cost function. This
+    // is of use for example if the user wishes to analyse the solution quality
+    // by studying the distribution of residuals before and after the solve.
     bool apply_loss_function = true;
 
     int num_threads = 1;
   };
 
-  // Evaluate Problem. Any of the output pointers can be nullptr. Which
-  // residual blocks and parameter blocks are used is controlled by
-  // the EvaluateOptions struct above.
+  // Evaluate Problem. Any of the output pointers can be nullptr. Which residual
+  // blocks and parameter blocks are used is controlled by the EvaluateOptions
+  // struct above.
   //
-  // Note 1: The evaluation will use the values stored in the memory
-  // locations pointed to by the parameter block pointers used at the
-  // time of the construction of the problem. i.e.,
+  // Note 1: The evaluation will use the values stored in the memory locations
+  // pointed to by the parameter block pointers used at the time of the
+  // construction of the problem. i.e.,
   //
   //   Problem problem;
   //   double x = 1;
@@ -456,8 +453,8 @@
   //   problem.Evaluate(Problem::EvaluateOptions(), &cost,
   //                    nullptr, nullptr, nullptr);
   //
-  // The cost is evaluated at x = 1. If you wish to evaluate the
-  // problem at x = 2, then
+  // The cost is evaluated at x = 1. If you wish to evaluate the problem at x =
+  // 2, then
   //
   //   x = 2;
   //   problem.Evaluate(Problem::EvaluateOptions(), &cost,
@@ -465,80 +462,74 @@
   //
   // is the way to do so.
   //
-  // Note 2: If no local parameterizations are used, then the size of
-  // the gradient vector (and the number of columns in the jacobian)
-  // is the sum of the sizes of all the parameter blocks. If a
-  // parameter block has a local parameterization, then it contributes
-  // "LocalSize" entries to the gradient vector (and the number of
-  // columns in the jacobian).
+  // Note 2: If no Manifolds are used, then the size of the gradient vector (and
+  // the number of columns in the jacobian) is the sum of the sizes of all the
+  // parameter blocks. If a parameter block has a Manifold, then it contributes
+  // "TangentSize" entries to the gradient vector (and the number of columns in
+  // the jacobian).
   //
-  // Note 3: This function cannot be called while the problem is being
-  // solved, for example it cannot be called from an IterationCallback
-  // at the end of an iteration during a solve.
+  // Note 3: This function cannot be called while the problem is being solved,
+  // for example it cannot be called from an IterationCallback at the end of an
+  // iteration during a solve.
   //
-  // Note 4: If an EvaluationCallback is associated with the problem,
-  // then its PrepareForEvaluation method will be called every time
-  // this method is called with new_point = true.
+  // Note 4: If an EvaluationCallback is associated with the problem, then its
+  // PrepareForEvaluation method will be called every time this method is called
+  // with new_point = true.
   bool Evaluate(const EvaluateOptions& options,
                 double* cost,
                 std::vector<double>* residuals,
                 std::vector<double>* gradient,
                 CRSMatrix* jacobian);
 
-  // Evaluates the residual block, storing the scalar cost in *cost,
-  // the residual components in *residuals, and the jacobians between
-  // the parameters and residuals in jacobians[i], in row-major order.
+  // Evaluates the residual block, storing the scalar cost in *cost, the
+  // residual components in *residuals, and the jacobians between the parameters
+  // and residuals in jacobians[i], in row-major order.
   //
   // If residuals is nullptr, the residuals are not computed.
   //
-  // If jacobians is nullptr, no Jacobians are computed. If
-  // jacobians[i] is nullptr, then the Jacobian for that parameter
-  // block is not computed.
+  // If jacobians is nullptr, no Jacobians are computed. If jacobians[i] is
+  // nullptr, then the Jacobian for that parameter block is not computed.
   //
-  // It is not okay to request the Jacobian w.r.t a parameter block
-  // that is constant.
+  // It is not okay to request the Jacobian w.r.t a parameter block that is
+  // constant.
   //
-  // The return value indicates the success or failure. Even if the
-  // function returns false, the caller should expect the output
-  // memory locations to have been modified.
+  // The return value indicates the success or failure. Even if the function
+  // returns false, the caller should expect the output memory locations to have
+  // been modified.
   //
-  // The returned cost and jacobians have had robustification and
-  // local parameterizations applied already; for example, the
-  // jacobian for a 4-dimensional quaternion parameter using the
-  // "QuaternionParameterization" is num_residuals by 3 instead of
-  // num_residuals by 4.
+  // The returned cost and jacobians have had robustification and Manifold
+  // applied already; for example, the jacobian for a 4-dimensional quaternion
+  // parameter using the "QuaternionParameterization" is num_residuals by 3
+  // instead of num_residuals by 4.
   //
-  // apply_loss_function as the name implies allows the user to switch
-  // the application of the loss function on and off.
+  // apply_loss_function as the name implies allows the user to switch the
+  // application of the loss function on and off.
   //
   // If an EvaluationCallback is associated with the problem, then its
-  // PrepareForEvaluation method will be called every time this method
-  // is called with new_point = true. This conservatively assumes that
-  // the user may have changed the parameter values since the previous
-  // call to evaluate / solve.  For improved efficiency, and only if
-  // you know that the parameter values have not changed between
-  // calls, see EvaluateResidualBlockAssumingParametersUnchanged().
+  // PrepareForEvaluation method will be called every time this method is called
+  // with new_point = true. This conservatively assumes that the user may have
+  // changed the parameter values since the previous call to evaluate / solve.
+  // For improved efficiency, and only if you know that the parameter values
+  // have not changed between calls, see
+  // EvaluateResidualBlockAssumingParametersUnchanged().
   bool EvaluateResidualBlock(ResidualBlockId residual_block_id,
                              bool apply_loss_function,
                              double* cost,
                              double* residuals,
                              double** jacobians) const;
 
-  // Same as EvaluateResidualBlock except that if an
-  // EvaluationCallback is associated with the problem, then its
-  // PrepareForEvaluation method will be called every time this method
-  // is called with new_point = false.
+  // Same as EvaluateResidualBlock except that if an EvaluationCallback is
+  // associated with the problem, then its PrepareForEvaluation method will be
+  // called every time this method is called with new_point = false.
   //
-  // This means, if an EvaluationCallback is associated with the
-  // problem then it is the user's responsibility to call
-  // PrepareForEvaluation before calling this method if necessary,
-  // i.e. iff the parameter values have been changed since the last
-  // call to evaluate / solve.'
+  // This means, if an EvaluationCallback is associated with the problem then it
+  // is the user's responsibility to call PrepareForEvaluation before calling
+  // this method if necessary, i.e. iff the parameter values have been changed
+  // since the last call to evaluate / solve.'
   //
-  // This is because, as the name implies, we assume that the
-  // parameter blocks did not change since the last time
-  // PrepareForEvaluation was called (via Solve, Evaluate or
-  // EvaluateResidualBlock).
+  // This is because, as the name implies, we assume that the parameter blocks
+  // did not change since the last time PrepareForEvaluation was called (via
+  // Solve, Evaluate or EvaluateResidualBlock).
   bool EvaluateResidualBlockAssumingParametersUnchanged(
       ResidualBlockId residual_block_id,
       bool apply_loss_function,
@@ -546,9 +537,13 @@
       double* residuals,
       double** jacobians) const;
 
+  // Returns reference to the options with which the Problem was constructed.
+  const Options& options() const;
+
+  // Returns pointer to Problem implementation
+  internal::ProblemImpl* mutable_impl();
+
  private:
-  friend class Solver;
-  friend class Covariance;
   std::unique_ptr<internal::ProblemImpl> impl_;
 };