From f9f893a56763935cc7dc42245fcc968b99a6a079 Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Wed, 20 Aug 2025 18:51:46 -0700
Subject: [PATCH 1/7] Got rid of topology use in RigidBody. Killed unused
 AddMobilizer() overload.

Still need to remove RigidBodyTopology, MobilizerTopology, and probably FrameTopology.

Watch out for cloning of new fields.
---
 .../rational/rational_forward_kinematics.cc   | 28 +++++---
 .../rational_forward_kinematics_internal.cc   | 35 +++++----
 ...ional_forward_kinematics_test_utilities.cc | 10 ++-
 multibody/topology/link_joint_graph_link.h    |  6 +-
 .../topology/test/spanning_forest_test.cc     | 11 ++-
 multibody/tree/mobilizer.h                    | 12 +++-
 multibody/tree/multibody_tree-inl.h           | 14 +---
 multibody/tree/multibody_tree.cc              | 51 +++++++------
 multibody/tree/multibody_tree.h               | 44 ------------
 multibody/tree/multibody_tree_topology.cc     | 13 ++--
 multibody/tree/multibody_tree_topology.h      |  5 --
 multibody/tree/rigid_body.h                   | 72 ++++++++++---------
 .../tree/test/multibody_tree_creation_test.cc | 15 +---
 13 files changed, 135 insertions(+), 181 deletions(-)

diff --git a/multibody/rational/rational_forward_kinematics.cc b/multibody/rational/rational_forward_kinematics.cc
index 672a0f6e5b09..dfcefd1f8175 100644
--- a/multibody/rational/rational_forward_kinematics.cc
+++ b/multibody/rational/rational_forward_kinematics.cc
@@ -232,20 +232,28 @@ RationalForwardKinematics::CalcChildBodyPoseAsMultilinearPolynomial(
   // X_F'M' = X_FM.inverse()
   // X_M'C' = X_PF.inverse()
   const internal::MultibodyTree<double>& tree = GetInternalTree(plant_);
-  const internal::RigidBodyTopology& parent_topology =
-      tree.get_topology().get_rigid_body_topology(parent);
-  const internal::RigidBodyTopology& child_topology =
-      tree.get_topology().get_rigid_body_topology(child);
+  const internal::SpanningForest& forest = tree.forest();
+
+  const internal::MobodIndex parent_mobod_index =
+      forest.link_by_index(parent).mobod_index();
+  const internal::SpanningForest::Mobod& parent_mobod =
+      forest.mobods(parent_mobod_index);
+
+  const internal::MobodIndex child_mobod_index =
+      forest.link_by_index(child).mobod_index();
+  const internal::SpanningForest::Mobod& child_mobod =
+      forest.mobods(child_mobod_index);
+
   internal::MobodIndex mobilizer_index;
   bool is_order_reversed{};
-  if (parent_topology.parent_body.is_valid() &&
-      parent_topology.parent_body == child) {
+  if (parent_mobod.inboard().is_valid() &&
+      parent_mobod.inboard() == child_mobod_index) {
     is_order_reversed = true;
-    mobilizer_index = parent_topology.inboard_mobilizer;
-  } else if (child_topology.parent_body.is_valid() &&
-             child_topology.parent_body == parent) {
+    mobilizer_index = parent_mobod_index;
+  } else if (child_mobod.inboard().is_valid() &&
+             child_mobod.inboard() == parent_mobod_index) {
     is_order_reversed = false;
-    mobilizer_index = child_topology.inboard_mobilizer;
+    mobilizer_index = child_mobod_index;
   } else {
     throw std::invalid_argument(fmt::format(
         "CalcChildBodyPoseAsMultilinearPolynomial: the pair of body indices "
diff --git a/multibody/rational/rational_forward_kinematics_internal.cc b/multibody/rational/rational_forward_kinematics_internal.cc
index 0c0fe6bcec14..72e97f7e765a 100644
--- a/multibody/rational/rational_forward_kinematics_internal.cc
+++ b/multibody/rational/rational_forward_kinematics_internal.cc
@@ -16,7 +16,8 @@ std::vector<BodyIndex> FindPath(const MultibodyPlant<double>& plant,
                                 BodyIndex start, BodyIndex end) {
   DRAKE_DEMAND(start.is_valid());
   DRAKE_DEMAND(end.is_valid());
-  const MultibodyTreeTopology& topology = GetInternalTree(plant).get_topology();
+  const MultibodyTree<double>& tree = GetInternalTree(plant);
+  const SpanningForest& forest = tree.forest();
 
   // Do a breadth first search in the tree. The `worklist` stores the nodes
   // ready for exploration; In the `ancestor` map, the values are the immediate
@@ -40,13 +41,21 @@ std::vector<BodyIndex> FindPath(const MultibodyPlant<double>& plant,
     if (current == end) {
       break;
     }
-    const RigidBodyTopology& current_node_topology =
-        topology.get_rigid_body_topology(current);
+    const LinkJointGraph::Link& current_link = forest.link_by_index(current);
+    const SpanningForest::Mobod& current_mobod =
+        forest.mobods(current_link.mobod_index());
     if (current != world_index()) {
-      const BodyIndex parent = current_node_topology.parent_body;
+      const SpanningForest::Mobod& parent_mobod =
+          forest.mobods(current_mobod.inboard());
+      const BodyIndex parent =
+          tree.forest().links(parent_mobod.link_ordinal()).index();
       visit_edge(current, parent);
     }
-    for (BodyIndex child : current_node_topology.child_bodies) {
+    for (const MobodIndex& child_mobod_index : current_mobod.outboards()) {
+      const SpanningForest::Mobod& child_mobod =
+          forest.mobods(child_mobod_index);
+      const BodyIndex child =
+          tree.forest().links(child_mobod.link_ordinal()).index();
       visit_edge(current, child);
     }
   }
@@ -71,20 +80,20 @@ std::vector<MobodIndex> FindMobilizersOnPath(
   std::vector<MobodIndex> mobilizers_on_path;
   mobilizers_on_path.reserve(path.size() - 1);
   const MultibodyTree<double>& tree = GetInternalTree(plant);
+  const SpanningForest& forest = tree.forest();
   for (int i = 0; i < static_cast<int>(path.size()) - 1; ++i) {
-    const RigidBodyTopology& rigid_body_topology =
-        tree.get_topology().get_rigid_body_topology(path[i]);
-    if (path[i] != world_index() &&
-        rigid_body_topology.parent_body == path[i + 1]) {
+    // Figure out which mobilizer connects path[i] with path[i+1].
+    const LinkJointGraph::Link& link_i = forest.link_by_index(path[i]);
+    const LinkJointGraph::Link& link_ip1 = forest.link_by_index(path[i + 1]);
+    const SpanningForest::Mobod& mobod_i = forest.mobods(link_i.mobod_index());
+    if (!mobod_i.is_world() && mobod_i.inboard() == link_ip1.mobod_index()) {
       // path[i] is the child of path[i+1] in MultibodyTreeTopology, they are
       // connected by path[i]'s inboard mobilizer.
-      mobilizers_on_path.push_back(rigid_body_topology.inboard_mobilizer);
+      mobilizers_on_path.push_back(link_i.mobod_index());
     } else {
       // path[i] is the parent of path[i+1] in MultibodyTreeTopology, they are
       // connected by path[i+1]'s inboard mobilizer.
-      mobilizers_on_path.push_back(tree.get_topology()
-                                       .get_rigid_body_topology(path[i + 1])
-                                       .inboard_mobilizer);
+      mobilizers_on_path.push_back(link_ip1.mobod_index());
     }
   }
   return mobilizers_on_path;
diff --git a/multibody/rational/test/rational_forward_kinematics_test_utilities.cc b/multibody/rational/test/rational_forward_kinematics_test_utilities.cc
index 250aa9e72162..0d96aa4a8b53 100644
--- a/multibody/rational/test/rational_forward_kinematics_test_utilities.cc
+++ b/multibody/rational/test/rational_forward_kinematics_test_utilities.cc
@@ -80,9 +80,8 @@ IiwaTest::IiwaTest()
   for (int i = 0; i < 8; ++i) {
     iiwa_link_[i] =
         iiwa_->GetBodyByName("iiwa_link_" + std::to_string(i)).index();
-    iiwa_joint_[i] = iiwa_tree_.get_topology()
-                         .get_rigid_body_topology(iiwa_link_[i])
-                         .inboard_mobilizer;
+    iiwa_joint_[i] =
+        iiwa_tree_.forest().link_by_index(iiwa_link_[i]).mobod_index();
   }
 }
 
@@ -93,9 +92,8 @@ FinalizedIiwaTest::FinalizedIiwaTest()
   for (int i = 0; i < 8; ++i) {
     iiwa_link_[i] =
         iiwa_->GetBodyByName("iiwa_link_" + std::to_string(i)).index();
-    iiwa_joint_[i] = iiwa_tree_.get_topology()
-                         .get_rigid_body_topology(iiwa_link_[i])
-                         .inboard_mobilizer;
+    iiwa_joint_[i] =
+        iiwa_tree_.forest().link_by_index(iiwa_link_[i]).mobod_index();
   }
 }
 
diff --git a/multibody/topology/link_joint_graph_link.h b/multibody/topology/link_joint_graph_link.h
index 0155b210240e..b2aeed0cf028 100644
--- a/multibody/topology/link_joint_graph_link.h
+++ b/multibody/topology/link_joint_graph_link.h
@@ -113,9 +113,9 @@ class LinkJointGraph::Link {
   MobodIndex mobod_index() const { return mobod_; }
 
   /* Returns the Joint that was used to associate this %Link with its
-  mobilized body. If this %Link is part of a LinkComposite, returns the Joint
-  that connects this %Link to the Composite, not necessarily the Joint that is
-  modeled by the Mobod returned by mobod_index(). */
+  mobilized body. If this %Link is part of a LinkComposite, returns the weld
+  Joint that connects this %Link to the Composite, not necessarily the Joint
+  that is modeled by the Mobod returned by mobod_index(). */
   JointIndex inboard_joint_index() const { return joint_; }
 
   /* Returns the index of the LinkComposite this %Link is part of, if any.
diff --git a/multibody/topology/test/spanning_forest_test.cc b/multibody/topology/test/spanning_forest_test.cc
index aa0112770e3e..88337407a6cf 100644
--- a/multibody/topology/test/spanning_forest_test.cc
+++ b/multibody/topology/test/spanning_forest_test.cc
@@ -843,7 +843,7 @@ GTEST_TEST(SpanningForest, SerialChainAndMore) {
   EXPECT_NO_THROW(forest.SanityCheckForest());
 
   // The graph shouldn't change from SpanningForest 1, but the forest will.
-  EXPECT_EQ(ssize(graph.joints()) - graph.num_user_joints(), 4);
+  EXPECT_EQ(graph.num_joints() - graph.num_user_joints(), 4);
   EXPECT_EQ(graph.link_composites(LinkCompositeIndex(0)).links,
             link_composites0);
   EXPECT_EQ(graph.link_composites(LinkCompositeIndex(1)).links,
@@ -984,7 +984,7 @@ non-composite links are {3}, {9}, {2}, {11}, and {14*}.
 
 Forest building should start with Link {5} since that is the only direct
 connection to World in the input ({3} and {9} get connected later). If we're
-giving every Link its own mobilizer (rather than making composites from
+giving every Link its own mobilizer (rather than merging composites from
 welded-together ones) we expect this forest of 3 trees and 17 Mobods:
 
       level 6                 12{16*} ....              ... loop constraint
@@ -1011,7 +1011,7 @@ though each Link has its own Mobod. Those are:
 The corresponding Mobods are in WeldedMobod groups:
 [0 1 2 6] [8 9 14 15] [10 11 13 12]
 
-Remodeling with composite link merging turned on should immediately create
+Remodeling with link composite merging turned on should immediately create
 composite {0 5 7 12} on mobod 0, then see outboard links {2} and {11} as new
 base bodies and grow those two trees, discovering a loop at joint 8. As before,
 Link {11} gets split with a shadow link {14} for joint 8. Then it
@@ -1470,8 +1470,7 @@ sufficient to prevent both massless Links from being terminal.
 
   {1}           {2}      massless       1{1}            3{2}
 
-   🡑 0           🡑 1                     🡑 T0            🡑 T1     T
-= tree
+   🡑 0           🡑 1                     🡑 T0            🡑 T1     T = tree
                            ---->
  ........{0}........                     ........ 0 ........
         World                                   World
@@ -1570,7 +1569,7 @@ The expected as-modeled graph and spanning forest model are:
 Notes:
   - Joint numbering determines branch ordering in the tree so the
     middle branch gets modeled last.
-  - Model Joint 8 is the added floating joint to World.
+  - Ephemeral Joint 8 is the added floating joint to World.
   - Link {8} is {6s} (shadow 1 of Link {6}); {9} is {6ss} (shadow 2).
   - Loop constraints (shown as . .) are always ordered so that the constraint's
     "parent" is the primary link and "child" is the shadow link. Thus the order
diff --git a/multibody/tree/mobilizer.h b/multibody/tree/mobilizer.h
index c502a2f0c729..351ea3c54157 100644
--- a/multibody/tree/mobilizer.h
+++ b/multibody/tree/mobilizer.h
@@ -3,7 +3,6 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "drake/common/autodiff.h"
 #include "drake/common/drake_assert.h"
@@ -357,6 +356,10 @@ class Mobilizer : public MultibodyElement<T> {
   // and any spatial velocity to machine precision.
   bool has_six_dofs() const { return num_velocities() == 6; }
 
+  bool is_floating_base_mobilizer() const {
+    return is_floating_base_mobilizer_;
+  }
+
   // Returns `true` if `this` uses a quaternion parameterization of rotations.
   virtual bool has_quaternion_dofs() const { return false; }
 
@@ -798,6 +801,10 @@ class Mobilizer : public MultibodyElement<T> {
         is_locked_parameter_index_);
   }
 
+  void set_is_floating_base_mobilizer(bool is_floating) {
+    is_floating_base_mobilizer_ = is_floating;
+  }
+
  protected:
   // NVI to CalcNMatrix(). Implementations can safely assume that N is not the
   // nullptr and that N has the proper size.
@@ -907,6 +914,9 @@ class Mobilizer : public MultibodyElement<T> {
   // System parameter index for `this` mobilizer's lock state stored in a
   // context.
   systems::AbstractParameterIndex is_locked_parameter_index_;
+
+  // Set according to some policy that defines a "floating base body".
+  bool is_floating_base_mobilizer_{false};
 };
 
 }  // namespace internal
diff --git a/multibody/tree/multibody_tree-inl.h b/multibody/tree/multibody_tree-inl.h
index b7b67919ea2a..6a8025f04217 100644
--- a/multibody/tree/multibody_tree-inl.h
+++ b/multibody/tree/multibody_tree-inl.h
@@ -1,13 +1,10 @@
 #pragma once
 
 #include <algorithm>
-#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
-#include <tuple>
 #include <type_traits>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -130,7 +127,7 @@ const MobilizerType<T>& MultibodyTree<T>::AddMobilizer(
 
   const BodyIndex outboard_body_index = mobilizer->outboard_body().index();
   topology_.get_mutable_rigid_body_topology(outboard_body_index)
-      .is_floating_base = is_floating_base_body;
+      .is_floating_base = mobilizer->is_floating_base_mobilizer();
   topology_.get_mutable_rigid_body_topology(outboard_body_index)
       .has_quaternion_dofs = mobilizer->has_quaternion_dofs();
 
@@ -139,15 +136,6 @@ const MobilizerType<T>& MultibodyTree<T>::AddMobilizer(
   return *raw_mobilizer_ptr;
 }
 
-template <typename T>
-template <template <typename Scalar> class MobilizerType, typename... Args>
-const MobilizerType<T>& MultibodyTree<T>::AddMobilizer(Args&&... args) {
-  static_assert(std::is_base_of_v<Mobilizer<T>, MobilizerType<T>>,
-                "MobilizerType must be a sub-class of Mobilizer<T>.");
-  return AddMobilizer(
-      std::make_unique<MobilizerType<T>>(std::forward<Args>(args)...));
-}
-
 template <typename T>
 template <template <typename Scalar> class ForceElementType>
 const ForceElementType<T>& MultibodyTree<T>::AddForceElement(
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index 4265e1b53b70..2589c1ac3fc4 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -792,6 +792,8 @@ void MultibodyTree<T>::CreateJointImplementations() {
     Mobilizer<T>* mobilizer = owned_mobilizer.get();
     mobilizer->set_model_instance(joint.model_instance());
     mobilizer->set_is_ephemeral(joint.is_ephemeral());
+    // TODO(sherm1) Merge issue: do we need this?
+    // mobilizer->set_is_floating_base_mobilizer(is_floating_base_mobilizer);
     AddMobilizer(std::move(owned_mobilizer));  // ownership->tree
     DRAKE_DEMAND(mobilizer->index() == mobod.index());
     // Record the joint to mobilizer map.
@@ -804,10 +806,8 @@ const Mobilizer<T>& MultibodyTree<T>::GetFreeBodyMobilizerOrThrow(
     const RigidBody<T>& body) const {
   DRAKE_MBT_THROW_IF_NOT_FINALIZED();
   DRAKE_DEMAND(body.index() != world_index());
-  const RigidBodyTopology& rigid_body_topology =
-      get_topology().get_rigid_body_topology(body.index());
-  const Mobilizer<T>& mobilizer =
-      get_mobilizer(rigid_body_topology.inboard_mobilizer);
+  const LinkJointGraph::Link& link = forest().link_by_index(body.index());
+  const Mobilizer<T>& mobilizer = get_mobilizer(link.mobod_index());
   if (!mobilizer.has_six_dofs()) {
     throw std::logic_error("Body '" + body.name() + "' is not a free body.");
   }
@@ -824,9 +824,8 @@ const Frame<T>& MultibodyTree<T>::AddOrGetJointFrame(
     return this->AddFrame<FixedOffsetFrame>(
         fmt::format("{}_{}", joint_name, frame_suffix), body.body_frame(),
         *X_BF, joint_instance);
-  } else {
-    return body.body_frame();
   }
+  return body.body_frame();
 }
 
 template <typename T>
@@ -3157,8 +3156,8 @@ void MultibodyTree<T>::CalcJacobianAngularAndOrTranslationalVelocityInWorld(
   // bodies, w_wF = Js_w_WF * v = 0  and  v_WFpi = Js_v_WFpi * v = 0.
   if (body_F.index() == world_index()) return;
 
-  // Form kinematic path from body_F to the world.
-  std::vector<MobodIndex> path_to_world =
+  // Form kinematic path from World to body_F.
+  std::vector<MobodIndex> path_from_world =
       forest().FindPathFromWorld(body_F.mobod_index());
 
   const PositionKinematicsCache<T>& pc = EvalPositionKinematics(context);
@@ -3171,8 +3170,8 @@ void MultibodyTree<T>::CalcJacobianAngularAndOrTranslationalVelocityInWorld(
   // For all bodies in the kinematic path from the world to body_F, compute
   // each node's contribution to the Jacobians.
   // Skip the world (level = 0).
-  for (size_t level = 1; level < path_to_world.size(); ++level) {
-    const MobodIndex mobod_index = path_to_world[level];
+  for (size_t level = 1; level < path_from_world.size(); ++level) {
+    const MobodIndex mobod_index = path_from_world[level];
     const BodyNode<T>& node = *body_nodes_[mobod_index];
     const SpanningForest::Mobod& mobod = node.mobod();
     const int start_index_in_v = mobod.v_start();
@@ -4200,6 +4199,8 @@ Mobilizer<T>* MultibodyTree<T>::CloneMobilizerAndAdd(
   auto mobilizer_clone = mobilizer.CloneToScalar(*this);
   mobilizer_clone->set_parent_tree(this, mobilizer_index);
   mobilizer_clone->set_model_instance(mobilizer.model_instance());
+  mobilizer_clone->set_is_floating_base_mobilizer(
+      mobilizer.is_floating_base_mobilizer());
   Mobilizer<T>* raw_mobilizer_clone_ptr = mobilizer_clone.get();
   mobilizers_.push_back(std::move(mobilizer_clone));
   return raw_mobilizer_clone_ptr;
@@ -4241,20 +4242,24 @@ template <typename T>
 std::optional<BodyIndex> MultibodyTree<T>::MaybeGetUniqueBaseBodyIndex(
     ModelInstanceIndex model_instance) const {
   DRAKE_THROW_UNLESS(model_instances_.has_element(model_instance));
-  if (model_instance == world_model_instance()) {
-    return std::nullopt;
-  }
+  if (model_instance == world_model_instance()) return std::nullopt;
+
+  // We need only look at World's outboard mobods since those are the base
+  // bodies of each tree in the forest. Each of those mobods has an
+  // associated Link (the active link in case of composites). We're only
+  // interested in links in the given model instance, and there should be
+  // just one of those.
+  const SpanningForest::Mobod& world = forest().world_mobod();
   std::optional<BodyIndex> base_body_index{};
-  for (const RigidBody<T>* body : rigid_bodies_.elements()) {
-    if (body->model_instance() == model_instance &&
-        (topology_.get_rigid_body_topology(body->index()).parent_body ==
-         world_index())) {
-      if (base_body_index.has_value()) {
-        // More than one base body associated with this model.
-        return std::nullopt;
-      }
-      base_body_index = body->index();
-    }
+  for (const MobodIndex& base_mobod_index : world.outboards()) {
+    const SpanningForest::Mobod& base_mobod = forest().mobods(base_mobod_index);
+    DRAKE_DEMAND(base_mobod.level() == 1);
+    const LinkJointGraph::Link& active_link =
+        forest().links(base_mobod.link_ordinal());
+    if (active_link.model_instance() != model_instance) continue;
+    if (base_body_index.has_value())  // Not unique if already set.
+      return std::nullopt;
+    base_body_index = active_link.index();
   }
   return base_body_index;
 }
diff --git a/multibody/tree/multibody_tree.h b/multibody/tree/multibody_tree.h
index c83070d902d1..182d80af8ee5 100644
--- a/multibody/tree/multibody_tree.h
+++ b/multibody/tree/multibody_tree.h
@@ -290,46 +290,6 @@ class MultibodyTree {
   const MobilizerType<T>& AddMobilizer(
       std::unique_ptr<MobilizerType<T>> mobilizer);
 
-  // Constructs a new mobilizer with type `MobilizerType` with the given
-  // `args`, and adds it to `this` %MultibodyTree, which retains ownership.
-  // The `MobilizerType` will be specialized on the scalar type T of this
-  // %MultibodyTree.
-  //
-  // Example of usage:
-  // @code
-  //   MultibodyTree<T> model;
-  //   // ... Code to define inboard and outboard frames by calling
-  //   // MultibodyTree::AddFrame() ...
-  //   // Notice RevoluteMobilizer is a template an a scalar type.
-  //   const RevoluteMobilizer<T>& pin =
-  //     model.template AddMobilizer<RevoluteMobilizer>(
-  //       inboard_frame, outboard_frame,
-  //       Vector3d::UnitZ() /*revolute axis*/);
-  // @endcode
-  //
-  // Note that for dependent names _only_ you must use the template keyword
-  // (say for instance you have a MultibodyTree<T> member within your custom
-  // class).
-  //
-  // @throws std::exception if Finalize() was already called on `this` tree.
-  // @throws std::exception if the new mobilizer attempts to connect a
-  // frame with itself.
-  // @throws std::exception if attempting to connect two bodies with more
-  // than one mobilizer between them.
-  //
-  // @param[in] args The arguments needed to construct a valid Mobilizer of
-  //                 type `MobilizerType`. `MobilizerType` must provide a
-  //                 public constructor that takes these arguments.
-  // @returns A constant reference of type `MobilizerType` to the created
-  //          mobilizer. This reference which will remain valid for the
-  //          lifetime of `this` %MultibodyTree.
-  //
-  // @tparam MobilizerType A template for the type of Mobilizer to construct.
-  //                       The template will be specialized on the scalar type
-  //                       T of `this` %MultibodyTree.
-  template <template <typename Scalar> class MobilizerType, typename... Args>
-  const MobilizerType<T>& AddMobilizer(Args&&... args);
-
   // Creates and adds to `this` %MultibodyTree (which retains ownership) a new
   // `ForceElement` member with the specific type `ForceElementType`. The
   // arguments to this method `args` are forwarded to `ForceElementType`'s
@@ -2881,10 +2841,6 @@ class MultibodyTree {
   GetDefaultFloatingBaseBodyPoseAsQuaternionVec3Pair(
       const RigidBody<T>& body) const;
 
-  // TODO(amcastro-tri): In future PR's adding MBT computational methods, write
-  //  a method that verifies the state of the topology with a signature similar
-  //  to RoadGeometry::CheckHasRightSizeForModel().
-
   // These objects are defined via MultibodyPlant and are thus user-visible.
   const RigidBody<T>* world_rigid_body_{nullptr};
   // When we need to look up elements by name, we'll use an ElementCollection.
diff --git a/multibody/tree/multibody_tree_topology.cc b/multibody/tree/multibody_tree_topology.cc
index 57f7691ac51c..8a4f5da2c90c 100644
--- a/multibody/tree/multibody_tree_topology.cc
+++ b/multibody/tree/multibody_tree_topology.cc
@@ -43,7 +43,6 @@ bool RigidBodyTopology::operator==(const RigidBodyTopology& other) const {
     return false;
   if (parent_body.is_valid() != other.parent_body.is_valid()) return false;
   if (parent_body.is_valid() && parent_body != other.parent_body) return false;
-  if (child_bodies != other.child_bodies) return false;
   if (body_frame != other.body_frame) return false;
   if (level != other.level) return false;
   if (mobod_index != other.mobod_index) return false;
@@ -155,10 +154,6 @@ void MultibodyTreeTopology::add_mobilizer_topology(
   // Similarly, record inboard_body as the parent of outboard_body.
   rigid_body_topology_[outboard_body].parent_body = inboard_body;
 
-  // Records "child" rigid bodies for bookkeeping in the context of the tree
-  // structure of the multibody forest.
-  rigid_body_topology_[inboard_body].child_bodies.push_back(outboard_body);
-
   mobilizer_topology_.emplace_back(mobilizer_index, in_frame, out_frame,
                                    inboard_body, outboard_body, mobod);
 }
@@ -236,11 +231,11 @@ void MultibodyTreeTopology::FinalizeTopology(const LinkJointGraph& graph) {
 
   const SpanningForest& forest = graph.forest();
 
-  // Create a BodyNodeTopology corresponding to each Mobod in the forest,
+  // Create MobilizerTopology corresponding to each Mobod in the forest,
   // indexed identically. Note that Mobods are already in depth-first order so
-  // we can use the same numbering for BodyNodes. Also update RigidBodyTopology,
-  // though in the case where we combine welded-together rigid bodies only the
-  // "active" body of each Composite gets updated here.
+  // we can use the same numbering for Mobilizers. Also update
+  // RigidBodyTopology, though in the case where we combine welded-together
+  // rigid bodies only the "active" body of each Composite gets updated here.
   for (const auto& mobod : forest.mobods()) {
     const MobodIndex node_index(mobod.index());
     const BodyIndex rigid_body_index =
diff --git a/multibody/tree/multibody_tree_topology.h b/multibody/tree/multibody_tree_topology.h
index ca504818170b..61756d08c8e5 100644
--- a/multibody/tree/multibody_tree_topology.h
+++ b/multibody/tree/multibody_tree_topology.h
@@ -63,11 +63,6 @@ struct RigidBodyTopology {
   // of a Joint. This will remain "invalid" for World.
   BodyIndex parent_body{};
 
-  // Within the SpanningForest, the immediate outboard (or "child") RigidBodies
-  // to this body. Bodies appear in child_bodies in the order mobilizers were
-  // added to the model, with MultibodyTreeTopology::add_mobilizer_topology().
-  std::vector<BodyIndex> child_bodies;
-
   // Unique index to the frame associated with this RigidBody.
   FrameIndex body_frame{0};
 
diff --git a/multibody/tree/rigid_body.h b/multibody/tree/rigid_body.h
index 66bc4fe7f657..8ef24bea2f9b 100644
--- a/multibody/tree/rigid_body.h
+++ b/multibody/tree/rigid_body.h
@@ -2,7 +2,6 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "drake/common/default_scalars.h"
 #include "drake/common/drake_assert.h"
@@ -11,6 +10,7 @@
 #include "drake/common/unused.h"
 #include "drake/multibody/tree/acceleration_kinematics_cache.h"
 #include "drake/multibody/tree/frame.h"
+#include "drake/multibody/tree/mobilizer.h"
 #include "drake/multibody/tree/multibody_element.h"
 #include "drake/multibody/tree/multibody_forces.h"
 #include "drake/multibody/tree/multibody_tree_indexes.h"
@@ -253,10 +253,7 @@ class RigidBody : public MultibodyElement<T> {
           "Attempted to call Lock() on non-floating-base rigid body {}",
           name()));
     }
-    DRAKE_ASSERT(this->has_parent_tree());
-    this->get_parent_tree()
-        .get_mobilizer(topology_.inboard_mobilizer)
-        .Lock(context);
+    mobilizer().Lock(context);
   }
 
   /// For a floating base %RigidBody, unlock its inboard joint.
@@ -271,10 +268,7 @@ class RigidBody : public MultibodyElement<T> {
           "Attempted to call Unlock() on non-floating-base rigid body {}",
           name()));
     }
-    DRAKE_ASSERT(this->has_parent_tree());
-    this->get_parent_tree()
-        .get_mobilizer(topology_.inboard_mobilizer)
-        .Unlock(context);
+    mobilizer().Unlock(context);
   }
 
   /// Determines whether this %RigidBody is currently locked to its inboard
@@ -284,16 +278,14 @@ class RigidBody : public MultibodyElement<T> {
   bool is_locked(const systems::Context<T>& context) const {
     ThrowIfNotFinalized(__func__);
     DRAKE_ASSERT(this->has_parent_tree());
-    return this->get_parent_tree()
-        .get_mobilizer(topology_.inboard_mobilizer)
-        .is_locked(context);
+    return mobilizer().is_locked(context);
   }
 
   /// (Advanced) Returns the index of the mobilized body ("mobod") in the
   /// computational directed forest structure of the owning MultibodyTree to
   /// which this %RigidBody belongs. This serves as the BodyNode index and the
   /// index into all associated quantities.
-  internal::MobodIndex mobod_index() const { return topology_.mobod_index; }
+  internal::MobodIndex mobod_index() const { return mobilizer().index(); }
 
   /// (Advanced) Returns `true` if this body is a _floating base body_, meaning
   /// it had no explicit joint to a parent body so is mobilized by an
@@ -308,7 +300,7 @@ class RigidBody : public MultibodyElement<T> {
   /// @see MultibodyPlant::Finalize()
   bool is_floating_base_body() const {
     ThrowIfNotFinalized(__func__);
-    return topology_.is_floating_base;
+    return is_floating_base_body_;
   }
 
   DRAKE_DEPRECATED("2026-01-01", "Use is_floating_base_body() instead.")
@@ -323,7 +315,7 @@ class RigidBody : public MultibodyElement<T> {
   /// @see is_floating_base_body(), MultibodyPlant::Finalize()
   bool has_quaternion_dofs() const {
     ThrowIfNotFinalized(__func__);
-    return topology_.has_quaternion_dofs;
+    return mobilizer().has_quaternion_dofs();
   }
 
   /// (Advanced) For floating base bodies (see is_floating_base_body()),
@@ -341,7 +333,7 @@ class RigidBody : public MultibodyElement<T> {
   int floating_positions_start() const {
     ThrowIfNotFinalized(__func__);
     DRAKE_DEMAND(is_floating_base_body());
-    return topology_.floating_positions_start;
+    return mobilizer().position_start_in_q();
   }
 
   /// (Advanced) For floating base bodies (see is_floating_base_body()),
@@ -354,7 +346,7 @@ class RigidBody : public MultibodyElement<T> {
   int floating_velocities_start_in_v() const {
     ThrowIfNotFinalized(__func__);
     DRAKE_DEMAND(is_floating_base_body());
-    return topology_.floating_velocities_start_in_v;
+    return mobilizer().velocity_start_in_v();
   }
 
   /// Returns a string suffix (e.g. to be appended to the name()) to identify
@@ -372,10 +364,7 @@ class RigidBody : public MultibodyElement<T> {
     } else {
       DRAKE_DEMAND(0 <= position_index_in_body && position_index_in_body < 6);
     }
-    DRAKE_ASSERT(this->has_parent_tree());
-    return this->get_parent_tree()
-        .get_mobilizer(topology_.inboard_mobilizer)
-        .position_suffix(position_index_in_body);
+    return mobilizer().position_suffix(position_index_in_body);
   }
 
   /// Returns a string suffix (e.g. to be appended to the name()) to identify
@@ -389,9 +378,7 @@ class RigidBody : public MultibodyElement<T> {
     DRAKE_DEMAND(is_floating_base_body());
     DRAKE_DEMAND(0 <= velocity_index_in_body && velocity_index_in_body < 6);
     DRAKE_ASSERT(this->has_parent_tree());
-    return this->get_parent_tree()
-        .get_mobilizer(topology_.inboard_mobilizer)
-        .velocity_suffix(velocity_index_in_body);
+    return mobilizer().velocity_suffix(velocity_index_in_body);
   }
 
   /// Returns this %RigidBody's default mass, which is initially supplied at
@@ -759,13 +746,19 @@ class RigidBody : public MultibodyElement<T> {
   // selected set of private RigidBody methods.
   friend class internal::RigidBodyAttorney<T>;
 
-  // Implementation for MultibodyElement::DoSetTopology().
-  // At MultibodyTree::Finalize() time, each body retrieves its topology
-  // from the parent MultibodyTree.
-  void DoSetTopology(
-      const internal::MultibodyTreeTopology& tree_topology) final {
-    topology_ = tree_topology.get_rigid_body_topology(this->index());
-    body_frame_.SetTopology(tree_topology);
+  // Called near the end of Finalize().
+  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
+    DRAKE_DEMAND(mobilizer_ == nullptr);
+    const internal::MultibodyTree<T>& tree = this->get_parent_tree();
+    const internal::SpanningForest& forest = tree.forest();
+    const internal::LinkJointGraph::Link& link = forest.link_by_index(index());
+    mobilizer_ = &tree.get_mobilizer(link.mobod_index());
+
+    // Is this RigidBody the active link on its Mobod?
+    const bool is_active_link =
+        link.ordinal() == forest.mobods(link.mobod_index()).link_ordinal();
+    is_floating_base_body_ =
+        is_active_link && mobilizer_->is_floating_base_mobilizer();
   }
 
   // Implementation for MultibodyElement::DoDeclareParameters().
@@ -847,6 +840,11 @@ class RigidBody : public MultibodyElement<T> {
   // RigidBodyAttorney.
   RigidBodyFrame<T>& get_mutable_body_frame() { return body_frame_; }
 
+  const internal::Mobilizer<T>& mobilizer() const {
+    DRAKE_ASSERT(mobilizer_ != nullptr);
+    return *mobilizer_;
+  }
+
   // A string identifying the body in its model.
   // Within a MultibodyPlant model instance this string is guaranteed to be
   // unique by MultibodyPlant's API.
@@ -855,15 +853,21 @@ class RigidBody : public MultibodyElement<T> {
   // Body frame associated with this body.
   RigidBodyFrame<T> body_frame_;
 
-  // The internal bookkeeping topology struct used by MultibodyTree.
-  internal::RigidBodyTopology topology_;
-
   // Spatial inertia about the body frame origin Bo, expressed in B.
   SpatialInertia<double> default_spatial_inertia_;
 
   // System parameter index for this bodies SpatialInertia stored in a
   // context.
   systems::NumericParameterIndex spatial_inertia_parameter_index_;
+
+  // Below here, members are set at Finalize() via SetTopology().
+
+  // The mobilizer of the Mobod that this body follows.
+  const internal::Mobilizer<T>* mobilizer_{};
+
+  // True if the mobilizer is a floating base mobilizer and this body is the
+  // active link of the mobilized composite.
+  bool is_floating_base_body_{false};
 };
 
 /// (Compatibility) Prefer RigidBody to Body, however this dispreferred alias
diff --git a/multibody/tree/test/multibody_tree_creation_test.cc b/multibody/tree/test/multibody_tree_creation_test.cc
index 216a21df39ad..1d907510eae7 100644
--- a/multibody/tree/test/multibody_tree_creation_test.cc
+++ b/multibody/tree/test/multibody_tree_creation_test.cc
@@ -377,24 +377,11 @@ class TreeTopologyTests : public ::testing::Test {
                                             LinkIndex(3), LinkIndex(8)};
     const set<LinkIndex> expected_level3 = {LinkIndex(6)};
 
-    std::vector<std::set<BodyIndex>> topo_levels(topology.num_rigid_bodies());
-    for (BodyIndex index(0); index < topology.num_rigid_bodies(); ++index) {
-      const RigidBodyTopology& rigid_body_topology =
-          topology.get_rigid_body_topology(index);
-      topo_levels[rigid_body_topology.level].insert(index);
-    }
     // Comparison of sets. The order of the elements is not important.
-    EXPECT_EQ(topo_levels[0], expected_level0);
-    EXPECT_EQ(topo_levels[1], expected_level1);
-    EXPECT_EQ(topo_levels[2], expected_level2);
-    EXPECT_EQ(topo_levels[3], expected_level3);
-
-    // Repeat for the forest.
     std::vector<std::set<LinkIndex>> levels(topology.num_rigid_bodies());
     for (const LinkJointGraph::Link& link : forest.links()) {
-      const LinkIndex link_index = link.index();
       const int level = forest.mobods(link.mobod_index()).level();
-      levels[level].insert(link_index);
+      levels[level].insert(link.index());
     }
     EXPECT_EQ(levels[0], expected_level0);
     EXPECT_EQ(levels[1], expected_level1);

From 9a7812217b72eadeb8bcca506751d98ef09ebb15 Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Wed, 24 Sep 2025 19:06:51 -0700
Subject: [PATCH 2/7] Nuke RigidBodyTopology.

Still need to get rid of MobilizerTopology altogether.
---
 multibody/tree/multibody_tree-inl.h           |  14 +--
 multibody/tree/multibody_tree.cc              |  12 +-
 multibody/tree/multibody_tree_topology.cc     |  93 ---------------
 multibody/tree/multibody_tree_topology.h      | 108 +-----------------
 .../tree/test/multibody_tree_creation_test.cc |   3 +-
 5 files changed, 15 insertions(+), 215 deletions(-)

diff --git a/multibody/tree/multibody_tree-inl.h b/multibody/tree/multibody_tree-inl.h
index 6a8025f04217..400354ac8671 100644
--- a/multibody/tree/multibody_tree-inl.h
+++ b/multibody/tree/multibody_tree-inl.h
@@ -119,18 +119,6 @@ const MobilizerType<T>& MultibodyTree<T>::AddMobilizer(
 
   mobilizer->set_parent_tree(this, mobilizer->mobod().index());
 
-  // Mark floating base bodies as needed. Note the strict definition:
-  // (1) the inboard joint must have six degrees of freedom, and
-  // (2) that joint must be ephemeral (added automatically).
-  bool is_floating_base_body =
-      mobilizer->has_six_dofs() && mobilizer->is_ephemeral();
-
-  const BodyIndex outboard_body_index = mobilizer->outboard_body().index();
-  topology_.get_mutable_rigid_body_topology(outboard_body_index)
-      .is_floating_base = mobilizer->is_floating_base_mobilizer();
-  topology_.get_mutable_rigid_body_topology(outboard_body_index)
-      .has_quaternion_dofs = mobilizer->has_quaternion_dofs();
-
   MobilizerType<T>* raw_mobilizer_ptr = mobilizer.get();
   mobilizers_.push_back(std::move(mobilizer));
   return *raw_mobilizer_ptr;
@@ -428,7 +416,7 @@ MultibodyTree<T>::get_mutable_positions_and_velocities(
 // Must be implemented carefully to avoid invalidating more cache entries than
 // are necessary.
 // TODO(sherm1) Currently we can only get q and v together so have no way to
-// invalidate just q-dependent or v-dependent cache entries.
+//  invalidate just q-dependent or v-dependent cache entries.
 template <typename T>
 Eigen::VectorBlock<VectorX<T>> MultibodyTree<T>::GetMutablePositions(
     systems::Context<T>* context) const {
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index 2589c1ac3fc4..16531c71937a 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -560,7 +560,7 @@ const RigidBody<T>& MultibodyTree<T>::AddRigidBodyImpl(
 
   const BodyIndex body_index(num_bodies());
   const FrameIndex body_frame_index(num_frames());
-  topology_.add_rigid_body_topology(body_index, body_frame_index);
+  topology_.add_frame_topology(body_frame_index, body_index);
 
   if (body_index == 0) {
     // We're adding the first RigidBody -- must be World!
@@ -792,8 +792,14 @@ void MultibodyTree<T>::CreateJointImplementations() {
     Mobilizer<T>* mobilizer = owned_mobilizer.get();
     mobilizer->set_model_instance(joint.model_instance());
     mobilizer->set_is_ephemeral(joint.is_ephemeral());
-    // TODO(sherm1) Merge issue: do we need this?
-    // mobilizer->set_is_floating_base_mobilizer(is_floating_base_mobilizer);
+
+    // Mark floating base bodies as needed. Note the strict definition:
+    // (1) the inboard joint must have six degrees of freedom, and
+    // (2) that joint must be ephemeral (added automatically).
+    bool is_floating_base_mobilizer =
+        mobilizer->has_six_dofs() && mobilizer->is_ephemeral();
+    mobilizer->set_is_floating_base_mobilizer(is_floating_base_mobilizer);
+
     AddMobilizer(std::move(owned_mobilizer));  // ownership->tree
     DRAKE_DEMAND(mobilizer->index() == mobod.index());
     // Record the joint to mobilizer map.
diff --git a/multibody/tree/multibody_tree_topology.cc b/multibody/tree/multibody_tree_topology.cc
index 8a4f5da2c90c..0d7bd3268576 100644
--- a/multibody/tree/multibody_tree_topology.cc
+++ b/multibody/tree/multibody_tree_topology.cc
@@ -10,7 +10,6 @@ bool MultibodyTreeTopology::operator==(
   if (forest_height_ != other.forest_height_) return false;
 
   if (frame_topology_ != other.frame_topology_) return false;
-  if (rigid_body_topology_ != other.rigid_body_topology_) return false;
   if (mobilizer_topology_ != other.mobilizer_topology_) return false;
   if (joint_actuator_topology_ != other.joint_actuator_topology_) return false;
 
@@ -34,26 +33,6 @@ bool MultibodyTreeTopology::operator==(
                     other.rigid_body_to_tree_index_.end());
 }
 
-bool RigidBodyTopology::operator==(const RigidBodyTopology& other) const {
-  if (index != other.index) return false;
-  if (inboard_mobilizer.is_valid() != other.inboard_mobilizer.is_valid())
-    return false;
-  if (inboard_mobilizer.is_valid() &&
-      inboard_mobilizer != other.inboard_mobilizer)
-    return false;
-  if (parent_body.is_valid() != other.parent_body.is_valid()) return false;
-  if (parent_body.is_valid() && parent_body != other.parent_body) return false;
-  if (body_frame != other.body_frame) return false;
-  if (level != other.level) return false;
-  if (mobod_index != other.mobod_index) return false;
-  if (is_floating_base != other.is_floating_base) return false;
-  if (has_quaternion_dofs != other.has_quaternion_dofs) return false;
-  if (floating_positions_start != other.floating_positions_start) return false;
-  if (floating_velocities_start_in_v != other.floating_velocities_start_in_v)
-    return false;
-  return true;
-}
-
 MultibodyTreeTopology::~MultibodyTreeTopology() = default;
 
 const JointActuatorTopology& MultibodyTreeTopology::get_joint_actuator_topology(
@@ -63,20 +42,6 @@ const JointActuatorTopology& MultibodyTreeTopology::get_joint_actuator_topology(
   return *joint_actuator_topology_[index];
 }
 
-void MultibodyTreeTopology::add_rigid_body_topology(
-    BodyIndex body_index, FrameIndex body_frame_index) {
-  if (is_valid()) {
-    throw std::logic_error(
-        "This MultibodyTreeTopology is finalized already. "
-        "Therefore adding more rigid bodies is not allowed. "
-        "See documentation for Finalize() for details.");
-  }
-  DRAKE_DEMAND(body_index == num_rigid_bodies());
-  DRAKE_DEMAND(body_frame_index == num_frames());
-  add_frame_topology(body_frame_index, body_index);
-  rigid_body_topology_.emplace_back(body_index, body_frame_index);
-}
-
 void MultibodyTreeTopology::add_frame_topology(FrameIndex frame_index,
                                                BodyIndex body_index) {
   if (is_valid()) {
@@ -127,32 +92,6 @@ void MultibodyTreeTopology::add_mobilizer_topology(
         "More than one mobilizer between two bodies is not allowed.",
         inboard_body, outboard_body));
   }
-  // Checks for graph loops. Each body can have only one inboard mobilizer.
-  if (rigid_body_topology_[outboard_body].inboard_mobilizer.is_valid()) {
-    throw std::runtime_error(
-        "When creating a model, an attempt was made to add two inboard "
-        "joints to the same rigid body; this is not allowed. One possible "
-        "cause might be attempting to weld a robot to World somewhere other "
-        "than its base rigid body; see Drake issue #17429 for discussion and "
-        "work-arounds, e.g., reversing some joint parent/child directions. "
-        "Another possible cause might be attempting to form a kinematic "
-        "loop using joints; to create a loop, consider using a "
-        "LinearBushingRollPitchYaw instead of a joint.");
-  }
-
-  // The checks above guarantee that it is the first time we add an inboard
-  // mobilizer to `outboard_body`. The DRAKE_DEMANDs below double check our
-  // implementation. RigidBodyTopology::inboard_mobilizer and
-  // RigidBodyTopology::parent_body are both set within this method right
-  // after these checks.
-  DRAKE_DEMAND(
-      !rigid_body_topology_[outboard_body].inboard_mobilizer.is_valid());
-  DRAKE_DEMAND(!rigid_body_topology_[outboard_body].parent_body.is_valid());
-
-  // Make note of the inboard mobilizer for the outboard body.
-  rigid_body_topology_[outboard_body].inboard_mobilizer = mobilizer_index;
-  // Similarly, record inboard_body as the parent of outboard_body.
-  rigid_body_topology_[outboard_body].parent_body = inboard_body;
 
   mobilizer_topology_.emplace_back(mobilizer_index, in_frame, out_frame,
                                    inboard_body, outboard_body, mobod);
@@ -171,7 +110,6 @@ void MultibodyTreeTopology::add_world_mobilizer_topology(
   mobilizer_topology_.emplace_back(MobodIndex(0), world_body_frame,
                                    world_body_frame, world_body_index,
                                    world_body_index, world_mobod);
-  rigid_body_topology_[world_body_index].inboard_mobilizer = MobodIndex(0);
 }
 
 void MultibodyTreeTopology::add_joint_actuator_topology(
@@ -231,41 +169,10 @@ void MultibodyTreeTopology::FinalizeTopology(const LinkJointGraph& graph) {
 
   const SpanningForest& forest = graph.forest();
 
-  // Create MobilizerTopology corresponding to each Mobod in the forest,
-  // indexed identically. Note that Mobods are already in depth-first order so
-  // we can use the same numbering for Mobilizers. Also update
-  // RigidBodyTopology, though in the case where we combine welded-together
-  // rigid bodies only the "active" body of each Composite gets updated here.
-  for (const auto& mobod : forest.mobods()) {
-    const MobodIndex node_index(mobod.index());
-    const BodyIndex rigid_body_index =
-        graph.links(mobod.link_ordinal()).index();
-    RigidBodyTopology& current_body = rigid_body_topology_[rigid_body_index];
-    current_body.mobod_index = node_index;
-    current_body.level = mobod.level();
-    const MobodIndex mobilizer_index = current_body.inboard_mobilizer;
-    DRAKE_DEMAND(mobilizer_index == node_index);
-    const MobilizerTopology& mobilizer = mobilizer_topology_[mobilizer_index];
-    DRAKE_DEMAND(mobilizer.index == node_index);
-  }
-
   num_positions_ = forest.num_positions();
   num_velocities_ = forest.num_velocities();
   num_states_ = num_positions_ + num_velocities_;
 
-  // Update position/velocity indexes for free rigid bodies so that they are
-  // easily accessible.
-  for (RigidBodyTopology& rigid_body_topology : rigid_body_topology_) {
-    if (rigid_body_topology.is_floating_base) {
-      DRAKE_DEMAND(rigid_body_topology.inboard_mobilizer.is_valid());
-      const MobilizerTopology& mobilizer =
-          get_mobilizer_topology(rigid_body_topology.inboard_mobilizer);
-      rigid_body_topology.floating_positions_start = mobilizer.positions_start;
-      rigid_body_topology.floating_velocities_start_in_v =
-          mobilizer.velocities_start_in_v;
-    }
-  }
-
   ExtractForestInfo(graph);
 
   // We are done with a successful Finalize() and we mark it as so.
diff --git a/multibody/tree/multibody_tree_topology.h b/multibody/tree/multibody_tree_topology.h
index 61756d08c8e5..f86515cf544d 100644
--- a/multibody/tree/multibody_tree_topology.h
+++ b/multibody/tree/multibody_tree_topology.h
@@ -1,23 +1,8 @@
 #pragma once
 
 /// @file
-/// This file defines the topological structures which represent the logical
-/// connectivities between multibody tree elements. For instance, the
-/// RigidBodyTopology for a RigidBody will contain the topological information
-/// specifying its inboard (or parent) RigidBody in the forest model, and its
-/// outboard (or children) rigid bodies, and the level or depth in the forest.
-/// All of this information is independent of the particular scalar type T the
-/// MultibodyTree and its components are specialized with. All of the data
-/// structures defined in this file are meant to be the minimal
-/// representation that can store this information. These data structures are
-/// used in the following ways:
-///
-/// - To aid the process of cloning or transmogrifying multibody tree
-///   components without having to create maps between the "original" and
-///   "cloned" objects.
-/// - Each topological Multibody element has a copy (acquired at
-///   MultibodyTree::Finalize() stage) of its topology which serves as a
-///   key into the Context for that element's state.
+/// This file is unnecessarily duplicative of multibody/topology and is
+/// being removed.
 
 #include <optional>
 #include <vector>
@@ -31,62 +16,6 @@ namespace drake {
 namespace multibody {
 namespace internal {
 
-// TODO(sherm1) Eliminate RigidBodyTopology altogether in favor of direct
-//  access to the SpanningForest, which contains the same information.
-
-// Store the topological information associated with a RigidBody.
-struct RigidBodyTopology {
-  DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(RigidBodyTopology);
-
-  // Default construction to invalid configuration.
-  RigidBodyTopology() {}
-
-  // Constructs for RigidBody with index `body_index` and corresponding
-  // RigidBodyFrame with index `frame_index`.
-  RigidBodyTopology(BodyIndex body_index, FrameIndex frame_index)
-      : index(body_index), body_frame(frame_index) {}
-
-  // Returns `true` if all members of `this` topology are exactly equal to the
-  // members of `other`.
-  bool operator==(const RigidBodyTopology& other) const;
-
-  // Unique index in the MultibodyPlant.
-  BodyIndex index{0};
-
-  // Index to the one and only inboard mobilizer a RigidBody can have.
-  MobodIndex inboard_mobilizer{};
-
-  // Within the SpanningForest, the RigidBody immediately inboard of this body;
-  // That is, the body at the other side of the inboard_mobilizer at a level
-  // one lower (closer to World) in the Forest. We're calling this "parent"
-  // here (in the tree sense) but don't confuse it with the parent RigidBody
-  // of a Joint. This will remain "invalid" for World.
-  BodyIndex parent_body{};
-
-  // Unique index to the frame associated with this RigidBody.
-  FrameIndex body_frame{0};
-
-  // Depth level in the SpanningForest, level = 0 for World.
-  int level{-1};
-
-  // Index to the mobilized body (BodyNode) modeling this RigidBody in the
-  // SpanningForest.
-  MobodIndex mobod_index;
-
-  // `true` if this topology corresponds to a floating base body, meaning
-  // it has an ephemeral (automatically added at Finalize()) 6dof mobilizer.
-  bool is_floating_base{false};
-
-  // `true` if this topology corresponds to a free body with rotations
-  // parametrized by a quaternion.
-  bool has_quaternion_dofs{false};
-
-  // For a floating base body only, these are indices into the multibody
-  // state for its ephemeral 6dof joint's coordinates.
-  int floating_positions_start{-1};
-  int floating_velocities_start_in_v{-1};
-};
-
 // Data structure to store the topological information associated with a Frame.
 struct FrameTopology {
   DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(FrameTopology);
@@ -206,9 +135,7 @@ class MultibodyTreeTopology {
  public:
   DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(MultibodyTreeTopology);
 
-  // Default constructor creates an empty, invalid topology. The minimum valid
-  // topology for a MultibodyPlant contains at least the
-  // RigidBodyTopology for World.
+  // Default constructor creates an empty, invalid topology.
   MultibodyTreeTopology() {}
 
   ~MultibodyTreeTopology();
@@ -217,11 +144,6 @@ class MultibodyTreeTopology {
   // members of `other`.
   bool operator==(const MultibodyTreeTopology& other) const;
 
-  // Returns the number of RigidBody elements in the MultibodyPlant. This
-  // includes the World RigidBody and therefore the minimum number of rigid
-  // bodies after MultibodyTree::Finalize() will always be one, not zero.
-  int num_rigid_bodies() const { return ssize(rigid_body_topology_); }
-
   // Returns the number of physical frames in the multibody tree.
   int num_frames() const { return ssize(frame_topology_); }
 
@@ -247,19 +169,6 @@ class MultibodyTreeTopology {
     return frame_topology_[index];
   }
 
-  // Returns a constant reference to the corresponding RigidBodyTopology given a
-  // BodyIndex.
-  const RigidBodyTopology& get_rigid_body_topology(BodyIndex index) const {
-    DRAKE_ASSERT(index < num_rigid_bodies());
-    return rigid_body_topology_[index];
-  }
-
-  // Mutable version of get_rigid_body().
-  RigidBodyTopology& get_mutable_rigid_body_topology(BodyIndex index) {
-    DRAKE_ASSERT(index < num_rigid_bodies());
-    return rigid_body_topology_[index];
-  }
-
   // Returns a constant reference to the corresponding MobilizerTopology given a
   // MobodIndex.
   const MobilizerTopology& get_mobilizer_topology(MobodIndex index) const {
@@ -304,7 +213,7 @@ class MultibodyTreeTopology {
   // TreeIndex::is_valid().
   // @pre Index b is valid and b < num_rigid_bodies().
   TreeIndex body_to_tree_index(BodyIndex b) const {
-    DRAKE_ASSERT(b < num_rigid_bodies());
+    DRAKE_ASSERT(b < ssize(rigid_body_to_tree_index_));
     return rigid_body_to_tree_index_[b];
   }
 
@@ -323,14 +232,6 @@ class MultibodyTreeTopology {
     return num_tree_velocities(tree_index) > 0;
   }
 
-  // Creates and adds a new RigidBodyTopology to this MultibodyTreeTopology
-  // using the indicated BodyIndex and FrameIndex values.
-  //
-  // @throws std::exception if FinalizeTopology() was already called on `this`
-  // topology.
-  // @pre the given indexes are the ones for the next available slots
-  void add_rigid_body_topology(BodyIndex, FrameIndex);
-
   // Creates and adds a new FrameTopology, associated with the given
   // BodyIndex, to this MultibodyTreeTopology.
   //
@@ -433,7 +334,6 @@ class MultibodyTreeTopology {
 
   // Topological elements:
   std::vector<FrameTopology> frame_topology_;
-  std::vector<RigidBodyTopology> rigid_body_topology_;
   std::vector<MobilizerTopology> mobilizer_topology_;
   std::vector<std::optional<JointActuatorTopology>> joint_actuator_topology_;
 
diff --git a/multibody/tree/test/multibody_tree_creation_test.cc b/multibody/tree/test/multibody_tree_creation_test.cc
index 1d907510eae7..541679ecacdb 100644
--- a/multibody/tree/test/multibody_tree_creation_test.cc
+++ b/multibody/tree/test/multibody_tree_creation_test.cc
@@ -358,7 +358,6 @@ class TreeTopologyTests : public ::testing::Test {
                              const SpanningForest& forest) {
     const int kNumRigidBodies = 10;
 
-    EXPECT_EQ(topology.num_rigid_bodies(), kNumRigidBodies);
     EXPECT_EQ(topology.num_mobilizers(), kNumRigidBodies);
     EXPECT_EQ(topology.num_mobods(), kNumRigidBodies);
     EXPECT_EQ(topology.forest_height(), 4);
@@ -378,7 +377,7 @@ class TreeTopologyTests : public ::testing::Test {
     const set<LinkIndex> expected_level3 = {LinkIndex(6)};
 
     // Comparison of sets. The order of the elements is not important.
-    std::vector<std::set<LinkIndex>> levels(topology.num_rigid_bodies());
+    std::vector<std::set<LinkIndex>> levels(forest.height());
     for (const LinkJointGraph::Link& link : forest.links()) {
       const int level = forest.mobods(link.mobod_index()).level();
       levels[level].insert(link.index());

From 5f93e88d2cd598707f7a21ef22e9f3d6cad8c521 Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Mon, 29 Sep 2025 14:38:01 -0700
Subject: [PATCH 3/7] Nuked MobilizerTopology

---
 multibody/tree/multibody_tree-inl.h           |   4 -
 multibody/tree/multibody_tree.cc              |  29 ++---
 multibody/tree/multibody_tree_topology.cc     |  77 ------------
 multibody/tree/multibody_tree_topology.h      | 118 ------------------
 .../tree/test/multibody_tree_creation_test.cc |   4 -
 5 files changed, 12 insertions(+), 220 deletions(-)

diff --git a/multibody/tree/multibody_tree-inl.h b/multibody/tree/multibody_tree-inl.h
index 400354ac8671..889d49c269ca 100644
--- a/multibody/tree/multibody_tree-inl.h
+++ b/multibody/tree/multibody_tree-inl.h
@@ -109,10 +109,6 @@ const MobilizerType<T>& MultibodyTree<T>::AddMobilizer(
   // Sanity check that we are processing in the expected order.
   DRAKE_DEMAND(mobilizer->mobod().index() == num_mobilizers());
 
-  topology_.add_mobilizer_topology(mobilizer->mobod(),
-                                   mobilizer->inboard_frame().index(),
-                                   mobilizer->outboard_frame().index());
-
   if (!mobilizer->model_instance().is_valid()) {
     mobilizer->set_model_instance(default_model_instance());
   }
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index 16531c71937a..0dc87cafb7e0 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -760,8 +760,6 @@ void MultibodyTree<T>::CreateJointImplementations() {
     if (mobod.is_world()) {
       // No associated Joint but we do want a stub "weld" Mobilizer so that
       // Mobods, BodyNodes, and Mobilizers have identical numbering.
-      topology_.add_world_mobilizer_topology(mobod,
-                                             world_body().body_frame().index());
       auto dummy_weld = std::make_unique<internal::WeldMobilizer<T>>(
           mobod, world_frame(), world_frame());
       dummy_weld->set_model_instance(world_model_instance());
@@ -1445,7 +1443,7 @@ void MultibodyTree<T>::CalcSpatialInertiasInWorld(
     const systems::Context<T>& context,
     std::vector<SpatialInertia<T>>* M_B_W_all) const {
   DRAKE_THROW_UNLESS(M_B_W_all != nullptr);
-  DRAKE_THROW_UNLESS(ssize(*M_B_W_all) == topology_.num_mobods());
+  DRAKE_THROW_UNLESS(ssize(*M_B_W_all) == num_mobods());
 
   const FrameBodyPoseCache<T>& frame_body_pose_cache =
       EvalFrameBodyPoses(context);
@@ -1582,8 +1580,7 @@ void MultibodyTree<T>::CalcSpatialAccelerationBias(
   // TODO(joemasterjohn): Consider an optimization where we avoid computing
   //  `Ab_WB` for locked floating bodies.
   (*Ab_WB_all)[world_mobod_index()].SetNaN();
-  for (MobodIndex mobod_index(1); mobod_index < topology_.num_mobods();
-       ++mobod_index) {
+  for (MobodIndex mobod_index(1); mobod_index < num_mobods(); ++mobod_index) {
     const BodyNode<T>& node = *body_nodes_[mobod_index];
     node.CalcSpatialAccelerationBias(frame_body_pose_cache, positions, pc,
                                      velocities, vc, &*Ab_WB_all);
@@ -1596,7 +1593,7 @@ void MultibodyTree<T>::CalcArticulatedBodyForceBias(
     const ArticulatedBodyInertiaCache<T>& abic,
     std::vector<SpatialForce<T>>* Zb_Bo_W_all) const {
   DRAKE_THROW_UNLESS(Zb_Bo_W_all != nullptr);
-  DRAKE_THROW_UNLESS(ssize(*Zb_Bo_W_all) == topology_.num_mobods());
+  DRAKE_THROW_UNLESS(ssize(*Zb_Bo_W_all) == num_mobods());
   const std::vector<SpatialAcceleration<T>>& Ab_WB_cache =
       EvalSpatialAccelerationBiasCache(context);
 
@@ -1607,8 +1604,7 @@ void MultibodyTree<T>::CalcArticulatedBodyForceBias(
   // TODO(joemasterjohn): Consider an optimization to avoid computing `Zb_Bo_W`
   //  for locked floating bodies.
   (*Zb_Bo_W_all)[world_mobod_index()].SetNaN();
-  for (MobodIndex mobod_index(1); mobod_index < topology_.num_mobods();
-       ++mobod_index) {
+  for (MobodIndex mobod_index(1); mobod_index < num_mobods(); ++mobod_index) {
     const ArticulatedBodyInertia<T>& Pplus_PB_W =
         abic.get_Pplus_PB_W(mobod_index);
     const SpatialAcceleration<T>& Ab_WB = Ab_WB_cache[mobod_index];
@@ -1623,7 +1619,7 @@ void MultibodyTree<T>::CalcArticulatedBodyForceBias(
     const systems::Context<T>& context,
     std::vector<SpatialForce<T>>* Zb_Bo_W_all) const {
   DRAKE_THROW_UNLESS(Zb_Bo_W_all != nullptr);
-  DRAKE_THROW_UNLESS(ssize(*Zb_Bo_W_all) == topology_.num_mobods());
+  DRAKE_THROW_UNLESS(ssize(*Zb_Bo_W_all) == num_mobods());
   const ArticulatedBodyInertiaCache<T>& abic =
       EvalArticulatedBodyInertiaCache(context);
   CalcArticulatedBodyForceBias(context, abic, Zb_Bo_W_all);
@@ -1635,7 +1631,7 @@ void MultibodyTree<T>::CalcDynamicBiasForces(
     const systems::Context<T>& context,
     std::vector<SpatialForce<T>>* Fb_Bo_W_all) const {
   DRAKE_THROW_UNLESS(Fb_Bo_W_all != nullptr);
-  DRAKE_THROW_UNLESS(ssize(*Fb_Bo_W_all) == topology_.num_mobods());
+  DRAKE_THROW_UNLESS(ssize(*Fb_Bo_W_all) == num_mobods());
 
   const std::vector<SpatialInertia<T>>& spatial_inertia_in_world_cache =
       EvalSpatialInertiaInWorldCache(context);
@@ -1682,7 +1678,7 @@ void MultibodyTree<T>::CalcSpatialAccelerationsFromVdot(
     bool ignore_velocities,
     std::vector<SpatialAcceleration<T>>* A_WB_array) const {
   DRAKE_DEMAND(A_WB_array != nullptr);
-  DRAKE_DEMAND(ssize(*A_WB_array) == topology_.num_mobods());
+  DRAKE_DEMAND(ssize(*A_WB_array) == num_mobods());
 
   DRAKE_DEMAND(known_vdot.size() == topology_.num_velocities());
 
@@ -1980,8 +1976,8 @@ void MultibodyTree<T>::CalcMassMatrixViaInverseDynamics(
   VectorX<T> vdot(nv);
   VectorX<T> tau(nv);
   // Auxiliary arrays used by inverse dynamics.
-  std::vector<SpatialAcceleration<T>> A_WB_array(topology_.num_mobods());
-  std::vector<SpatialForce<T>> F_BMo_W_array(topology_.num_mobods());
+  std::vector<SpatialAcceleration<T>> A_WB_array(num_mobods());
+  std::vector<SpatialForce<T>> F_BMo_W_array(num_mobods());
 
   // The mass matrix is only a function of configuration q. Therefore velocity
   // terms are not considered.
@@ -2058,8 +2054,8 @@ void MultibodyTree<T>::CalcBiasTerm(const systems::Context<T>& context,
   const int nv = num_velocities();
   const VectorX<T> vdot = VectorX<T>::Zero(nv);
   // Auxiliary arrays used by inverse dynamics.
-  std::vector<SpatialAcceleration<T>> A_WB_array(topology_.num_mobods());
-  std::vector<SpatialForce<T>> F_BMo_W_array(topology_.num_mobods());
+  std::vector<SpatialAcceleration<T>> A_WB_array(num_mobods());
+  std::vector<SpatialForce<T>> F_BMo_W_array(num_mobods());
   // TODO(amcastro-tri): provide specific API for when vdot = 0.
   CalcInverseDynamics(context, vdot, {}, VectorX<T>(), &A_WB_array,
                       &F_BMo_W_array, Cv);
@@ -2658,8 +2654,7 @@ void MultibodyTree<T>::CalcAcrossNodeJacobianWrtVExpressedInWorld(
 
   // TODO(joemasterjohn): Consider an optimization where we avoid computing
   //  `H_PB_W` for locked floating bodies.
-  for (MobodIndex mobod_index(1); mobod_index < topology_.num_mobods();
-       ++mobod_index) {
+  for (MobodIndex mobod_index(1); mobod_index < num_mobods(); ++mobod_index) {
     const BodyNode<T>& node = *body_nodes_[mobod_index];
 
     node.CalcAcrossNodeJacobianWrtVExpressedInWorld(
diff --git a/multibody/tree/multibody_tree_topology.cc b/multibody/tree/multibody_tree_topology.cc
index 0d7bd3268576..dc7d83733aea 100644
--- a/multibody/tree/multibody_tree_topology.cc
+++ b/multibody/tree/multibody_tree_topology.cc
@@ -10,7 +10,6 @@ bool MultibodyTreeTopology::operator==(
   if (forest_height_ != other.forest_height_) return false;
 
   if (frame_topology_ != other.frame_topology_) return false;
-  if (mobilizer_topology_ != other.mobilizer_topology_) return false;
   if (joint_actuator_topology_ != other.joint_actuator_topology_) return false;
 
   if (num_positions_ != other.num_positions_) return false;
@@ -54,64 +53,6 @@ void MultibodyTreeTopology::add_frame_topology(FrameIndex frame_index,
   frame_topology_.emplace_back(frame_index, body_index);
 }
 
-void MultibodyTreeTopology::add_mobilizer_topology(
-    const SpanningForest::Mobod& mobod, FrameIndex in_frame,
-    FrameIndex out_frame) {
-  if (is_valid()) {
-    throw std::logic_error(
-        "This MultibodyTreeTopology is finalized already. "
-        "Therefore adding more mobilizers is not allowed. "
-        "See documentation for Finalize() for details.");
-  }
-
-  const MobodIndex mobilizer_index(mobod.index());
-  DRAKE_DEMAND(mobilizer_index == num_mobilizers());
-
-  // Note: MultibodyTree double checks the mobilizer's frames belong to that
-  // tree. Therefore the validity of in_frame and out_frame is already
-  // guaranteed. We add the checks here for additional security.
-  DRAKE_THROW_UNLESS(in_frame < num_frames());
-  DRAKE_THROW_UNLESS(out_frame < num_frames());
-  if (in_frame == out_frame) {
-    throw std::runtime_error(
-        "Attempting to add a mobilizer between a frame and itself");
-  }
-  if (IsThereAMobilizerBetweenFrames(in_frame, out_frame)) {
-    throw std::runtime_error(fmt::format(
-        "This multibody tree already has a mobilizer connecting "
-        "inboard frame (index={}) and outboard frame (index={}). "
-        "More than one mobilizer between two frames is not allowed.",
-        in_frame, out_frame));
-  }
-  const BodyIndex inboard_body = frame_topology_[in_frame].rigid_body;
-  const BodyIndex outboard_body = frame_topology_[out_frame].rigid_body;
-  if (IsThereAMobilizerBetweenRigidBodies(inboard_body, outboard_body)) {
-    throw std::runtime_error(fmt::format(
-        "This multibody tree already has a mobilizer connecting "
-        "inboard rigid body (index={}) and outboard rigid body (index={}). "
-        "More than one mobilizer between two bodies is not allowed.",
-        inboard_body, outboard_body));
-  }
-
-  mobilizer_topology_.emplace_back(mobilizer_index, in_frame, out_frame,
-                                   inboard_body, outboard_body, mobod);
-}
-
-void MultibodyTreeTopology::add_world_mobilizer_topology(
-    const SpanningForest::Mobod& world_mobod, FrameIndex world_body_frame) {
-  DRAKE_DEMAND(world_mobod.is_world());
-  const BodyIndex world_body_index =
-      frame_topology_[world_body_frame].rigid_body;
-  DRAKE_DEMAND(world_body_index == BodyIndex(0));
-  DRAKE_DEMAND(mobilizer_topology_.empty());
-  // There is no inboard frame for this mobilizer. We'll use the World body
-  // frame and rigid body for both frames & bodies so we don't have to deal
-  // with invalid indices. No computation depends on those.
-  mobilizer_topology_.emplace_back(MobodIndex(0), world_body_frame,
-                                   world_body_frame, world_body_index,
-                                   world_body_index, world_mobod);
-}
-
 void MultibodyTreeTopology::add_joint_actuator_topology(
     JointActuatorIndex joint_actuator_index, int num_dofs) {
   DRAKE_DEMAND(joint_actuator_index == num_joint_actuators());
@@ -180,24 +121,6 @@ void MultibodyTreeTopology::FinalizeTopology(const LinkJointGraph& graph) {
   is_valid_ = true;
 }
 
-bool MultibodyTreeTopology::IsThereAMobilizerBetweenFrames(
-    FrameIndex frame1, FrameIndex frame2) const {
-  for (const auto& mobilizer_topology : mobilizer_topology_) {
-    if (mobilizer_topology.connects_frames(frame1, frame2)) return true;
-  }
-  return false;
-}
-
-// Returns `true` if there is _any_ mobilizer in the multibody tree
-// connecting the Links with indexes `body1` and `body2`.
-bool MultibodyTreeTopology::IsThereAMobilizerBetweenRigidBodies(
-    BodyIndex body1, BodyIndex body2) const {
-  for (const auto& mobilizer_topology : mobilizer_topology_) {
-    if (mobilizer_topology.connects_rigid_bodies(body1, body2)) return true;
-  }
-  return false;
-}
-
 // TODO(sherm1) Currently this copies from the graph and forest into the
 //  previous data structures, to establish that we are computing the same
 //  quantities. Once this works, should switch to using the forest data
diff --git a/multibody/tree/multibody_tree_topology.h b/multibody/tree/multibody_tree_topology.h
index f86515cf544d..2bd70f791fac 100644
--- a/multibody/tree/multibody_tree_topology.h
+++ b/multibody/tree/multibody_tree_topology.h
@@ -39,77 +39,6 @@ struct FrameTopology {
   BodyIndex rigid_body{0};
 };
 
-// Data structure to store the topological information associated with a
-// Mobilizer object. It stores:
-//
-// - Indexes to the inboard/outboard frames of this mobilizer.
-// - Indexes to the inboard/outboard rigid bodies of this mobilizer.
-// - Numbers of dofs admitted by this mobilizer.
-// - Indexing information to retrieve entries from the parent MultibodyTree
-//   Context.
-//
-// Additional information on topology classes is given in this file's
-// documentation at the top.
-struct MobilizerTopology {
-  DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(MobilizerTopology);
-
-  // Constructs a MobilizerTopology from the corresponding Mobod, plus the
-  // connected RigidBodies and the Frame geometric information from the
-  // modeled Joint.
-  MobilizerTopology(MobodIndex mobilizer_index, FrameIndex in_frame,
-                    FrameIndex out_frame, BodyIndex in_body, BodyIndex out_body,
-                    const SpanningForest::Mobod& mobod)
-      : index(mobilizer_index),
-        inboard_frame(in_frame),
-        outboard_frame(out_frame),
-        inboard_body(in_body),
-        outboard_body(out_body),
-        num_positions(mobod.nq()),
-        positions_start(mobod.q_start()),
-        num_velocities(mobod.nv()),
-        velocities_start_in_v(mobod.v_start()) {}
-
-  // Returns `true` if all members of `this` topology are exactly equal to the
-  // members of `other`.
-  bool operator==(const MobilizerTopology& other) const = default;
-
-  // Returns `true` if this Mobilizer connects these Frames.
-  bool connects_frames(FrameIndex frame1, FrameIndex frame2) const {
-    return (inboard_frame == frame1 && outboard_frame == frame2) ||
-           (inboard_frame == frame2 && outboard_frame == frame1);
-  }
-
-  // Returns `true` if this Mobilizer connects this RigidBody pair.
-  bool connects_rigid_bodies(BodyIndex body1, BodyIndex body2) const {
-    return (inboard_body == body1 && outboard_body == body2) ||
-           (inboard_body == body2 && outboard_body == body1);
-  }
-
-  // Returns `true` if this Mobilizer is a weld.
-  bool is_weld_mobilizer() const { return num_velocities == 0; }
-
-  // Unique index in the set of Mobilizers. There will be a corresponding
-  // BodyNode with the same index.
-  MobodIndex index;
-
-  FrameIndex inboard_frame;
-  FrameIndex outboard_frame;
-  BodyIndex inboard_body;
-  BodyIndex outboard_body;
-
-  // Number of generalized coordinates granted by this mobilizer.
-  int num_positions{0};
-  // First entry in the q partition of the global array of states x = [q v z].
-  int positions_start{0};
-
-  // Number of generalized velocities granted by this mobilizer.
-  int num_velocities{0};
-  // Start index in a vector indexed like the v partition of states x, including
-  // generalized accelerations (which are the time derivatives of the
-  // generalized velocities) and generalized forces.
-  int velocities_start_in_v{0};
-};
-
 // Data structure to store the topological information associated with a
 // JointActuator.
 struct JointActuatorTopology {
@@ -147,15 +76,6 @@ class MultibodyTreeTopology {
   // Returns the number of physical frames in the multibody tree.
   int num_frames() const { return ssize(frame_topology_); }
 
-  // Returns the number of Mobilizers. This is always the same as the number
-  // of BodyNodes and the number of mobilized bodies in the SpanningForest.
-  int num_mobilizers() const { return ssize(mobilizer_topology_); }
-
-  // Returns the number of BodyNodes. These are generated 1:1 from the
-  // MobilizedBodies in the SpanningForest. If we combined welded Links,
-  // there will be more RigidBodies than BodyNodes.
-  int num_mobods() const { return num_mobilizers(); }
-
   // Returns the number of joint actuators in the topology.
   int num_joint_actuators() const { return ssize(joint_actuator_topology_); }
 
@@ -169,13 +89,6 @@ class MultibodyTreeTopology {
     return frame_topology_[index];
   }
 
-  // Returns a constant reference to the corresponding MobilizerTopology given a
-  // MobodIndex.
-  const MobilizerTopology& get_mobilizer_topology(MobodIndex index) const {
-    DRAKE_ASSERT(index < num_mobilizers());
-    return mobilizer_topology_[index];
-  }
-
   // Returns a constant reference to the corresponding JointActuatorTopology
   // given a JointActuatorIndex.
   const JointActuatorTopology& get_joint_actuator_topology(
@@ -240,26 +153,6 @@ class MultibodyTreeTopology {
   // @pre the FrameIndex is the one for the next available slot
   void add_frame_topology(FrameIndex, BodyIndex);
 
-  // Creates and adds a new MobilizerTopology connecting the inboard and
-  // outboard multibody frames identified by indexes `in_frame` and
-  // `out_frame`, respectively. The created topology will reflect information
-  // provided in the given Mobod (including the index).
-  //
-  // @throws std::exception if either `in_frame` or `out_frame` do not
-  // index frame topologies in `this` %MultibodyTreeTopology.
-  // @throws std::exception if `in_frame == out_frame`.
-  // @throws std::exception if `in_frame` and `out_frame` already are
-  // connected by another mobilizer. More than one mobilizer between two frames
-  // is not allowed.
-  // @throws std::exception if FinalizeTopology() was already called on `this`
-  // topology.
-  // @pre the mobod's index is the one for the next available slot
-  void add_mobilizer_topology(const SpanningForest::Mobod& mobod,
-                              FrameIndex in_frame, FrameIndex out_frame);
-
-  void add_world_mobilizer_topology(const SpanningForest::Mobod& world_mobod,
-                                    FrameIndex world_body_frame);
-
   // Creates and adds a new JointActuatorTopology for a joint with `num_dofs`
   // degrees of freedom.
   //
@@ -311,16 +204,6 @@ class MultibodyTreeTopology {
   int num_actuated_dofs() const { return num_actuated_dofs_; }
 
  private:
-  // Returns `true` if there is _any_ mobilizer in the multibody tree
-  // connecting the frames with indexes `frame` and `frame2`.
-  bool IsThereAMobilizerBetweenFrames(FrameIndex frame1,
-                                      FrameIndex frame2) const;
-
-  // Returns `true` if there is _any_ mobilizer in the multibody tree
-  // connecting the Links with indexes `body1` and `body2`.
-  bool IsThereAMobilizerBetweenRigidBodies(BodyIndex body1,
-                                           BodyIndex body2) const;
-
   // Helper method to be used within FinalizeTopology() to obtain the
   // topological information that describes the multibody system as a "forest"
   // of trees.
@@ -334,7 +217,6 @@ class MultibodyTreeTopology {
 
   // Topological elements:
   std::vector<FrameTopology> frame_topology_;
-  std::vector<MobilizerTopology> mobilizer_topology_;
   std::vector<std::optional<JointActuatorTopology>> joint_actuator_topology_;
 
   // Total number of generalized positions and velocities in the MultibodyTree
diff --git a/multibody/tree/test/multibody_tree_creation_test.cc b/multibody/tree/test/multibody_tree_creation_test.cc
index 541679ecacdb..fe4d50881551 100644
--- a/multibody/tree/test/multibody_tree_creation_test.cc
+++ b/multibody/tree/test/multibody_tree_creation_test.cc
@@ -358,8 +358,6 @@ class TreeTopologyTests : public ::testing::Test {
                              const SpanningForest& forest) {
     const int kNumRigidBodies = 10;
 
-    EXPECT_EQ(topology.num_mobilizers(), kNumRigidBodies);
-    EXPECT_EQ(topology.num_mobods(), kNumRigidBodies);
     EXPECT_EQ(topology.forest_height(), 4);
 
     EXPECT_EQ(forest.num_links(), kNumRigidBodies);
@@ -507,7 +505,6 @@ TEST_F(TreeTopologyTests, Finalize) {
   const MultibodyTreeTopology& topology = model_->get_topology();
   const SpanningForest& forest = model_->forest();
 
-  EXPECT_EQ(topology.num_mobods(), 10);
   EXPECT_EQ(topology.forest_height(), 4);
 
   EXPECT_EQ(forest.num_mobods(), 10);
@@ -529,7 +526,6 @@ TEST_F(TreeTopologyTests, SizesAndIndexing) {
   const MultibodyTreeTopology& topology = model_->get_topology();
   const SpanningForest& forest = model_->forest();
 
-  EXPECT_EQ(topology.num_mobods(), model_->num_bodies());
   EXPECT_EQ(topology.forest_height(), 4);
   EXPECT_EQ(topology.num_positions(), 7);
   EXPECT_EQ(topology.num_velocities(), 7);

From a06495a3c1ad7a3a54b7bea8af2ebffd8c112e6c Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Mon, 29 Sep 2025 15:11:19 -0700
Subject: [PATCH 4/7] Nuked FrameTopology

---
 multibody/tree/frame.h                    |  9 ++---
 multibody/tree/multibody_tree-inl.h       |  4 ---
 multibody/tree/multibody_tree.cc          |  5 +--
 multibody/tree/multibody_tree_topology.cc | 13 -------
 multibody/tree/multibody_tree_topology.h  | 42 -----------------------
 5 files changed, 3 insertions(+), 70 deletions(-)

diff --git a/multibody/tree/frame.h b/multibody/tree/frame.h
index 07749a6cfeb9..5fcc798ffc60 100644
--- a/multibody/tree/frame.h
+++ b/multibody/tree/frame.h
@@ -636,10 +636,8 @@ class Frame : public MultibodyElement<T> {
 
  private:
   // Implementation for MultibodyElement::DoSetTopology().
-  void DoSetTopology(
-      const internal::MultibodyTreeTopology& tree_topology) final {
-    topology_ = tree_topology.get_frame_topology(this->index());
-    DRAKE_ASSERT(topology_.index == this->index());
+  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
+    // Frame gets everything it needs at construction.
   }
 
   // Implementation for MultibodyElement::DoDeclareParameters().
@@ -658,9 +656,6 @@ class Frame : public MultibodyElement<T> {
   // The body associated with this frame.
   const RigidBody<T>& body_;
 
-  // The internal bookkeeping topology struct used by MultibodyTree.
-  internal::FrameTopology topology_;
-
   int body_pose_index_in_cache_{-1};
 };
 
diff --git a/multibody/tree/multibody_tree-inl.h b/multibody/tree/multibody_tree-inl.h
index 889d49c269ca..631a55d47d27 100644
--- a/multibody/tree/multibody_tree-inl.h
+++ b/multibody/tree/multibody_tree-inl.h
@@ -58,10 +58,6 @@ const FrameType<T>& MultibodyTree<T>::AddFrame(
   }
   DRAKE_DEMAND(frame->model_instance().is_valid());
   const FrameIndex frame_index(num_frames());
-  topology_.add_frame_topology(frame_index, frame->body().index());
-
-  // TODO(amcastro-tri): consider not depending on setting this pointer at
-  //  all. Consider also removing MultibodyElement altogether.
   frame->set_parent_tree(this, frame_index);
   FrameType<T>* result = frame.get();
   frames_.Add(std::move(frame));
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index 0dc87cafb7e0..2ad4ff5e536e 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -559,8 +559,6 @@ const RigidBody<T>& MultibodyTree<T>::AddRigidBodyImpl(
   DRAKE_DEMAND(body->model_instance().is_valid());
 
   const BodyIndex body_index(num_bodies());
-  const FrameIndex body_frame_index(num_frames());
-  topology_.add_frame_topology(body_frame_index, body_index);
 
   if (body_index == 0) {
     // We're adding the first RigidBody -- must be World!
@@ -574,14 +572,13 @@ const RigidBody<T>& MultibodyTree<T>::AddRigidBodyImpl(
     link_joint_graph_.AddLink(body->name(), body->model_instance());
   }
 
-  // TODO(amcastro-tri): consider not depending on setting this pointer at
-  //  all. Consider also removing MultibodyElement altogether.
   body->set_parent_tree(this, body_index);
   // MultibodyTree can access selected private methods in RigidBody through its
   // RigidBodyAttorney.
   // - Register body frame.
   Frame<T>* body_frame =
       &internal::RigidBodyAttorney<T>::get_mutable_body_frame(body.get());
+  const FrameIndex body_frame_index(num_frames());
   body_frame->set_parent_tree(this, body_frame_index);
   DRAKE_DEMAND(body_frame->name() == body->name());
   frames_.AddBorrowed(body_frame);
diff --git a/multibody/tree/multibody_tree_topology.cc b/multibody/tree/multibody_tree_topology.cc
index dc7d83733aea..a90388808457 100644
--- a/multibody/tree/multibody_tree_topology.cc
+++ b/multibody/tree/multibody_tree_topology.cc
@@ -9,7 +9,6 @@ bool MultibodyTreeTopology::operator==(
   if (is_valid_ != other.is_valid_) return false;
   if (forest_height_ != other.forest_height_) return false;
 
-  if (frame_topology_ != other.frame_topology_) return false;
   if (joint_actuator_topology_ != other.joint_actuator_topology_) return false;
 
   if (num_positions_ != other.num_positions_) return false;
@@ -41,18 +40,6 @@ const JointActuatorTopology& MultibodyTreeTopology::get_joint_actuator_topology(
   return *joint_actuator_topology_[index];
 }
 
-void MultibodyTreeTopology::add_frame_topology(FrameIndex frame_index,
-                                               BodyIndex body_index) {
-  if (is_valid()) {
-    throw std::logic_error(
-        "This MultibodyTreeTopology is finalized already. "
-        "Therefore adding more frames is not allowed. "
-        "See documentation for Finalize() for details.");
-  }
-  DRAKE_DEMAND(frame_index == num_frames());
-  frame_topology_.emplace_back(frame_index, body_index);
-}
-
 void MultibodyTreeTopology::add_joint_actuator_topology(
     JointActuatorIndex joint_actuator_index, int num_dofs) {
   DRAKE_DEMAND(joint_actuator_index == num_joint_actuators());
diff --git a/multibody/tree/multibody_tree_topology.h b/multibody/tree/multibody_tree_topology.h
index 2bd70f791fac..94b2fc6ff45e 100644
--- a/multibody/tree/multibody_tree_topology.h
+++ b/multibody/tree/multibody_tree_topology.h
@@ -16,29 +16,6 @@ namespace drake {
 namespace multibody {
 namespace internal {
 
-// Data structure to store the topological information associated with a Frame.
-struct FrameTopology {
-  DRAKE_DEFAULT_COPY_AND_MOVE_AND_ASSIGN(FrameTopology);
-
-  // Default construction to invalid configuration.
-  FrameTopology() {}
-
-  // Constructs a frame topology for a frame with index `frame_index`
-  // associated with a RigidBody with index `body_index`.
-  FrameTopology(FrameIndex frame_index, BodyIndex body_index)
-      : index(frame_index), rigid_body(body_index) {}
-
-  // Returns `true` if all members of `this` topology are exactly equal to the
-  // members of `other`.
-  bool operator==(const FrameTopology& other) const = default;
-
-  // Index in the MultibodyPlant.
-  FrameIndex index{0};
-
-  // Index of the RigidBody this physical frame attaches to.
-  BodyIndex rigid_body{0};
-};
-
 // Data structure to store the topological information associated with a
 // JointActuator.
 struct JointActuatorTopology {
@@ -73,22 +50,12 @@ class MultibodyTreeTopology {
   // members of `other`.
   bool operator==(const MultibodyTreeTopology& other) const;
 
-  // Returns the number of physical frames in the multibody tree.
-  int num_frames() const { return ssize(frame_topology_); }
-
   // Returns the number of joint actuators in the topology.
   int num_joint_actuators() const { return ssize(joint_actuator_topology_); }
 
   // Returns the number of levels in the forest topology.
   int forest_height() const { return forest_height_; }
 
-  // Returns a constant reference to the corresponding FrameTopology given the
-  // FrameIndex.
-  const FrameTopology& get_frame_topology(FrameIndex index) const {
-    DRAKE_ASSERT(index < num_frames());
-    return frame_topology_[index];
-  }
-
   // Returns a constant reference to the corresponding JointActuatorTopology
   // given a JointActuatorIndex.
   const JointActuatorTopology& get_joint_actuator_topology(
@@ -145,14 +112,6 @@ class MultibodyTreeTopology {
     return num_tree_velocities(tree_index) > 0;
   }
 
-  // Creates and adds a new FrameTopology, associated with the given
-  // BodyIndex, to this MultibodyTreeTopology.
-  //
-  // @throws std::exception if FinalizeTopology() was already called on `this`
-  // topology.
-  // @pre the FrameIndex is the one for the next available slot
-  void add_frame_topology(FrameIndex, BodyIndex);
-
   // Creates and adds a new JointActuatorTopology for a joint with `num_dofs`
   // degrees of freedom.
   //
@@ -216,7 +175,6 @@ class MultibodyTreeTopology {
   int forest_height_{-1};
 
   // Topological elements:
-  std::vector<FrameTopology> frame_topology_;
   std::vector<std::optional<JointActuatorTopology>> joint_actuator_topology_;
 
   // Total number of generalized positions and velocities in the MultibodyTree

From 4cc56fe6ea99d169b092cbbfe9fb233099e76718 Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Mon, 29 Sep 2025 17:52:07 -0700
Subject: [PATCH 5/7] Nuked JointActuatorTopology.

---
 .../generated_docstrings/multibody_tree.h     | 16 +++---
 multibody/tree/joint_actuator.cc              | 38 ++++----------
 multibody/tree/joint_actuator.h               | 41 ++++++++++-----
 multibody/tree/multibody_tree-inl.h           |  3 +-
 multibody/tree/multibody_tree.cc              | 14 ++++-
 multibody/tree/multibody_tree.h               | 20 +++++---
 multibody/tree/multibody_tree_topology.cc     | 51 -------------------
 multibody/tree/multibody_tree_topology.h      | 44 ----------------
 multibody/tree/test/joint_actuator_test.cc    |  6 +--
 9 files changed, 76 insertions(+), 157 deletions(-)

diff --git a/bindings/generated_docstrings/multibody_tree.h b/bindings/generated_docstrings/multibody_tree.h
index 769b1b8f1632..679b37072da4 100644
--- a/bindings/generated_docstrings/multibody_tree.h
+++ b/bindings/generated_docstrings/multibody_tree.h
@@ -4202,9 +4202,8 @@ with a call to set_controller_gains().
           const char* doc =
 R"""(Returns the index to the first element for this joint actuator /
 within the vector of actuation inputs for the full multibody / system.
-
-Raises:
-    RuntimeError if the MultibodyTree model is not finalized.)""";
+Returns -1 if this JointActuator hasn't been added to a
+MultibodyPlant.)""";
         } input_start;
         // Symbol: drake::multibody::JointActuator::joint
         struct /* joint */ {
@@ -4225,10 +4224,8 @@ R"""(Returns a reference to the joint actuated by this JointActuator.
         struct /* num_inputs */ {
           // Source: drake/multibody/tree/joint_actuator.h
           const char* doc =
-R"""(Returns the number of inputs associated with this actuator.
-
-Raises:
-    RuntimeError if the MultibodyTree model is not finalized.)""";
+R"""(Returns the number of inputs associated with this actuator. This is
+always the number of degrees of freedom of the actuated joint.)""";
         } num_inputs;
         // Symbol: drake::multibody::JointActuator::rotor_inertia
         struct /* rotor_inertia */ {
@@ -4272,6 +4269,11 @@ Parameter ``u``:
     RuntimeError if ``u.size() !=
     this->GetParentPlant().num_actuated_dofs()``.)""";
         } set_actuation_vector;
+        // Symbol: drake::multibody::JointActuator::set_actuator_dof_start
+        struct /* set_actuator_dof_start */ {
+          // Source: drake/multibody/tree/joint_actuator.h
+          const char* doc = R"""()""";
+        } set_actuator_dof_start;
         // Symbol: drake::multibody::JointActuator::set_controller_gains
         struct /* set_controller_gains */ {
           // Source: drake/multibody/tree/joint_actuator.h
diff --git a/multibody/tree/joint_actuator.cc b/multibody/tree/joint_actuator.cc
index b1fb291af2f6..2baf184c9c46 100644
--- a/multibody/tree/joint_actuator.cc
+++ b/multibody/tree/joint_actuator.cc
@@ -40,8 +40,7 @@ void JointActuator<T>::set_controller_gains(PdControllerGains gains) {
   // plant. On the other hand, if set_controller_gains is called post-Finalize
   // to add a controller on a continuous-time plant, we need to reject that
   // ourselves; the plant won't know to check for it.
-  const bool is_finalized = topology_.actuator_dof_start >= 0;
-  if (is_finalized) {
+  if (is_finalized_) {
     DRAKE_DEMAND(this->has_parent_tree());
     // N.B. Calling is_state_discrete() on a non-finalized plant will segfault;
     // we must be careful to only call it inside of the if-finalized guard.
@@ -82,50 +81,33 @@ void JointActuator<T>::set_actuation_vector(
   DRAKE_THROW_UNLESS(this->has_parent_tree());
   DRAKE_THROW_UNLESS(u->size() == this->get_parent_tree().num_actuated_dofs());
   DRAKE_THROW_UNLESS(u_actuator.size() == num_inputs());
-  u->segment(topology_.actuator_dof_start, num_inputs()) = u_actuator;
+  u->segment(input_start(), num_inputs()) = u_actuator;
 }
 
 template <typename T>
 int JointActuator<T>::input_start() const {
-  if (topology_.actuator_dof_start < 0) {
-    throw std::runtime_error(
-        "JointActuator::input_start() must be called after the MultibodyPlant "
-        "is finalized.");
-  }
-  return topology_.actuator_dof_start;
+  return actuator_dof_start_;
 }
 
 template <typename T>
 int JointActuator<T>::num_inputs() const {
-  if (topology_.actuator_dof_start < 0) {
-    throw std::runtime_error(
-        "JointActuator::num_inputs() must be called after the MultibodyPlant "
-        "is finalized.");
-  }
-  DRAKE_ASSERT(joint().num_velocities() == topology_.num_dofs);
   return joint().num_velocities();
 }
 
-template <typename T>
-void JointActuator<T>::DoSetTopology(
-    const internal::MultibodyTreeTopology& mbt_topology) {
-  topology_ = mbt_topology.get_joint_actuator_topology(this->index());
-}
-
 template <typename T>
 std::unique_ptr<JointActuator<double>> JointActuator<T>::DoCloneToScalar(
     const internal::MultibodyTree<double>&) const {
-  return std::unique_ptr<JointActuator<double>>(
-      new JointActuator<double>(name_, joint_index_, effort_limit_,
-                                default_rotor_inertia_, default_gear_ratio_));
+  return std::unique_ptr<JointActuator<double>>(new JointActuator<double>(
+      name_, joint_index_, actuator_dof_start_, effort_limit_,
+      default_rotor_inertia_, default_gear_ratio_));
 }
 
 template <typename T>
 std::unique_ptr<JointActuator<AutoDiffXd>> JointActuator<T>::DoCloneToScalar(
     const internal::MultibodyTree<AutoDiffXd>&) const {
   return std::unique_ptr<JointActuator<AutoDiffXd>>(
-      new JointActuator<AutoDiffXd>(name_, joint_index_, effort_limit_,
-                                    default_rotor_inertia_,
+      new JointActuator<AutoDiffXd>(name_, joint_index_, actuator_dof_start_,
+                                    effort_limit_, default_rotor_inertia_,
                                     default_gear_ratio_));
 }
 
@@ -135,8 +117,8 @@ JointActuator<T>::DoCloneToScalar(
     const internal::MultibodyTree<symbolic::Expression>&) const {
   return std::unique_ptr<JointActuator<symbolic::Expression>>(
       new JointActuator<symbolic::Expression>(
-          name_, joint_index_, effort_limit_, default_rotor_inertia_,
-          default_gear_ratio_));
+          name_, joint_index_, actuator_dof_start_, effort_limit_,
+          default_rotor_inertia_, default_gear_ratio_));
 }
 
 }  // namespace multibody
diff --git a/multibody/tree/joint_actuator.h b/multibody/tree/joint_actuator.h
index 48a8a4cda377..f74e0f9a76fe 100644
--- a/multibody/tree/joint_actuator.h
+++ b/multibody/tree/joint_actuator.h
@@ -4,7 +4,6 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <vector>
 
 #include "drake/common/default_scalars.h"
 #include "drake/common/drake_copyable.h"
@@ -115,7 +114,7 @@ class JointActuator final : public MultibodyElement<T> {
       const VectorX<T>& u) const {
     DRAKE_THROW_UNLESS(this->has_parent_tree());
     DRAKE_DEMAND(u.size() == this->get_parent_tree().num_actuated_dofs());
-    return u.segment(topology_.actuator_dof_start, joint().num_velocities());
+    return u.segment(actuator_dof_start_, joint().num_velocities());
   }
 
   /// Given the actuation values `u_actuator` for `this` actuator, updates the
@@ -142,15 +141,16 @@ class JointActuator final : public MultibodyElement<T> {
 
   /// Returns the index to the first element for this joint actuator / within
   /// the vector of actuation inputs for the full multibody / system.
-  /// @throws std::exception if the MultibodyTree model is not finalized.
+  /// Returns -1 if this %JointActuator hasn't been added to a MultibodyPlant.
   int input_start() const;
 
-  /// Returns the number of inputs associated with this actuator.
-  /// @throws std::exception if the MultibodyTree model is not finalized.
+  /// Returns the number of inputs associated with this actuator. This is
+  /// always the number of degrees of freedom of the actuated joint.
   int num_inputs() const;
 
   // TODO(russt): This should be a vector (not a double), and we should have
-  // lower and upper limits (not require them to be symmetric).
+  //  lower and upper limits (not require them to be symmetric).
+
   /// Returns the actuator effort limit.
   double effort_limit() const { return effort_limit_; }
 
@@ -285,6 +285,7 @@ class JointActuator final : public MultibodyElement<T> {
   ///@{
 
   // TODO(amcastro-tri): Place gains in the context as parameters.
+
   /// Set controller gains for this joint actuator.
   /// This enables the modeling of a simple PD controller of the form:
   ///   ũ = -Kp⋅(q − qd) - Kd⋅(v − vd) + u_ff
@@ -336,6 +337,11 @@ class JointActuator final : public MultibodyElement<T> {
       const internal::MultibodyTree<ToScalar>& cloned_tree) const {
     return DoCloneToScalar(cloned_tree);
   }
+
+  void set_actuator_dof_start(int actuator_dof_start) {
+    DRAKE_DEMAND(actuator_dof_start >= 0);
+    actuator_dof_start_ = actuator_dof_start;
+  }
   /// @endcond
 
  private:
@@ -346,9 +352,11 @@ class JointActuator final : public MultibodyElement<T> {
 
   // Private constructor used for cloning.
   JointActuator(const std::string& name, JointIndex joint_index,
-                double effort_limit, double rotor_inertia, double gear_ratio)
+                int actuator_dof_start, double effort_limit,
+                double rotor_inertia, double gear_ratio)
       : name_(name),
         joint_index_(joint_index),
+        actuator_dof_start_(actuator_dof_start),
         effort_limit_(effort_limit),
         default_rotor_inertia_(rotor_inertia),
         default_gear_ratio_(gear_ratio) {}
@@ -367,9 +375,12 @@ class JointActuator final : public MultibodyElement<T> {
       const internal::MultibodyTree<symbolic::Expression>& tree_clone) const;
 
   // Implementation for MultibodyElement::DoSetTopology().
-  // At MultibodyTree::Finalize() time, each actuator retrieves its topology
-  // from the parent MultibodyTree.
-  void DoSetTopology(const internal::MultibodyTreeTopology&) final;
+  // This is called at the end of Finalize(). We just need to record
+  // that this actuator has been finalized because there are some
+  // checks we can't do until then.
+  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
+    is_finalized_ = true;
+  }
 
   // Implementation for MultibodyElement::DoDeclareParameters().
   void DoDeclareParameters(
@@ -401,6 +412,11 @@ class JointActuator final : public MultibodyElement<T> {
   // The index of the joint on which this actuator acts.
   JointIndex joint_index_;
 
+  // This is the offset into the vector of actuated dofs at which this
+  // actuator's dofs start. The number of controlled dofs starting here is
+  // joint().num_velocities().
+  int actuator_dof_start_{-1};
+
   // Actuator effort limit. It must be greater than 0.
   double effort_limit_;
 
@@ -421,10 +437,9 @@ class JointActuator final : public MultibodyElement<T> {
   // context.
   systems::NumericParameterIndex gear_ratio_parameter_index_;
 
-  // The topology of this actuator. Only valid post- MultibodyTree::Finalize().
-  internal::JointActuatorTopology topology_;
-
   std::optional<PdControllerGains> pd_controller_gains_{std::nullopt};
+
+  bool is_finalized_{false};
 };
 
 }  // namespace multibody
diff --git a/multibody/tree/multibody_tree-inl.h b/multibody/tree/multibody_tree-inl.h
index 631a55d47d27..6c2f03ba2888 100644
--- a/multibody/tree/multibody_tree-inl.h
+++ b/multibody/tree/multibody_tree-inl.h
@@ -281,7 +281,8 @@ const JointActuator<T>& MultibodyTree<T>::AddJointActuator(
   // if the JointActuator constructor throws our state will still be valid.
   auto actuator = std::make_unique<JointActuator<T>>(name, joint, effort_limit);
   const JointActuatorIndex actuator_index(actuators_.next_index());
-  topology_.add_joint_actuator_topology(actuator_index, joint.num_velocities());
+  actuator->set_actuator_dof_start(num_actuated_dofs_);
+  num_actuated_dofs_ += joint.num_velocities();
   actuator->set_parent_tree(this, actuator_index);
   return actuators_.Add(std::move(actuator));
 }
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index 2ad4ff5e536e..61fbbf673df3 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -163,9 +163,19 @@ template <typename T>
 void MultibodyTree<T>::RemoveJointActuator(const JointActuator<T>& actuator) {
   DRAKE_MBT_THROW_IF_FINALIZED();
   actuator.HasThisParentTreeOrThrow(this);
+  const int num_dofs_removed = actuator.num_inputs();
   JointActuatorIndex actuator_index = actuator.index();
   actuators_.Remove(actuator_index);
-  topology_.RemoveJointActuatorTopology(actuator_index);
+  num_actuated_dofs_ -= num_dofs_removed;
+
+  // We have to adjust the dof-start allocation for all the higher-index
+  // actuators.
+  for (JointActuatorIndex i(actuator_index); i < actuators_.next_index(); ++i) {
+    if (!actuators_.has_element(i)) continue;  // Skip removed actuators.
+    JointActuator<T>& fixup_actuator = actuators_.get_mutable_element(i);
+    fixup_actuator.set_actuator_dof_start(fixup_actuator.input_start() -
+                                          num_dofs_removed);
+  }
 }
 
 template <typename T>
@@ -4137,6 +4147,8 @@ std::unique_ptr<MultibodyTree<ToScalar>> MultibodyTree<T>::CloneToScalar()
     tree_clone->CloneActuatorAndAdd(*actuator);
   }
 
+  tree_clone->num_actuated_dofs_ = this->num_actuated_dofs_;
+
   // We can safely make a deep copy here since the original multibody tree is
   // required to be finalized.
   tree_clone->topology_ = this->topology_;
diff --git a/multibody/tree/multibody_tree.h b/multibody/tree/multibody_tree.h
index 182d80af8ee5..ec04cbe8cad9 100644
--- a/multibody/tree/multibody_tree.h
+++ b/multibody/tree/multibody_tree.h
@@ -546,7 +546,7 @@ class MultibodyTree {
   }
 
   // See MultibodyPlant method.
-  int num_actuated_dofs() const { return topology_.num_actuated_dofs(); }
+  int num_actuated_dofs() const { return num_actuated_dofs_; }
 
   // See MultibodyPlant method.
   int num_actuators(ModelInstanceIndex model_instance) const {
@@ -2851,6 +2851,9 @@ class MultibodyTree {
   std::vector<std::unique_ptr<ForceElement<T>>> force_elements_;
   ElementCollection<T, JointActuator, JointActuatorIndex> actuators_;
 
+  // This is accumulated as actuators are added.
+  int num_actuated_dofs_{0};
+
   // This is the internal representation of user-defined model instances.
   ElementCollection<T, internal::ModelInstance, ModelInstanceIndex>
       model_instances_;
@@ -2880,13 +2883,14 @@ class MultibodyTree {
   std::unordered_map<JointIndex, MobodIndex> joint_to_mobilizer_;
 
   // Maps the default body poses of all floating bodies AND bodies touched by
-  // MultibodyPlant::SetDefaultFreeBodyPose(). During Finalize(), the default
-  // pose of a floating body is converted to the joint index of the floating
-  // joint connecting the world and the body. Post-finalize and the default
-  // poses of such floating bodies can (and should) be retrieved via the joints'
-  // default positions. The poses are stored as a quaternion-translation pair to
-  // match the default positions stored in the quaternion floating joints
-  // without any numerical conversions and thereby avoiding roundoff errors and
+  // MultibodyPlant::SetDefaultFloatingBaseBodyPose(). During Finalize(), the
+  // default pose of a floating base body is converted to the joint index of the
+  // ephemeral (automatically added) floating joint connecting the world frame
+  // and the body frame. Post-finalize, the default poses of such floating
+  // base bodies can (and should) be retrieved via the joints' default
+  // positions. The poses are stored as a quaternion-translation pair to match
+  // the default positions stored in the quaternion floating joints without
+  // any numerical conversions and thereby avoiding roundoff errors and
   // surprising discrepancies pre and post finalize.
   std::unordered_map<
       BodyIndex, std::variant<JointIndex, std::pair<Eigen::Quaternion<double>,
diff --git a/multibody/tree/multibody_tree_topology.cc b/multibody/tree/multibody_tree_topology.cc
index a90388808457..a60267e9709c 100644
--- a/multibody/tree/multibody_tree_topology.cc
+++ b/multibody/tree/multibody_tree_topology.cc
@@ -9,8 +9,6 @@ bool MultibodyTreeTopology::operator==(
   if (is_valid_ != other.is_valid_) return false;
   if (forest_height_ != other.forest_height_) return false;
 
-  if (joint_actuator_topology_ != other.joint_actuator_topology_) return false;
-
   if (num_positions_ != other.num_positions_) return false;
   if (num_velocities_ != other.num_velocities_) return false;
   if (num_states_ != other.num_states_) return false;
@@ -33,55 +31,6 @@ bool MultibodyTreeTopology::operator==(
 
 MultibodyTreeTopology::~MultibodyTreeTopology() = default;
 
-const JointActuatorTopology& MultibodyTreeTopology::get_joint_actuator_topology(
-    JointActuatorIndex index) const {
-  DRAKE_ASSERT(index < ssize(joint_actuator_topology_));
-  DRAKE_DEMAND(joint_actuator_topology_[index].has_value());
-  return *joint_actuator_topology_[index];
-}
-
-void MultibodyTreeTopology::add_joint_actuator_topology(
-    JointActuatorIndex joint_actuator_index, int num_dofs) {
-  DRAKE_DEMAND(joint_actuator_index == num_joint_actuators());
-  DRAKE_DEMAND(num_dofs > 0);
-  if (is_valid()) {
-    throw std::logic_error(
-        "This MultibodyTreeTopology is finalized already. "
-        "Therefore adding more joint actuators is not allowed. "
-        "See documentation for Finalize() for details.");
-  }
-  const int actuator_dof_start = num_actuated_dofs();
-  joint_actuator_topology_.push_back(
-      JointActuatorTopology{.index = joint_actuator_index,
-                            .actuator_dof_start = actuator_dof_start,
-                            .num_dofs = num_dofs});
-  num_actuated_dofs_ += num_dofs;
-}
-
-void MultibodyTreeTopology::RemoveJointActuatorTopology(
-    JointActuatorIndex actuator_index) {
-  DRAKE_DEMAND(actuator_index < ssize(joint_actuator_topology_));
-  DRAKE_THROW_UNLESS(!is_valid());
-  DRAKE_THROW_UNLESS(joint_actuator_topology_[actuator_index].has_value());
-
-  // Reduce the total number of actuated dofs.
-  const int num_dofs = (*joint_actuator_topology_[actuator_index]).num_dofs;
-  DRAKE_DEMAND(num_actuated_dofs_ >= num_dofs);
-  num_actuated_dofs_ -= num_dofs;
-
-  // Mark the actuator as "removed".
-  joint_actuator_topology_[actuator_index] = std::nullopt;
-
-  // Update the actuator_dof_start for all joint actuators that come after
-  // the one we just removed.
-  for (JointActuatorIndex i(actuator_index);
-       i < ssize(joint_actuator_topology_); ++i) {
-    if (joint_actuator_topology_[i].has_value()) {
-      (*joint_actuator_topology_[i]).actuator_dof_start -= num_dofs;
-    }
-  }
-}
-
 // TODO(sherm1) For historical reasons we're extracting information from the
 //  Forest and distributing it but we should work directly from the Forest
 //  without duplication.
diff --git a/multibody/tree/multibody_tree_topology.h b/multibody/tree/multibody_tree_topology.h
index 94b2fc6ff45e..a39e1caad8d8 100644
--- a/multibody/tree/multibody_tree_topology.h
+++ b/multibody/tree/multibody_tree_topology.h
@@ -16,25 +16,6 @@ namespace drake {
 namespace multibody {
 namespace internal {
 
-// Data structure to store the topological information associated with a
-// JointActuator.
-struct JointActuatorTopology {
-  // Returns `true` if all members of `this` topology are exactly equal to the
-  // members of `other`.
-  bool operator==(const JointActuatorTopology& other) const = default;
-
-  // Unique index in the MultibodyTree.
-  JointActuatorIndex index{0};
-  // For an actuator in a MultibodyTree model, this dof start index corresponds
-  // to the first entry in the global array u containing all actuation values
-  // for the entire model. Actuator dof start indexes are assigned in the order
-  // actuators are added to the model, that is, in the order of
-  // JointActuatorIndex.
-  int actuator_dof_start{-1};
-  // The number of dofs actuated by this actuator.
-  int num_dofs{-1};
-};
-
 // Data structure to store the topological information associated with an
 // entire SpanningForest of a MultibodyPlant.
 class MultibodyTreeTopology {
@@ -50,17 +31,9 @@ class MultibodyTreeTopology {
   // members of `other`.
   bool operator==(const MultibodyTreeTopology& other) const;
 
-  // Returns the number of joint actuators in the topology.
-  int num_joint_actuators() const { return ssize(joint_actuator_topology_); }
-
   // Returns the number of levels in the forest topology.
   int forest_height() const { return forest_height_; }
 
-  // Returns a constant reference to the corresponding JointActuatorTopology
-  // given a JointActuatorIndex.
-  const JointActuatorTopology& get_joint_actuator_topology(
-      JointActuatorIndex index) const;
-
   // Returns the number of trees in the "forest" topology of the entire system.
   // We refer to as "tree" a subgraph in the topology having a tree structure
   // and whose base node connects to the world. The world does not belong to any
@@ -112,22 +85,6 @@ class MultibodyTreeTopology {
     return num_tree_velocities(tree_index) > 0;
   }
 
-  // Creates and adds a new JointActuatorTopology for a joint with `num_dofs`
-  // degrees of freedom.
-  //
-  // @throws std::exception if FinalizeTopology() was already called on `this`
-  // topology.
-  // @pre the given index is the one for the next available slot
-  void add_joint_actuator_topology(JointActuatorIndex actuator_index,
-                                   int num_dofs);
-
-  // Removes `actuator_index` from the list of joint actuators. The
-  // `actuator_dof_start` will be modified if necessary for other actuators.
-  // @throws std::exception if called post-Finalize.
-  // @throws std::exception if the actuator with the index `actuator_index` has
-  // already been removed.
-  void RemoveJointActuatorTopology(JointActuatorIndex actuator_index);
-
   // This method must be called by MultibodyTree::Finalize() after all
   // topological elements in the plant (rigid bodies, joints, constraints) were
   // added and a suitable SpanningForest built.
@@ -175,7 +132,6 @@ class MultibodyTreeTopology {
   int forest_height_{-1};
 
   // Topological elements:
-  std::vector<std::optional<JointActuatorTopology>> joint_actuator_topology_;
 
   // Total number of generalized positions and velocities in the MultibodyTree
   // model.
diff --git a/multibody/tree/test/joint_actuator_test.cc b/multibody/tree/test/joint_actuator_test.cc
index f9679e965fe8..97bc714656ab 100644
--- a/multibody/tree/test/joint_actuator_test.cc
+++ b/multibody/tree/test/joint_actuator_test.cc
@@ -67,10 +67,8 @@ GTEST_TEST(JointActuatorTest, JointActuatorLimitTest) {
       tree.AddJointActuator("act3", body3_body2, kZeroEffortLimit),
       "Effort limit must be strictly positive!");
 
-  DRAKE_EXPECT_THROWS_MESSAGE(actuator1.input_start(),
-                              ".*after the MultibodyPlant is finalized.");
-  DRAKE_EXPECT_THROWS_MESSAGE(actuator1.num_inputs(),
-                              ".*after the MultibodyPlant is finalized.");
+  EXPECT_EQ(actuator1.input_start(), 0);  // First & only actuated dof.
+  EXPECT_EQ(actuator1.num_inputs(), 1);   // Prismatic is 1 dof.
 
   const auto body4 = &tree.AddRigidBody("body4", M_NaN());
   const Joint<double>& body4_world =

From 090f7fecca86b2576e596441397cfa76a4d1795c Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Tue, 30 Sep 2025 15:37:21 -0700
Subject: [PATCH 6/7] Tests and MbP don't use MultibodyTreeTopology now.

MbTTopology functionality stripped to only is_valid. Move that to MbT and nuke MbTTopology altogether.
---
 multibody/plant/deformable_driver.cc          |  34 ++-
 multibody/plant/discrete_update_manager.cc    |  77 +++----
 multibody/plant/discrete_update_manager.h     |  11 +-
 multibody/plant/multibody_plant.cc            |  30 +--
 multibody/plant/sap_driver.cc                 | 205 +++++++++---------
 multibody/plant/sap_driver.h                  |   4 +-
 multibody/plant/tamsi_driver.cc               |  10 +-
 multibody/plant/tamsi_driver.h                |   4 +-
 .../test/compliant_contact_manager_test.cc    |   4 -
 .../test/compliant_contact_manager_tester.h   |  19 +-
 .../test/sap_driver_joint_limits_test.cc      |  13 +-
 multibody/plant/test/sap_driver_test.cc       |  14 +-
 multibody/topology/spanning_forest.h          |   8 +-
 multibody/topology/spanning_forest_inlines.h  |  10 +-
 multibody/topology/spanning_forest_tree.h     |   3 +
 .../topology/test/spanning_forest_test.cc     |  28 +--
 multibody/tree/multibody_tree.cc              |  27 +--
 multibody/tree/multibody_tree.h               |   2 +-
 multibody/tree/multibody_tree_topology.cc     |  67 +-----
 multibody/tree/multibody_tree_topology.h      | 101 ---------
 .../tree/test/multibody_tree_creation_test.cc | 104 ++-------
 21 files changed, 265 insertions(+), 510 deletions(-)

diff --git a/multibody/plant/deformable_driver.cc b/multibody/plant/deformable_driver.cc
index cb6d18a1ff3f..a58a83b0f08e 100644
--- a/multibody/plant/deformable_driver.cc
+++ b/multibody/plant/deformable_driver.cc
@@ -318,8 +318,8 @@ DeformableDriver<T>::ComputeContactDataForDeformable(
     }
     scaled_Jv_v_WGc_C.SetFromTriplets(triplets);
     result.v_WGc.emplace_back(v_WGc);
-    const TreeIndex tree_index(
-        manager_->internal_tree().get_topology().num_trees() + body_index);
+    const TreeIndex tree_index(manager_->internal_tree().forest().num_trees() +
+                               body_index);
     result.jacobian.emplace_back(tree_index,
                                  MatrixBlock<T>(std::move(scaled_Jv_v_WGc_C)));
   }
@@ -343,14 +343,15 @@ DeformableDriver<T>::ComputeContactDataForRigid(
       manager_->plant()
           .EvalBodyPoseInWorld(context, manager_->plant().get_body(body_index))
           .translation();
-  const MultibodyTreeTopology& tree_topology =
-      manager_->internal_tree().get_topology();
-  const TreeIndex tree_index = tree_topology.body_to_tree_index(body_index);
+  if (body_index == world_index()) return result;
+
+  const SpanningForest& forest = manager_->internal_tree().forest();
+  const TreeIndex tree_index = forest.link_to_tree_index(body_index);
+  const SpanningForest::Tree& tree = forest.trees(tree_index);
+  const int tree_nv = tree.nv();
   /* If the body is welded to world, then everything is trivially zero (as
    indicated by empty jacobian and velocity vectors). */
-  if (!tree_topology.tree_has_dofs(tree_index)) {
-    return result;
-  }
+  if (tree_nv == 0) return result;
 
   const Eigen::VectorBlock<const VectorX<T>> rigid_v0 =
       manager_->plant().GetVelocities(context);
@@ -367,9 +368,7 @@ DeformableDriver<T>::ComputeContactDataForRigid(
         p_WC, frame_W, frame_W, &Jv_v_WGc_W);
     result.v_WGc.emplace_back(Jv_v_WGc_W * rigid_v0);
     Matrix3X<T> J = surface.R_WCs()[i].matrix().transpose() *
-                    Jv_v_WGc_W.middleCols(
-                        tree_topology.tree_velocities_start_in_v(tree_index),
-                        tree_topology.num_tree_velocities(tree_index));
+                    Jv_v_WGc_W.middleCols(tree.v_start(), tree_nv);
     result.jacobian.emplace_back(tree_index, MatrixBlock<T>(std::move(J)));
   }
   return result;
@@ -616,8 +615,7 @@ void DeformableDriver<T>::AppendDeformableRigidFixedConstraintKinematics(
    and rigid bodies are mutually exclusive, and Jv_v_WAp = 0 for rigid dofs
    and Jv_v_WBq = 0 for deformable dofs. */
   const int nv = manager_->plant().num_velocities();
-  const MultibodyTreeTopology& tree_topology =
-      manager_->internal_tree().get_topology();
+  const SpanningForest& forest = manager_->internal_tree().forest();
   const auto& configurations =
       manager_->plant()
           .get_deformable_body_configuration_output_port()
@@ -644,7 +642,7 @@ void DeformableDriver<T>::AppendDeformableRigidFixedConstraintKinematics(
         EvalConstraintParticipation(context, index);
     // Each deformable body forms its own clique and are indexed in inceasing
     // DeformableBodyIndex order and placed after all rigid cliques.
-    const TreeIndex clique_index_A(tree_topology.num_trees() + index);
+    const TreeIndex clique_index_A(forest.num_trees() + index);
     const GeometryId geometry_id = body.geometry_id();
     const PartialPermutation& vertex_permutation =
         EvalVertexPermutation(context, geometry_id);
@@ -660,7 +658,6 @@ void DeformableDriver<T>::AppendDeformableRigidFixedConstraintKinematics(
       jacobian_triplets.reserve(num_vertices_in_constraint);
       /* The Jacobian block for the rigid body B. */
       const BodyIndex index_B = spec.body_B;
-      const TreeIndex tree_index = tree_topology.body_to_tree_index(index_B);
       const RigidBody<T>& rigid_body = manager_->plant().get_body(index_B);
       const math::RigidTransform<T>& X_WB =
           manager_->plant().EvalBodyPoseInWorld(context, rigid_body);
@@ -698,6 +695,7 @@ void DeformableDriver<T>::AppendDeformableRigidFixedConstraintKinematics(
           index + manager_->plant().num_bodies();  // Deformable body.
       const int object_B = index_B;                // Rigid body.
 
+      const TreeIndex tree_index = forest.link_to_tree_index(index_B);
       if (tree_index.is_valid()) {
         /* Rigid body is not welded to world. */
         const int clique_index_B = tree_index;
@@ -707,9 +705,9 @@ void DeformableDriver<T>::AppendDeformableRigidFixedConstraintKinematics(
             context, JacobianWrtVariable::kV, rigid_body.body_frame(), frame_W,
             Eigen::Map<const Matrix3X<T>>(p_WQs.data(), 3, p_WQs.size() / 3),
             frame_W, frame_W, &Jv_v_WBq);
-        MatrixBlock<T> jacobian_block_B(Jv_v_WBq.middleCols(
-            tree_topology.tree_velocities_start_in_v(tree_index),
-            tree_topology.num_tree_velocities(tree_index)));
+        const SpanningForest::Tree& tree = forest.trees(tree_index);
+        MatrixBlock<T> jacobian_block_B(
+            Jv_v_WBq.middleCols(tree.v_start(), tree.nv()));
         SapConstraintJacobian<T> J(clique_index_A, std::move(jacobian_block_A),
                                    clique_index_B, std::move(jacobian_block_B));
         result->emplace_back(object_A, std::move(p_WPs), object_B,
diff --git a/multibody/plant/discrete_update_manager.cc b/multibody/plant/discrete_update_manager.cc
index 105d85b209fa..b31a1bf8a5b1 100644
--- a/multibody/plant/discrete_update_manager.cc
+++ b/multibody/plant/discrete_update_manager.cc
@@ -3,6 +3,8 @@
 #include <limits>
 #include <utility>
 
+#include "multibody/topology/spanning_forest.h"
+
 #include "drake/multibody/plant/contact_properties.h"
 #include "drake/multibody/plant/deformable_driver.h"
 #include "drake/multibody/plant/deformable_model.h"
@@ -20,8 +22,6 @@ using drake::math::RigidTransform;
 using drake::math::RotationMatrix;
 using drake::multibody::contact_solvers::internal::ContactSolverResults;
 using drake::multibody::contact_solvers::internal::MatrixBlock;
-using drake::multibody::internal::DiscreteContactPair;
-using drake::multibody::internal::MultibodyTreeTopology;
 using drake::systems::Context;
 using drake::systems::DependencyTicket;
 
@@ -212,11 +212,6 @@ const MultibodyPlant<T>& DiscreteUpdateManager<T>::plant() const {
   return *plant_;
 }
 
-template <typename T>
-const MultibodyTree<T>& DiscreteUpdateManager<T>::internal_tree() const {
-  return MultibodyPlantDiscreteUpdateManagerAttorney<T>::internal_tree(plant());
-}
-
 template <typename T>
 void DiscreteUpdateManager<T>::CalcNonContactForces(
     const drake::systems::Context<T>& context,
@@ -644,7 +639,7 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForPointContact(
   contact_pairs->Reserve(num_point_contacts, 0, 0);
   const geometry::SceneGraphInspector<T>& inspector =
       plant().EvalSceneGraphInspector(context);
-  const MultibodyTreeTopology& topology = internal_tree().get_topology();
+  const SpanningForest& forest = get_forest();
   const Eigen::VectorBlock<const VectorX<T>> v = plant().GetVelocities(context);
   const Frame<T>& frame_W = plant().world_frame();
 
@@ -663,10 +658,13 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForPointContact(
     const BodyIndex body_B_index = FindBodyByGeometryId(pair.id_B);
     const RigidBody<T>& body_B = plant().get_body(body_B_index);
 
-    const TreeIndex treeA_index = topology.body_to_tree_index(body_A_index);
-    const TreeIndex treeB_index = topology.body_to_tree_index(body_B_index);
-    const bool treeA_has_dofs = topology.tree_has_dofs(treeA_index);
-    const bool treeB_has_dofs = topology.tree_has_dofs(treeB_index);
+    const TreeIndex& tree_A_index = forest.link_to_tree_index(body_A_index);
+    const bool tree_A_has_dofs =
+        tree_A_index.is_valid() && forest.trees(tree_A_index).has_dofs();
+
+    const TreeIndex& tree_B_index = forest.link_to_tree_index(body_B_index);
+    const bool tree_B_has_dofs =
+        tree_B_index.is_valid() && forest.trees(tree_B_index).has_dofs();
 
     const T kA = GetPointContactStiffness(
         pair.id_A, default_contact_stiffness(), inspector);
@@ -711,25 +709,21 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForPointContact(
     jacobian_blocks.reserve(2);
 
     // Tree A contribution to contact Jacobian Jv_W_AcBc_C.
-    if (treeA_has_dofs) {
-      Matrix3X<T> J =
-          R_WC.matrix().transpose() *
-          Jv_AcBc_W.middleCols(
-              tree_topology().tree_velocities_start_in_v(treeA_index),
-              tree_topology().num_tree_velocities(treeA_index));
-      jacobian_blocks.emplace_back(treeA_index, MatrixBlock<T>(std::move(J)));
+    if (tree_A_has_dofs) {
+      const SpanningForest::Tree& tree_A = forest.trees(tree_A_index);
+      Matrix3X<T> J = R_WC.matrix().transpose() *
+                      Jv_AcBc_W.middleCols(tree_A.v_start(), tree_A.nv());
+      jacobian_blocks.emplace_back(tree_A_index, MatrixBlock<T>(std::move(J)));
     }
 
     // Tree B contribution to contact Jacobian Jv_W_AcBc_C.
     // This contribution must be added only if B is different from A.
-    if ((treeB_has_dofs && !treeA_has_dofs) ||
-        (treeB_has_dofs && treeB_index != treeA_index)) {
-      Matrix3X<T> J =
-          R_WC.matrix().transpose() *
-          Jv_AcBc_W.middleCols(
-              tree_topology().tree_velocities_start_in_v(treeB_index),
-              tree_topology().num_tree_velocities(treeB_index));
-      jacobian_blocks.emplace_back(treeB_index, MatrixBlock<T>(std::move(J)));
+    if ((tree_B_has_dofs && !tree_A_has_dofs) ||
+        (tree_B_has_dofs && tree_B_index != tree_A_index)) {
+      const SpanningForest::Tree& tree_B = forest.trees(tree_B_index);
+      Matrix3X<T> J = R_WC.matrix().transpose() *
+                      Jv_AcBc_W.middleCols(tree_B.v_start(), tree_B.nv());
+      jacobian_blocks.emplace_back(tree_B_index, MatrixBlock<T>(std::move(J)));
     }
 
     // Contact stiffness and damping
@@ -812,7 +806,7 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForHydroelasticContact(
   contact_pairs->Reserve(0, num_hydro_contacts, 0);
   const geometry::SceneGraphInspector<T>& inspector =
       plant().EvalSceneGraphInspector(context);
-  const MultibodyTreeTopology& topology = internal_tree().get_topology();
+  const SpanningForest& forest = get_forest();
   const Eigen::VectorBlock<const VectorX<T>> v = plant().GetVelocities(context);
   const Frame<T>& frame_W = plant().world_frame();
 
@@ -837,10 +831,13 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForHydroelasticContact(
     const BodyIndex body_B_index = FindBodyByGeometryId(s.id_N());
     const RigidBody<T>& body_B = plant().get_body(body_B_index);
 
-    const TreeIndex& tree_A_index = topology.body_to_tree_index(body_A_index);
-    const TreeIndex& tree_B_index = topology.body_to_tree_index(body_B_index);
-    const bool treeA_has_dofs = topology.tree_has_dofs(tree_A_index);
-    const bool treeB_has_dofs = topology.tree_has_dofs(tree_B_index);
+    const TreeIndex& tree_A_index = forest.link_to_tree_index(body_A_index);
+    const bool treeA_has_dofs =
+        tree_A_index.is_valid() && forest.trees(tree_A_index).has_dofs();
+
+    const TreeIndex& tree_B_index = forest.link_to_tree_index(body_B_index);
+    const bool treeB_has_dofs =
+        tree_B_index.is_valid() && forest.trees(tree_B_index).has_dofs();
 
     // TODO(amcastro-tri): Consider making the modulus required, instead of
     // a default infinite value.
@@ -951,11 +948,9 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForHydroelasticContact(
 
         // Tree A contribution to contact Jacobian Jv_W_AcBc_C.
         if (treeA_has_dofs) {
-          Matrix3X<T> J =
-              R_WC.matrix().transpose() *
-              Jv_AcBc_W.middleCols(
-                  tree_topology().tree_velocities_start_in_v(tree_A_index),
-                  tree_topology().num_tree_velocities(tree_A_index));
+          const SpanningForest::Tree& tree_A = forest.trees(tree_A_index);
+          Matrix3X<T> J = R_WC.matrix().transpose() *
+                          Jv_AcBc_W.middleCols(tree_A.v_start(), tree_A.nv());
           jacobian_blocks.emplace_back(tree_A_index,
                                        MatrixBlock<T>(std::move(J)));
         }
@@ -964,11 +959,9 @@ void DiscreteUpdateManager<T>::AppendDiscreteContactPairsForHydroelasticContact(
         // This contribution must be added only if B is different from A.
         if ((treeB_has_dofs && !treeA_has_dofs) ||
             (treeB_has_dofs && tree_B_index != tree_A_index)) {
-          Matrix3X<T> J =
-              R_WC.matrix().transpose() *
-              Jv_AcBc_W.middleCols(
-                  tree_topology().tree_velocities_start_in_v(tree_B_index),
-                  tree_topology().num_tree_velocities(tree_B_index));
+          const SpanningForest::Tree& tree_B = forest.trees(tree_B_index);
+          Matrix3X<T> J = R_WC.matrix().transpose() *
+                          Jv_AcBc_W.middleCols(tree_B.v_start(), tree_B.nv());
           jacobian_blocks.emplace_back(tree_B_index,
                                        MatrixBlock<T>(std::move(J)));
         }
diff --git a/multibody/plant/discrete_update_manager.h b/multibody/plant/discrete_update_manager.h
index 3aa3cf20bbc8..cfa17c11dd0a 100644
--- a/multibody/plant/discrete_update_manager.h
+++ b/multibody/plant/discrete_update_manager.h
@@ -220,7 +220,9 @@ class DiscreteUpdateManager : public ScalarConvertibleComponent<T> {
   /* N.B. Keep the spelling and order of declarations here identical to the
    MultibodyPlantDiscreteUpdateManagerAttorney spelling and order of same. */
 
-  const MultibodyTree<T>& internal_tree() const;
+  const MultibodyTree<T>& internal_tree() const {
+    return GetInternalTree(this->plant());
+  }
 
   systems::CacheEntry& DeclareCacheEntry(std::string description,
                                          systems::ValueProducer,
@@ -236,13 +238,8 @@ class DiscreteUpdateManager : public ScalarConvertibleComponent<T> {
 
   /* @} */
 
-  const MultibodyTreeTopology& tree_topology() const {
-    return internal::GetInternalTree(this->plant()).get_topology();
-  }
+  const SpanningForest& get_forest() const { return internal_tree().forest(); }
 
-  const internal::SpanningForest& forest() const {
-    return internal::GetInternalTree(this->plant()).forest();
-  }
   /* Returns the pointer to the DeformableDriver owned by `this` manager if one
    exists. Otherwise, returns nullptr. */
   const DeformableDriver<double>* deformable_driver() const {
diff --git a/multibody/plant/multibody_plant.cc b/multibody/plant/multibody_plant.cc
index 8ce78e046b9d..f6466d0e2e98 100644
--- a/multibody/plant/multibody_plant.cc
+++ b/multibody/plant/multibody_plant.cc
@@ -2997,18 +2997,18 @@ void MultibodyPlant<T>::CalcGeometryContactData(
     return;
   }
   const auto& geometry_id_to_body_index = geometry_id_to_body_index_;
-  const internal::MultibodyTreeTopology& topology =
-      internal_tree().get_topology();
+  const internal::SpanningForest& forest = internal_tree().forest();
   const std::vector<std::vector<int>>& per_tree_unlocked_indices =
       joint_locking.unlocked_velocity_indices_per_tree;
   const auto is_irrelevant_geometry =
-      [&geometry_id_to_body_index, &topology,
+      [&geometry_id_to_body_index, &forest,
        &per_tree_unlocked_indices](GeometryId geometry_id) {
         // Checks whether `geometry_id` belongs to a zero-dof tree.
         const BodyIndex body_index = geometry_id_to_body_index.at(geometry_id);
         const internal::TreeIndex tree_index =
-            topology.body_to_tree_index(body_index);
-        return !topology.tree_has_dofs(tree_index) ||
+            forest.link_to_tree_index(body_index);
+        const internal::SpanningForest::Tree& tree = forest.trees(tree_index);
+        return !tree.has_dofs() ||
                per_tree_unlocked_indices[tree_index].size() == 0;
       };
   const auto is_irrelevant_point_pair =
@@ -3043,7 +3043,7 @@ void MultibodyPlant<T>::CalcJointLocking(
     internal::JointLockingCacheData<T>* data) const {
   DRAKE_DEMAND(data != nullptr);
 
-  const auto& topology = internal_tree().get_topology();
+  const internal::SpanningForest& forest = internal_tree().forest();
 
   auto& unlocked = data->unlocked_velocity_indices;
   auto& locked = data->locked_velocity_indices;
@@ -3054,8 +3054,8 @@ void MultibodyPlant<T>::CalcJointLocking(
   locked_per_tree.clear();
   unlocked.resize(num_velocities());
   locked.resize(num_velocities());
-  unlocked_per_tree.resize(topology.num_trees());
-  locked_per_tree.resize(topology.num_trees());
+  unlocked_per_tree.resize(forest.num_trees());
+  locked_per_tree.resize(forest.num_trees());
 
   int unlocked_cursor = 0;
   int locked_cursor = 0;
@@ -3088,15 +3088,17 @@ void MultibodyPlant<T>::CalcJointLocking(
   internal::DemandIndicesValid(locked, num_velocities());
 
   for (int dof : unlocked) {
-    const internal::TreeIndex tree = topology.velocity_to_tree_index(dof);
-    const int tree_dof = dof - topology.tree_velocities_start_in_v(tree);
-    unlocked_per_tree[tree].push_back(tree_dof);
+    const internal::TreeIndex tree_index = forest.v_to_tree_index(dof);
+    const internal::SpanningForest::Tree& tree = forest.trees(tree_index);
+    const int tree_dof = dof - tree.v_start();
+    unlocked_per_tree[tree_index].push_back(tree_dof);
   }
 
   for (int dof : locked) {
-    const internal::TreeIndex tree = topology.velocity_to_tree_index(dof);
-    const int tree_dof = dof - topology.tree_velocities_start_in_v(tree);
-    locked_per_tree[tree].push_back(tree_dof);
+    const internal::TreeIndex tree_index = forest.v_to_tree_index(dof);
+    const internal::SpanningForest::Tree& tree = forest.trees(tree_index);
+    const int tree_dof = dof - tree.v_start();
+    locked_per_tree[tree_index].push_back(tree_dof);
   }
 }
 
diff --git a/multibody/plant/sap_driver.cc b/multibody/plant/sap_driver.cc
index a23ad030e451..a71f222cc7c8 100644
--- a/multibody/plant/sap_driver.cc
+++ b/multibody/plant/sap_driver.cc
@@ -134,7 +134,8 @@ template <typename T>
 void SapDriver<T>::CalcLinearDynamicsMatrix(const systems::Context<T>& context,
                                             std::vector<MatrixX<T>>* A) const {
   DRAKE_DEMAND(A != nullptr);
-  A->resize(tree_topology().num_trees());
+  const SpanningForest& forest = get_forest();
+  A->resize(forest.num_trees());
   const int nv = plant().num_velocities();
 
   // TODO(amcastro-tri): consider placing the computation of the dense mass
@@ -152,9 +153,10 @@ void SapDriver<T>::CalcLinearDynamicsMatrix(const systems::Context<T>& context,
   //   A = ∂m/∂v = (M + dt⋅D)
   M.diagonal() += plant().time_step() * plant().EvalJointDampingCache(context);
 
-  for (TreeIndex t(0); t < tree_topology().num_trees(); ++t) {
-    const int tree_start_in_v = tree_topology().tree_velocities_start_in_v(t);
-    const int tree_nv = tree_topology().num_tree_velocities(t);
+  for (TreeIndex t(0); t < forest.num_trees(); ++t) {
+    const SpanningForest::Tree& tree = forest.trees(t);
+    const int tree_start_in_v = tree.v_start();
+    const int tree_nv = tree.nv();
     (*A)[t] = M.block(tree_start_in_v, tree_start_in_v, tree_nv, tree_nv);
   }
 
@@ -321,6 +323,7 @@ void SapDriver<T>::AddLimitConstraints(const systems::Context<T>& context,
   const double stiffness = 1.0e12;
   const double dissipation_time_scale = dt;
 
+  const SpanningForest& forest = get_forest();
   for (JointIndex joint_index : plant().GetJointIndices()) {
     const Joint<T>& joint = plant().get_joint(joint_index);
     // We only support limits for 1 DOF joints for which we know that q̇ = v.
@@ -328,11 +331,10 @@ void SapDriver<T>::AddLimitConstraints(const systems::Context<T>& context,
       const double lower_limit = joint.position_lower_limits()[0];
       const double upper_limit = joint.position_upper_limits()[0];
       const int velocity_start = joint.velocity_start();
-      const TreeIndex tree_index =
-          tree_topology().velocity_to_tree_index(velocity_start);
-      const int tree_nv = tree_topology().num_tree_velocities(tree_index);
-      const int tree_velocity_start =
-          tree_topology().tree_velocities_start_in_v(tree_index);
+      const TreeIndex tree_index = forest.v_to_tree_index(velocity_start);
+      const SpanningForest::Tree& tree = forest.trees(tree_index);
+      const int tree_nv = tree.nv();
+      const int tree_velocity_start = tree.v_start();
       const int tree_dof = velocity_start - tree_velocity_start;
 
       // Current configuration position.
@@ -396,6 +398,7 @@ void SapDriver<T>::AddCouplerConstraints(const systems::Context<T>& context,
   const std::map<MultibodyConstraintId, bool>& constraint_active_status =
       manager().GetConstraintActiveStatus(context);
 
+  const SpanningForest& forest = get_forest();
   for (const auto& [id, info] : manager().coupler_constraints_specs()) {
     // Skip this constraint if it is not active.
     if (!constraint_active_status.at(id)) continue;
@@ -403,24 +406,25 @@ void SapDriver<T>::AddCouplerConstraints(const systems::Context<T>& context,
     const Joint<T>& joint1 = plant().get_joint(info.joint1_index);
     const int dof0 = joint0.velocity_start();
     const int dof1 = joint1.velocity_start();
-    const TreeIndex tree0 = tree_topology().velocity_to_tree_index(dof0);
-    const TreeIndex tree1 = tree_topology().velocity_to_tree_index(dof1);
+    const TreeIndex tree0_index = forest.v_to_tree_index(dof0);
+    const TreeIndex tree1_index = forest.v_to_tree_index(dof1);
 
     // Sanity check.
-    DRAKE_DEMAND(tree0.is_valid() && tree1.is_valid());
+    DRAKE_DEMAND(tree0_index.is_valid() && tree1_index.is_valid());
+
+    const SpanningForest::Tree& tree0 = forest.trees(tree0_index);
+    const SpanningForest::Tree& tree1 = forest.trees(tree1_index);
 
     // DOFs local to their tree.
-    const int tree_dof0 =
-        dof0 - tree_topology().tree_velocities_start_in_v(tree0);
-    const int tree_dof1 =
-        dof1 - tree_topology().tree_velocities_start_in_v(tree1);
+    const int tree_dof0 = dof0 - tree0.v_start();
+    const int tree_dof1 = dof1 - tree1.v_start();
 
-    const int tree_nv0 = tree_topology().num_tree_velocities(tree0);
-    const int tree_nv1 = tree_topology().num_tree_velocities(tree1);
+    const int tree_nv0 = tree0.nv();
+    const int tree_nv1 = tree1.nv();
 
     const typename SapCouplerConstraint<T>::Kinematics kinematics{
-        tree0,           tree_dof0,  tree_nv0, joint0.GetOnePosition(context),
-        tree1,           tree_dof1,  tree_nv1, joint1.GetOnePosition(context),
+        tree0_index,     tree_dof0,  tree_nv0, joint0.GetOnePosition(context),
+        tree1_index,     tree_dof1,  tree_nv1, joint1.GetOnePosition(context),
         info.gear_ratio, info.offset};
 
     problem->AddConstraint(
@@ -477,10 +481,14 @@ void SapDriver<T>::AddDistanceConstraints(const systems::Context<T>& context,
     // SapDistanceConstraint.
     auto make_constraint_jacobian = [this, &Jv_ApBq_W](BodyIndex bodyA,
                                                        BodyIndex bodyB) {
-      const TreeIndex treeA_index = tree_topology().body_to_tree_index(bodyA);
-      const TreeIndex treeB_index = tree_topology().body_to_tree_index(bodyB);
-      const bool treeA_has_dofs = tree_topology().tree_has_dofs(treeA_index);
-      const bool treeB_has_dofs = tree_topology().tree_has_dofs(treeB_index);
+      const SpanningForest& forest = get_forest();
+      const TreeIndex treeA_index = forest.link_to_tree_index(bodyA);
+      const SpanningForest::Tree& treeA = forest.trees(treeA_index);
+      const bool treeA_has_dofs = treeA.has_dofs();
+
+      const TreeIndex treeB_index = forest.link_to_tree_index(bodyB);
+      const SpanningForest::Tree& treeB = forest.trees(treeB_index);
+      const bool treeB_has_dofs = treeB.has_dofs();
 
       // Sanity check at least one body is not World or anchored to World.
       DRAKE_DEMAND(treeA_has_dofs || treeB_has_dofs);
@@ -491,18 +499,12 @@ void SapDriver<T>::AddDistanceConstraints(const systems::Context<T>& context,
           !treeA_has_dofs || !treeB_has_dofs || treeA_index == treeB_index;
 
       if (single_tree) {
-        const TreeIndex tree_index = treeA_has_dofs ? treeA_index : treeB_index;
-        MatrixX<T> Jtree = Jv_ApBq_W.middleCols(
-            tree_topology().tree_velocities_start_in_v(tree_index),
-            tree_topology().num_tree_velocities(tree_index));
-        return SapConstraintJacobian<T>(tree_index, std::move(Jtree));
+        const SpanningForest::Tree& tree = treeA_has_dofs ? treeA : treeB;
+        MatrixX<T> Jtree = Jv_ApBq_W.middleCols(tree.v_start(), tree.nv());
+        return SapConstraintJacobian<T>(tree.index(), std::move(Jtree));
       } else {
-        MatrixX<T> JA = Jv_ApBq_W.middleCols(
-            tree_topology().tree_velocities_start_in_v(treeA_index),
-            tree_topology().num_tree_velocities(treeA_index));
-        MatrixX<T> JB = Jv_ApBq_W.middleCols(
-            tree_topology().tree_velocities_start_in_v(treeB_index),
-            tree_topology().num_tree_velocities(treeB_index));
+        MatrixX<T> JA = Jv_ApBq_W.middleCols(treeA.v_start(), treeA.nv());
+        MatrixX<T> JB = Jv_ApBq_W.middleCols(treeB.v_start(), treeB.nv());
         return SapConstraintJacobian<T>(treeA_index, std::move(JA), treeB_index,
                                         std::move(JB));
       }
@@ -568,12 +570,11 @@ void SapDriver<T>::AddBallConstraints(
     // Jacobian for the relative velocity v_PQ_W, as required by
     // SapDistanceConstraint.
     auto make_constraint_jacobian = [this, &Jv_ApBq_W, &body_A, &body_B]() {
-      const TreeIndex treeA_index =
-          tree_topology().body_to_tree_index(body_A.index());
-      const TreeIndex treeB_index =
-          tree_topology().body_to_tree_index(body_B.index());
-      const bool treeA_has_dofs = tree_topology().tree_has_dofs(treeA_index);
-      const bool treeB_has_dofs = tree_topology().tree_has_dofs(treeB_index);
+      const SpanningForest& forest = get_forest();
+      const TreeIndex treeA_index = forest.link_to_tree_index(body_A.index());
+      const TreeIndex treeB_index = forest.link_to_tree_index(body_B.index());
+      const bool treeA_has_dofs = forest.trees(treeA_index).has_dofs();
+      const bool treeB_has_dofs = forest.trees(treeB_index).has_dofs();
 
       // TODO(joemasterjohn): Move this exception up to the plant level so that
       // it fails as fast as possible. Currently, the earliest this can happen
@@ -593,17 +594,14 @@ void SapDriver<T>::AddBallConstraints(
 
       if (single_tree) {
         const TreeIndex tree_index = treeA_has_dofs ? treeA_index : treeB_index;
-        MatrixX<T> Jtree = Jv_ApBq_W.middleCols(
-            tree_topology().tree_velocities_start_in_v(tree_index),
-            tree_topology().num_tree_velocities(tree_index));
+        const SpanningForest::Tree& tree = forest.trees(tree_index);
+        MatrixX<T> Jtree = Jv_ApBq_W.middleCols(tree.v_start(), tree.nv());
         return SapConstraintJacobian<T>(tree_index, std::move(Jtree));
       } else {
-        MatrixX<T> JA = Jv_ApBq_W.middleCols(
-            tree_topology().tree_velocities_start_in_v(treeA_index),
-            tree_topology().num_tree_velocities(treeA_index));
-        MatrixX<T> JB = Jv_ApBq_W.middleCols(
-            tree_topology().tree_velocities_start_in_v(treeB_index),
-            tree_topology().num_tree_velocities(treeB_index));
+        const SpanningForest::Tree& treeA = forest.trees(treeA_index);
+        const SpanningForest::Tree& treeB = forest.trees(treeB_index);
+        MatrixX<T> JA = Jv_ApBq_W.middleCols(treeA.v_start(), treeA.nv());
+        MatrixX<T> JB = Jv_ApBq_W.middleCols(treeB.v_start(), treeB.nv());
         return SapConstraintJacobian<T>(treeA_index, std::move(JA), treeB_index,
                                         std::move(JB));
       }
@@ -672,12 +670,15 @@ void SapDriver<T>::AddWeldConstraints(
     auto make_constraint_jacobian = [this, &J_W_AmBm](
                                         const RigidBody<T>& bodyA,
                                         const RigidBody<T>& bodyB) {
-      const TreeIndex treeA_index =
-          tree_topology().body_to_tree_index(bodyA.index());
-      const TreeIndex treeB_index =
-          tree_topology().body_to_tree_index(bodyB.index());
-      const bool treeA_has_dofs = tree_topology().tree_has_dofs(treeA_index);
-      const bool treeB_has_dofs = tree_topology().tree_has_dofs(treeB_index);
+      const SpanningForest& forest = get_forest();
+
+      const TreeIndex treeA_index = forest.link_to_tree_index(bodyA.index());
+      const SpanningForest::Tree& treeA = forest.trees(treeA_index);
+      const bool treeA_has_dofs = treeA.has_dofs();
+
+      const TreeIndex treeB_index = forest.link_to_tree_index(bodyB.index());
+      const SpanningForest::Tree& treeB = forest.trees(treeB_index);
+      const bool treeB_has_dofs = treeB.has_dofs();
 
       // TODO(joemasterjohn): Move this exception up to the plant level so
       //  that it fails as fast as possible. Currently, the earliest this can
@@ -696,18 +697,12 @@ void SapDriver<T>::AddWeldConstraints(
           !treeA_has_dofs || !treeB_has_dofs || treeA_index == treeB_index;
 
       if (single_tree) {
-        const TreeIndex tree_index = treeA_has_dofs ? treeA_index : treeB_index;
-        MatrixX<T> Jtree_W = J_W_AmBm.middleCols(
-            tree_topology().tree_velocities_start_in_v(tree_index),
-            tree_topology().num_tree_velocities(tree_index));
-        return SapConstraintJacobian<T>(tree_index, std::move(Jtree_W));
+        const SpanningForest::Tree& tree = treeA_has_dofs ? treeA : treeB;
+        MatrixX<T> Jtree_W = J_W_AmBm.middleCols(tree.v_start(), tree.nv());
+        return SapConstraintJacobian<T>(tree.index(), std::move(Jtree_W));
       } else {
-        MatrixX<T> JA_W = J_W_AmBm.middleCols(
-            tree_topology().tree_velocities_start_in_v(treeA_index),
-            tree_topology().num_tree_velocities(treeA_index));
-        MatrixX<T> JB_W = J_W_AmBm.middleCols(
-            tree_topology().tree_velocities_start_in_v(treeB_index),
-            tree_topology().num_tree_velocities(treeB_index));
+        MatrixX<T> JA_W = J_W_AmBm.middleCols(treeA.v_start(), treeA.nv());
+        MatrixX<T> JB_W = J_W_AmBm.middleCols(treeB.v_start(), treeB.nv());
         return SapConstraintJacobian<T>(treeA_index, std::move(JA_W),
                                         treeB_index, std::move(JB_W));
       }
@@ -737,6 +732,7 @@ void SapDriver<T>::AddPdControllerConstraints(
   const VectorX<T> feed_forward_actuation =
       manager_->AssembleActuationInput(context);
 
+  const SpanningForest& forest = get_forest();
   for (ModelInstanceIndex model_instance_index(0);
        model_instance_index < plant().num_model_instances();
        ++model_instance_index) {
@@ -769,10 +765,10 @@ void SapDriver<T>::AddPdControllerConstraints(
 
           const T& q0 = joint.GetOnePosition(context);
           const int dof = joint.velocity_start();
-          const TreeIndex tree = tree_topology().velocity_to_tree_index(dof);
-          const int tree_dof =
-              dof - tree_topology().tree_velocities_start_in_v(tree);
-          const int tree_nv = tree_topology().num_tree_velocities(tree);
+          const TreeIndex tree_index = forest.v_to_tree_index(dof);
+          const SpanningForest::Tree& tree = forest.trees(tree_index);
+          const int tree_dof = dof - tree.v_start();
+          const int tree_nv = tree.nv();
 
           // Controller gains.
           const PdControllerGains& gains = actuator.get_controller_gains();
@@ -782,7 +778,7 @@ void SapDriver<T>::AddPdControllerConstraints(
           typename SapPdControllerConstraint<T>::Parameters parameters{
               Kp, Kd, effort_limit};
           typename SapPdControllerConstraint<T>::Configuration configuration{
-              tree, tree_dof, tree_nv, q0, qd, vd, u0};
+              tree_index, tree_dof, tree_nv, q0, qd, vd, u0};
 
           problem->AddConstraint(std::make_unique<SapPdControllerConstraint<T>>(
               std::move(configuration), std::move(parameters)));
@@ -826,6 +822,7 @@ void SapDriver<T>::AddTendonConstraints(const systems::Context<T>& context,
   const std::map<MultibodyConstraintId, bool>& constraint_active_status =
       manager().GetConstraintActiveStatus(context);
 
+  const SpanningForest& forest = get_forest();
   for (const auto& [id, info] : manager().tendon_constraints_specs()) {
     // Skip this constraint if it is not active.
     if (!constraint_active_status.at(id)) continue;
@@ -835,36 +832,37 @@ void SapDriver<T>::AddTendonConstraints(const systems::Context<T>& context,
         kBeta);
 
     // Find the set of trees that the joints of this constraint belong to.
-    TreeIndex tree0, tree1;
+    TreeIndex tree0_index, tree1_index;
     for (int i = 0; i < ssize(info.joints); ++i) {
       const Joint<T>& joint = plant().get_joint(info.joints[i]);
-      const TreeIndex tree =
-          tree_topology().velocity_to_tree_index(joint.velocity_start());
+      const TreeIndex tree_index =
+          forest.v_to_tree_index(joint.velocity_start());
       // Sanity check.
-      DRAKE_DEMAND(tree.is_valid());
+      DRAKE_DEMAND(tree_index.is_valid());
 
       // Update the first two trees that we find along the way.
-      if (!tree0.is_valid()) {
-        tree0 = tree;
-      } else if (!tree1.is_valid() && tree != tree0) {
-        tree1 = tree;
+      if (!tree0_index.is_valid()) {
+        tree0_index = tree_index;
+      } else if (!tree1_index.is_valid() && tree_index != tree0_index) {
+        tree1_index = tree_index;
       }
 
       // Constraints can have at most 2 participating cliques.
       // TODO(joemasterjohn): Fail faster by moving this detection to
-      // MultibodyPlant at Finalize() time.
-      if (tree != tree0 && tree != tree1) {
+      //  MultibodyPlant at Finalize() time.
+      if (tree_index != tree0_index && tree_index != tree1_index) {
         throw std::logic_error(
             "Creating a tendon constraint for a set of joints that belong "
             "to more than two kinematic trees is not allowed.");
       }
     }
 
-    DRAKE_DEMAND(tree0.is_valid());
+    DRAKE_DEMAND(tree0_index.is_valid());
 
     // Single clique version.
-    if (!tree1.is_valid()) {
-      const int tree0_nv = tree_topology().num_tree_velocities(tree0);
+    if (!tree1_index.is_valid()) {
+      const SpanningForest::Tree& tree0 = forest.trees(tree0_index);
+      const int tree0_nv = tree0.nv();
       VectorX<T> q0(tree0_nv);
       VectorX<T> a0(tree0_nv);
       q0.setZero();
@@ -874,14 +872,13 @@ void SapDriver<T>::AddTendonConstraints(const systems::Context<T>& context,
         const Joint<T>& joint = plant().get_joint(info.joints[i]);
         const int dof = joint.velocity_start();
         // DOFs local to their tree.
-        const int tree_dof =
-            dof - tree_topology().tree_velocities_start_in_v(tree0);
+        const int tree_dof = dof - tree0.v_start();
         q0(tree_dof) = joint.GetOnePosition(context);
         a0(tree_dof) = info.a[i];
       }
 
-      typename SapTendonConstraint<T>::Kinematics kinematics(tree0, q0, a0,
-                                                             info.offset);
+      typename SapTendonConstraint<T>::Kinematics kinematics(tree0_index, q0,
+                                                             a0, info.offset);
 
       // Only add the constraint if it is violated at q_0.
       if ((SapTendonConstraint<T>::CalcConstraintFunction(parameters,
@@ -894,8 +891,11 @@ void SapDriver<T>::AddTendonConstraints(const systems::Context<T>& context,
 
     } else {
       // 2 clique version.
-      const int tree_nv0 = tree_topology().num_tree_velocities(tree0);
-      const int tree_nv1 = tree_topology().num_tree_velocities(tree1);
+      const SpanningForest::Tree& tree0 = forest.trees(tree0_index);
+      const SpanningForest::Tree& tree1 = forest.trees(tree1_index);
+
+      const int tree_nv0 = tree0.nv();
+      const int tree_nv1 = tree1.nv();
       VectorX<T> q0(tree_nv0);
       VectorX<T> q1(tree_nv1);
       VectorX<T> a0(tree_nv0);
@@ -907,24 +907,21 @@ void SapDriver<T>::AddTendonConstraints(const systems::Context<T>& context,
 
       for (int i = 0; i < ssize(info.joints); ++i) {
         const Joint<T>& joint = plant().get_joint(info.joints[i]);
-        const TreeIndex tree =
-            tree_topology().velocity_to_tree_index(joint.velocity_start());
         const int dof = joint.velocity_start();
-        if (tree == tree0) {
-          const int tree_dof =
-              dof - tree_topology().tree_velocities_start_in_v(tree0);
+        const TreeIndex tree_index = forest.v_to_tree_index(dof);
+        if (tree_index == tree0_index) {
+          const int tree_dof = dof - tree0.v_start();
           q0(tree_dof) = joint.GetOnePosition(context);
           a0(tree_dof) = info.a[i];
         } else {
-          const int tree_dof =
-              dof - tree_topology().tree_velocities_start_in_v(tree1);
+          const int tree_dof = dof - tree1.v_start();
           q1(tree_dof) = joint.GetOnePosition(context);
           a1(tree_dof) = info.a[i];
         }
       }
 
       typename SapTendonConstraint<T>::Kinematics kinematics(
-          tree0, tree1, q0, q1, a0, a1, info.offset);
+          tree0_index, tree1_index, q0, q1, a0, a1, info.offset);
       // Only add the constraint if it is violated at q_0.
       if ((SapTendonConstraint<T>::CalcConstraintFunction(parameters,
                                                           kinematics)
@@ -1051,7 +1048,8 @@ void SapDriver<T>::AddCliqueContribution(
     const systems::Context<T>& context, int clique,
     const Eigen::Ref<const VectorX<T>>& clique_values,
     EigenPtr<VectorX<T>> values) const {
-  if (clique >= tree_topology().num_trees()) {
+  const SpanningForest& forest = get_forest();
+  if (clique >= forest.num_trees()) {
     const DeformableDriver<double>* deformable_driver =
         manager().deformable_driver();
     DRAKE_THROW_UNLESS(deformable_driver != nullptr);
@@ -1059,7 +1057,7 @@ void SapDriver<T>::AddCliqueContribution(
       const int num_deformable_dofs = values->size() - plant().num_velocities();
       Eigen::Ref<VectorX<T>> deformable_values =
           values->tail(num_deformable_dofs);
-      DeformableBodyIndex body_index(clique - tree_topology().num_trees());
+      DeformableBodyIndex body_index(clique - forest.num_trees());
       deformable_driver->EvalParticipatingVelocityMultiplexer(context)
           .Demultiplex(&deformable_values, body_index) += clique_values;
     } else {
@@ -1069,8 +1067,9 @@ void SapDriver<T>::AddCliqueContribution(
     }
   } else {
     const TreeIndex t(clique);
-    const int v_start = tree_topology().tree_velocities_start_in_v(t);
-    const int nv = tree_topology().num_tree_velocities(t);
+    const SpanningForest::Tree& tree = forest.trees(t);
+    const int v_start = tree.v_start();
+    const int nv = tree.nv();
     values->segment(v_start, nv) += clique_values;
   }
 }
diff --git a/multibody/plant/sap_driver.h b/multibody/plant/sap_driver.h
index 72207587201f..bf65004476e5 100644
--- a/multibody/plant/sap_driver.h
+++ b/multibody/plant/sap_driver.h
@@ -128,9 +128,7 @@ class SapDriver {
 
   const MultibodyPlant<T>& plant() const { return manager().plant(); }
 
-  const MultibodyTreeTopology& tree_topology() const {
-    return manager().tree_topology();
-  }
+  const SpanningForest& get_forest() const { return manager().get_forest(); }
 
   // Computes the linearized momentum equation matrix A to build the SAP
   // contact problem. The matrices for deformable bodies come after those for
diff --git a/multibody/plant/tamsi_driver.cc b/multibody/plant/tamsi_driver.cc
index fcfa4c740a7c..302c42b2b51d 100644
--- a/multibody/plant/tamsi_driver.cc
+++ b/multibody/plant/tamsi_driver.cc
@@ -4,6 +4,8 @@
 #include <string>
 #include <vector>
 
+#include "multibody/topology/spanning_forest.h"
+
 #include "drake/common/eigen_types.h"
 #include "drake/geometry/geometry_ids.h"
 #include "drake/math/rigid_transform.h"
@@ -42,16 +44,14 @@ internal::ContactJacobians<T> TamsiDriver<T>::CalcContactJacobians(
   contact_jacobians.Jn = MatrixX<T>::Zero(nc, nv);
   contact_jacobians.Jt = MatrixX<T>::Zero(2 * nc, nv);
 
-  const auto& topology = tree_topology();
+  const SpanningForest& forest = get_forest();
   for (int i = 0; i < nc; ++i) {
     const int row_offset = 3 * i;
     const DiscreteContactPair<T>& contact_pair = contact_pairs[i];
     for (const typename DiscreteContactPair<T>::JacobianTreeBlock&
              tree_jacobian : contact_pair.jacobian) {
-      const int col_offset =
-          topology.tree_velocities_start_in_v(tree_jacobian.tree);
-      const int tree_nv = topology.num_tree_velocities(tree_jacobian.tree);
-      contact_jacobians.Jc.block(row_offset, col_offset, 3, tree_nv) =
+      const SpanningForest::Tree& tree = forest.trees(tree_jacobian.tree);
+      contact_jacobians.Jc.block(row_offset, tree.v_start(), 3, tree.nv()) =
           tree_jacobian.J.MakeDenseMatrix();
     }
     contact_jacobians.Jt.middleRows(2 * i, 2) =
diff --git a/multibody/plant/tamsi_driver.h b/multibody/plant/tamsi_driver.h
index b1ab4079cabf..f7e220e9d3ae 100644
--- a/multibody/plant/tamsi_driver.h
+++ b/multibody/plant/tamsi_driver.h
@@ -63,9 +63,7 @@ class TamsiDriver {
 
   // Returns a reference to the underlying tree topology of the multibody
   // system.
-  const MultibodyTreeTopology& tree_topology() const {
-    return manager().tree_topology();
-  }
+  const SpanningForest& get_forest() const { return manager().get_forest(); }
 
   // Returns a reference to the MultibodyPlant model held by the manager
   // provided at construction.
diff --git a/multibody/plant/test/compliant_contact_manager_test.cc b/multibody/plant/test/compliant_contact_manager_test.cc
index 233eb1011c67..fc26000bb627 100644
--- a/multibody/plant/test/compliant_contact_manager_test.cc
+++ b/multibody/plant/test/compliant_contact_manager_test.cc
@@ -274,10 +274,6 @@ class SpheresStackTest : public SpheresStack, public ::testing::Test {
   // In the functions below we use CompliantContactManagerTester to provide
   // access to private functions for unit testing.
 
-  const internal::MultibodyTreeTopology& topology() const {
-    return CompliantContactManagerTester::topology(*contact_manager_);
-  }
-
   const GeometryContactData<double>& EvalGeometryContactData(
       const Context<double>& context) const {
     return CompliantContactManagerTester::EvalGeometryContactData(
diff --git a/multibody/plant/test/compliant_contact_manager_tester.h b/multibody/plant/test/compliant_contact_manager_tester.h
index 5eaf7e7ce6f4..91a71a5894c1 100644
--- a/multibody/plant/test/compliant_contact_manager_tester.h
+++ b/multibody/plant/test/compliant_contact_manager_tester.h
@@ -16,15 +16,9 @@ namespace internal {
 class CompliantContactManagerTester {
  public:
   template <typename T>
-  static const internal::MultibodyTreeTopology& topology(
+  static const internal::SpanningForest& get_forest(
       const CompliantContactManager<T>& manager) {
-    return manager.tree_topology();
-  }
-
-  template <typename T>
-  static const internal::SpanningForest& forest(
-      const CompliantContactManager<T>& manager) {
-    return manager.forest();
+    return manager.get_forest();
   }
 
   template <typename T>
@@ -75,7 +69,8 @@ class CompliantContactManagerTester {
     const int nc = contact_pairs.size();
     Eigen::MatrixX<T> J_AcBc_C(3 * nc, manager.plant().num_velocities());
     J_AcBc_C.setZero();
-    const auto& topology = CompliantContactManagerTester::topology(manager);
+    const SpanningForest& forest =
+        CompliantContactManagerTester::get_forest(manager);
     for (int i = 0; i < nc; ++i) {
       const int row_offset = 3 * i;
       const DiscreteContactPair<T>& contact_pair = contact_pairs[i];
@@ -83,10 +78,8 @@ class CompliantContactManagerTester {
                tree_jacobian : contact_pair.jacobian) {
         // If added to the Jacobian, it must have a valid index.
         EXPECT_TRUE(tree_jacobian.tree.is_valid());
-        const int col_offset =
-            topology.tree_velocities_start_in_v(tree_jacobian.tree);
-        const int tree_nv = topology.num_tree_velocities(tree_jacobian.tree);
-        J_AcBc_C.block(row_offset, col_offset, 3, tree_nv) =
+        const SpanningForest::Tree& tree = forest.trees(tree_jacobian.tree);
+        J_AcBc_C.block(row_offset, tree.v_start(), 3, tree.nv()) =
             tree_jacobian.J.MakeDenseMatrix();
       }
     }
diff --git a/multibody/plant/test/sap_driver_joint_limits_test.cc b/multibody/plant/test/sap_driver_joint_limits_test.cc
index fb4c0a481d08..5a62f84004ec 100644
--- a/multibody/plant/test/sap_driver_joint_limits_test.cc
+++ b/multibody/plant/test/sap_driver_joint_limits_test.cc
@@ -348,11 +348,12 @@ TEST_F(KukaIiwaArmTests, CalcLinearDynamicsMatrix) {
       SapDriverTest::CalcLinearDynamicsMatrix(sap_driver(), *context_);
   const int nv = plant_.num_velocities();
   MatrixXd Adense = MatrixXd::Zero(nv, nv);
-  const MultibodyTreeTopology& topology =
-      CompliantContactManagerTester::topology(*manager_);
-  for (TreeIndex t(0); t < topology.num_trees(); ++t) {
-    const int tree_start = topology.tree_velocities_start_in_v(t);
-    const int tree_nv = topology.num_tree_velocities(t);
+  const SpanningForest& forest =
+      CompliantContactManagerTester::get_forest(*manager_);
+  for (TreeIndex t(0); t < forest.num_trees(); ++t) {
+    const SpanningForest::Tree& tree = forest.trees(t);
+    const int tree_start = tree.v_start();
+    const int tree_nv = tree.nv();
     Adense.block(tree_start, tree_start, tree_nv, tree_nv) = A[t];
   }
   const MatrixXd Aexpected =
@@ -402,7 +403,7 @@ TEST_F(KukaIiwaArmTests, CalcAccelerationKinematicsCache) {
   // Verify CompliantContactManager loads the acceleration kinematics with the
   // proper results.
   AccelerationKinematicsCache<double> ac(
-      CompliantContactManagerTester::forest(*manager_));
+      CompliantContactManagerTester::get_forest(*manager_));
   manager_->CalcAccelerationKinematicsCache(*context_, &ac);
   EXPECT_TRUE(CompareMatrices(ac.get_vdot(), a_expected));
   for (BodyIndex b(0); b < plant_.num_bodies(); ++b) {
diff --git a/multibody/plant/test/sap_driver_test.cc b/multibody/plant/test/sap_driver_test.cc
index 1ad597b603e2..aa92c38cf030 100644
--- a/multibody/plant/test/sap_driver_test.cc
+++ b/multibody/plant/test/sap_driver_test.cc
@@ -145,8 +145,8 @@ class SpheresStackTest : public SpheresStack, public ::testing::Test {
   // The functions below provide access to private CompliantContactManager
   // functions for unit testing.
 
-  const internal::MultibodyTreeTopology& topology() const {
-    return CompliantContactManagerTester::topology(*contact_manager_);
+  const SpanningForest& get_forest() const {
+    return CompliantContactManagerTester::get_forest(*contact_manager_);
   }
 };
 
@@ -165,7 +165,7 @@ TEST_F(SpheresStackTest, EvalContactProblemCache) {
   const int num_contacts = contact_pairs.size();
 
   // Verify sizes.
-  EXPECT_EQ(problem.num_cliques(), topology().num_trees());
+  EXPECT_EQ(problem.num_cliques(), get_forest().num_trees());
   EXPECT_EQ(problem.num_velocities(), plant_->num_velocities());
   EXPECT_EQ(problem.num_constraints(), num_contacts);
   EXPECT_EQ(problem.num_constraint_equations(), 3 * num_contacts);
@@ -294,9 +294,11 @@ TEST_F(SpheresStackTest, CalcLinearDynamicsMatrix) {
   const std::vector<MatrixXd> A = CalcLinearDynamicsMatrix(*plant_context_);
   const int nv = plant_->num_velocities();
   MatrixXd Adense = MatrixXd::Zero(nv, nv);
-  for (TreeIndex t(0); t < topology().num_trees(); ++t) {
-    const int tree_start_in_v = topology().tree_velocities_start_in_v(t);
-    const int tree_nv = topology().num_tree_velocities(t);
+  const SpanningForest& forest = get_forest();
+  for (TreeIndex t(0); t < forest.num_trees(); ++t) {
+    const SpanningForest::Tree& tree = forest.trees(t);
+    const int tree_start_in_v = tree.v_start();
+    const int tree_nv = tree.nv();
     Adense.block(tree_start_in_v, tree_start_in_v, tree_nv, tree_nv) = A[t];
   }
   MatrixXd Aexpected(nv, nv);
diff --git a/multibody/topology/spanning_forest.h b/multibody/topology/spanning_forest.h
index 3309e28a7342..13d0bf08bcef 100644
--- a/multibody/topology/spanning_forest.h
+++ b/multibody/topology/spanning_forest.h
@@ -401,21 +401,21 @@ class SpanningForest {
   for the Tree to which the Primary (original) Link's Mobod belongs. An invalid
   tree index is returned if the Link's Mobod is World. O(1), very fast.
   @pre link_ordinal is in range [0, num_links) */
-  inline TreeIndex link_to_tree(LinkOrdinal link_ordinal) const;
+  inline TreeIndex link_to_tree_index(LinkOrdinal link_ordinal) const;
 
   /* Convenience signature that takes a LinkIndex rather than a LinkOrdinal.
   @pre the index refers to a link that exists and hasn't been removed. */
-  inline TreeIndex link_to_tree(LinkIndex link_index) const;
+  inline TreeIndex link_to_tree_index(LinkIndex link_index) const;
 
   /* Returns the Tree to which a given position coordinate q belongs.
   O(1), very fast.
   @pre q_index is in range [0, num_positions) */
-  inline TreeIndex q_to_tree(int q_index) const;
+  inline TreeIndex q_to_tree_index(int q_index) const;
 
   /* Returns the Tree to which a given velocity coordinate v belongs.
   O(1), very fast.
   @pre v_index is in range [0, num_velocities) */
-  inline TreeIndex v_to_tree(int v_index) const;
+  inline TreeIndex v_to_tree_index(int v_index) const;
 
   // FYI Debugging APIs (including Graphviz-related) are defined in
   // spanning_forest_debug.cc.
diff --git a/multibody/topology/spanning_forest_inlines.h b/multibody/topology/spanning_forest_inlines.h
index d4db98fa951e..0e920f0f5f13 100644
--- a/multibody/topology/spanning_forest_inlines.h
+++ b/multibody/topology/spanning_forest_inlines.h
@@ -33,19 +33,21 @@ inline const std::vector<LinkOrdinal>& SpanningForest::mobod_to_link_ordinals(
   return mobods(mobod_index).follower_link_ordinals();
 }
 
-inline TreeIndex SpanningForest::link_to_tree(LinkOrdinal link_ordinal) const {
+inline TreeIndex SpanningForest::link_to_tree_index(
+    LinkOrdinal link_ordinal) const {
   return mobods(links(link_ordinal).mobod_index()).tree();
 }
 
-inline TreeIndex SpanningForest::link_to_tree(LinkIndex link_index) const {
+inline TreeIndex SpanningForest::link_to_tree_index(
+    LinkIndex link_index) const {
   return mobods(link_by_index(link_index).mobod_index()).tree();
 }
 
-inline TreeIndex SpanningForest::q_to_tree(int q_index) const {
+inline TreeIndex SpanningForest::q_to_tree_index(int q_index) const {
   return mobods(q_to_mobod(q_index)).tree();
 }
 
-inline TreeIndex SpanningForest::v_to_tree(int v_index) const {
+inline TreeIndex SpanningForest::v_to_tree_index(int v_index) const {
   return mobods(v_to_mobod(v_index)).tree();
 }
 
diff --git a/multibody/topology/spanning_forest_tree.h b/multibody/topology/spanning_forest_tree.h
index 0464f7ad7fcd..e396bd6797d4 100644
--- a/multibody/topology/spanning_forest_tree.h
+++ b/multibody/topology/spanning_forest_tree.h
@@ -97,6 +97,9 @@ class SpanningForest::Tree {
     return last_v_plus_1 - v_start();
   }
 
+  /* Convenience method equivalent to (nv() > 0). */
+  bool has_dofs() const { return nv() > 0; }
+
  private:
   friend class SpanningForest;
 
diff --git a/multibody/topology/test/spanning_forest_test.cc b/multibody/topology/test/spanning_forest_test.cc
index 88337407a6cf..73fd4d72d0b2 100644
--- a/multibody/topology/test/spanning_forest_test.cc
+++ b/multibody/topology/test/spanning_forest_test.cc
@@ -73,8 +73,8 @@ GTEST_TEST(SpanningForest, WorldOnlyTest) {
             std::vector{world_link_index});
   EXPECT_FALSE(graph.link_composites(LinkCompositeIndex(0)).is_massless);
 
-  EXPECT_FALSE(forest.link_to_tree(LinkOrdinal(0)).is_valid());
-  EXPECT_FALSE(forest.link_to_tree(LinkIndex(0)).is_valid());
+  EXPECT_FALSE(forest.link_to_tree_index(LinkOrdinal(0)).is_valid());
+  EXPECT_FALSE(forest.link_to_tree_index(LinkIndex(0)).is_valid());
 
   // Check that the World-only forest makes sense.
   EXPECT_EQ(ssize(forest.mobods()), 1);
@@ -172,15 +172,15 @@ GTEST_TEST(SpanningForest, TreeAndLoopConstraintAPIs) {
   EXPECT_EQ(forest.num_mobods(), 4);
   EXPECT_EQ(ssize(forest.loop_constraints()), 1);
 
-  EXPECT_FALSE(forest.link_to_tree(LinkIndex(0)).is_valid());
-  EXPECT_EQ(forest.link_to_tree(LinkIndex(1)), TreeIndex(0));
+  EXPECT_FALSE(forest.link_to_tree_index(LinkIndex(0)).is_valid());
+  EXPECT_EQ(forest.link_to_tree_index(LinkIndex(1)), TreeIndex(0));
   // Link2's primary follows mobod3, which is in tree1.
-  EXPECT_EQ(forest.link_to_tree(LinkIndex(2)), TreeIndex(1));
+  EXPECT_EQ(forest.link_to_tree_index(LinkIndex(2)), TreeIndex(1));
 
   // The index and ordinal values are the same here.
-  EXPECT_FALSE(forest.link_to_tree(LinkOrdinal(0)).is_valid());
-  EXPECT_EQ(forest.link_to_tree(LinkOrdinal(1)), TreeIndex(0));
-  EXPECT_EQ(forest.link_to_tree(LinkOrdinal(2)), TreeIndex(1));
+  EXPECT_FALSE(forest.link_to_tree_index(LinkOrdinal(0)).is_valid());
+  EXPECT_EQ(forest.link_to_tree_index(LinkOrdinal(1)), TreeIndex(0));
+  EXPECT_EQ(forest.link_to_tree_index(LinkOrdinal(2)), TreeIndex(1));
 
   // Not much to check for the loop constraint.
   const auto& loop_constraint = forest.loop_constraints(LoopConstraintIndex(0));
@@ -393,12 +393,12 @@ GTEST_TEST(SpanningForest, MultipleBranchesDefaultOptions) {
   // clang-format on
 
   // Sample some q's and v's to see if they can find their tree and mobod.
-  EXPECT_EQ(forest.q_to_tree(9), TreeIndex(0));
-  EXPECT_EQ(forest.q_to_tree(19), TreeIndex(1));
-  EXPECT_EQ(forest.q_to_tree(30), TreeIndex(2));
-  EXPECT_EQ(forest.v_to_tree(9), TreeIndex(0));
-  EXPECT_EQ(forest.v_to_tree(19), TreeIndex(1));
-  EXPECT_EQ(forest.v_to_tree(29), TreeIndex(2));
+  EXPECT_EQ(forest.q_to_tree_index(9), TreeIndex(0));
+  EXPECT_EQ(forest.q_to_tree_index(19), TreeIndex(1));
+  EXPECT_EQ(forest.q_to_tree_index(30), TreeIndex(2));
+  EXPECT_EQ(forest.v_to_tree_index(9), TreeIndex(0));
+  EXPECT_EQ(forest.v_to_tree_index(19), TreeIndex(1));
+  EXPECT_EQ(forest.v_to_tree_index(29), TreeIndex(2));
   EXPECT_EQ(forest.q_to_mobod(9), MobodIndex(4));
   EXPECT_EQ(forest.q_to_mobod(20), MobodIndex(9));
   EXPECT_EQ(forest.q_to_mobod(30), MobodIndex(15));
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index 61fbbf673df3..a6dd8e4061e0 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -957,6 +957,18 @@ void MultibodyTree<T>::Finalize() {
   process (BuildForest()), which augmented the graph with them. We call those
   "ephemeral" elements. */
 
+  // TODO(sherm1) Add shadow links and loop constraints.
+  if (!graph.loop_constraints().empty()) {
+    link_joint_graph_.InvalidateForest();
+    throw std::runtime_error(fmt::format(
+        "The bodies and joints of this system form one or "
+        "more loops in the system graph. Drake currently does not "
+        "support automatic modeling of such systems; however, they "
+        "can be modeled with some input changes. See "
+        "https://drake.mit.edu/troubleshooting.html"
+        "#mbp-loops-in-graph for advice on how to model systems with loops."));
+  }
+
   /* Add the ephemeral Joints. */
   for (JointOrdinal i(graph.num_user_joints()); i < graph.num_joints(); ++i) {
     const LinkJointGraph::Joint& added_joint = graph.joints(i);
@@ -987,17 +999,6 @@ void MultibodyTree<T>::Finalize() {
     DRAKE_DEMAND(new_joint.index() == added_joint.index());
   }
 
-  // TODO(sherm1) Add shadow links and loop constraints.
-  if (!graph.loop_constraints().empty()) {
-    throw std::runtime_error(fmt::format(
-        "The bodies and joints of this system form one or "
-        "more loops in the system graph. Drake currently does not "
-        "support automatic modeling of such systems; however, they "
-        "can be modeled with some input changes. See "
-        "https://drake.mit.edu/troubleshooting.html"
-        "#mbp-loops-in-graph for advice on how to model systems with loops."));
-  }
-
   CreateJointImplementations();
   FinalizeTopology();
   FinalizeInternals();
@@ -1687,7 +1688,7 @@ void MultibodyTree<T>::CalcSpatialAccelerationsFromVdot(
   DRAKE_DEMAND(A_WB_array != nullptr);
   DRAKE_DEMAND(ssize(*A_WB_array) == num_mobods());
 
-  DRAKE_DEMAND(known_vdot.size() == topology_.num_velocities());
+  DRAKE_DEMAND(known_vdot.size() == forest().num_velocities());
 
   const auto& frame_body_pose_cache = EvalFrameBodyPoses(context);
   const auto& pc = EvalPositionKinematics(context);
@@ -1721,7 +1722,7 @@ void MultibodyTree<T>::CalcAccelerationKinematicsCache(
     const VelocityKinematicsCache<T>& vc, const VectorX<T>& known_vdot,
     AccelerationKinematicsCache<T>* ac) const {
   DRAKE_DEMAND(ac != nullptr);
-  DRAKE_DEMAND(known_vdot.size() == topology_.num_velocities());
+  DRAKE_DEMAND(known_vdot.size() == forest().num_velocities());
 
   std::vector<SpatialAcceleration<T>>& A_WB_array = ac->get_mutable_A_WB_pool();
 
diff --git a/multibody/tree/multibody_tree.h b/multibody/tree/multibody_tree.h
index ec04cbe8cad9..027b9515e16f 100644
--- a/multibody/tree/multibody_tree.h
+++ b/multibody/tree/multibody_tree.h
@@ -567,7 +567,7 @@ class MultibodyTree {
   // Kinematic paths are created by Mobilizer objects connecting a chain of
   // frames. Therefore, this method does not count kinematic cycles, which
   // could only be considered in the model using constraints.
-  int forest_height() const { return topology_.forest_height(); }
+  int forest_height() const { return forest().height(); }
 
   // Returns a constant reference to the *world* body.
   const RigidBody<T>& world_body() const {
diff --git a/multibody/tree/multibody_tree_topology.cc b/multibody/tree/multibody_tree_topology.cc
index a60267e9709c..f345d90ade50 100644
--- a/multibody/tree/multibody_tree_topology.cc
+++ b/multibody/tree/multibody_tree_topology.cc
@@ -4,31 +4,6 @@ namespace drake {
 namespace multibody {
 namespace internal {
 
-bool MultibodyTreeTopology::operator==(
-    const MultibodyTreeTopology& other) const {
-  if (is_valid_ != other.is_valid_) return false;
-  if (forest_height_ != other.forest_height_) return false;
-
-  if (num_positions_ != other.num_positions_) return false;
-  if (num_velocities_ != other.num_velocities_) return false;
-  if (num_states_ != other.num_states_) return false;
-  if (num_actuated_dofs_ != other.num_actuated_dofs_) return false;
-
-  if (num_tree_velocities_ != other.num_tree_velocities_) return false;
-  if (tree_velocities_start_in_v_ != other.tree_velocities_start_in_v_)
-    return false;
-  // Each velocity should have a valid tree index, so it is ok to compare these
-  // directly.
-  if (velocity_to_tree_index_ != other.velocity_to_tree_index_) return false;
-  // The world body (BodyIndex(0)) does not have a valid tree index so we skip
-  // it when comparing for equality.
-  DRAKE_DEMAND(!other.rigid_body_to_tree_index_[0].is_valid());
-  return std::equal(rigid_body_to_tree_index_.begin() + 1,
-                    rigid_body_to_tree_index_.end(),
-                    other.rigid_body_to_tree_index_.begin() + 1,
-                    other.rigid_body_to_tree_index_.end());
-}
-
 MultibodyTreeTopology::~MultibodyTreeTopology() = default;
 
 // TODO(sherm1) For historical reasons we're extracting information from the
@@ -46,52 +21,14 @@ void MultibodyTreeTopology::FinalizeTopology(const LinkJointGraph& graph) {
 
   const SpanningForest& forest = graph.forest();
 
-  num_positions_ = forest.num_positions();
-  num_velocities_ = forest.num_velocities();
-  num_states_ = num_positions_ + num_velocities_;
-
-  ExtractForestInfo(graph);
+  const SpanningForest::Mobod& root = forest.mobods(MobodIndex(0));
+  DRAKE_DEMAND(ssize(root.outboards()) == ssize(forest.trees()));
 
   // We are done with a successful Finalize() and we mark it as so.
   // Do not add any more code after this!
   is_valid_ = true;
 }
 
-// TODO(sherm1) Currently this copies from the graph and forest into the
-//  previous data structures, to establish that we are computing the same
-//  quantities. Once this works, should switch to using the forest data
-//  directly and cut out the redundant data structures.
-void MultibodyTreeTopology::ExtractForestInfo(const LinkJointGraph& graph) {
-  const SpanningForest& forest = graph.forest();
-  forest_height_ = forest.height();
-
-  const SpanningForest::Mobod& root = forest.mobods(MobodIndex(0));
-  DRAKE_DEMAND(ssize(root.outboards()) == ssize(forest.trees()));
-
-  tree_velocities_start_in_v_.resize(ssize(forest.trees()), -1);
-  num_tree_velocities_.resize(ssize(forest.trees()), -1);
-  for (const auto& tree : forest.trees()) {
-    const TreeIndex index = tree.index();
-    tree_velocities_start_in_v_.at(index) = tree.v_start();
-    num_tree_velocities_[index] = tree.nv();
-  }
-
-  velocity_to_tree_index_.reserve(forest.num_velocities());
-  for (int v = 0; v < forest.num_velocities(); ++v)
-    velocity_to_tree_index_.emplace_back(forest.v_to_tree(v));
-
-  // Map each Link in the graph (including shadows added to break loops) to
-  // the tree to which its modeling Mobod belongs.
-  // TODO(sherm1) Really should be graph.num_link_indexes() which is private.
-  //  Doesn't matter though since we don't currently remove Links and this code
-  //  is going away soon.
-  rigid_body_to_tree_index_.resize(graph.num_links());
-  for (const auto& link : graph.links()) {
-    // The tree index will be invalid for World.
-    rigid_body_to_tree_index_[link.index()] = forest.link_to_tree(link.index());
-  }
-}
-
 }  // namespace internal
 }  // namespace multibody
 }  // namespace drake
diff --git a/multibody/tree/multibody_tree_topology.h b/multibody/tree/multibody_tree_topology.h
index a39e1caad8d8..f4dce992c610 100644
--- a/multibody/tree/multibody_tree_topology.h
+++ b/multibody/tree/multibody_tree_topology.h
@@ -27,64 +27,6 @@ class MultibodyTreeTopology {
 
   ~MultibodyTreeTopology();
 
-  // Returns `true` if all members of `this` topology are exactly equal to the
-  // members of `other`.
-  bool operator==(const MultibodyTreeTopology& other) const;
-
-  // Returns the number of levels in the forest topology.
-  int forest_height() const { return forest_height_; }
-
-  // Returns the number of trees in the "forest" topology of the entire system.
-  // We refer to as "tree" a subgraph in the topology having a tree structure
-  // and whose base node connects to the world. The world does not belong to any
-  // tree. In other words, the number of trees in the topology corresponds to
-  // the number of children of the world body node (also called "base nodes").
-  int num_trees() const { return ssize(num_tree_velocities_); }
-
-  // Returns the number of generalized velocities for the t-th tree.
-  // @pre t.is_valid() is true and t < num_trees().
-  int num_tree_velocities(TreeIndex t) const {
-    DRAKE_ASSERT(t < num_trees());
-    return num_tree_velocities_[t];
-  }
-
-  // For the t-th tree, this method returns the index of the first generalized
-  // velocity in the vector of generalized velocities for the entire model.
-  // Starting at this index, the num_tree_velocities(t) velocities for the t-th
-  // tree are contiguous in the vector of generalized velocities for the full
-  // model. tree_velocities_start(t) always returns a valid index to an entry in
-  // the vector of generalized velocities for the full model, even if the t-th
-  // tree has no generalized velocities. In such case however,
-  // num_tree_velocities(t) will be zero.
-  int tree_velocities_start_in_v(TreeIndex t) const {
-    DRAKE_ASSERT(t < num_trees());
-    return tree_velocities_start_in_v_[t];
-  }
-
-  // Returns the tree index for the b-th rigid body. The tree index for the
-  // world rigid body, BodyIndex(0), is invalid. Check with
-  // TreeIndex::is_valid().
-  // @pre Index b is valid and b < num_rigid_bodies().
-  TreeIndex body_to_tree_index(BodyIndex b) const {
-    DRAKE_ASSERT(b < ssize(rigid_body_to_tree_index_));
-    return rigid_body_to_tree_index_[b];
-  }
-
-  // Returns the tree index for the v-th velocity.
-  // @pre 0 <= v and v < num_velocities().
-  TreeIndex velocity_to_tree_index(int v) const {
-    DRAKE_ASSERT(0 <= v && v < num_velocities());
-    return velocity_to_tree_index_[v];
-  }
-
-  // Given a tree index, returns `true` if that tree has any degrees of freedom
-  // (ignoring joint locking). An invalid tree index is treated as World's
-  // "tree", which has no dofs.
-  bool tree_has_dofs(TreeIndex tree_index) const {
-    if (!tree_index.is_valid()) return false;  // World doesn't have a Tree.
-    return num_tree_velocities(tree_index) > 0;
-  }
-
   // This method must be called by MultibodyTree::Finalize() after all
   // topological elements in the plant (rigid bodies, joints, constraints) were
   // added and a suitable SpanningForest built.
@@ -107,52 +49,9 @@ class MultibodyTreeTopology {
   // @see FinalizeTopology()
   bool is_valid() const { return is_valid_; }
 
-  // Returns the total number of generalized positions in the model.
-  int num_positions() const { return num_positions_; }
-
-  // Returns the total number of generalized velocities in the model.
-  int num_velocities() const { return num_velocities_; }
-
-  // Returns the total size of the state vector in the model.
-  int num_states() const { return num_states_; }
-
-  // Returns the total number of actuated joint dofs in the model.
-  int num_actuated_dofs() const { return num_actuated_dofs_; }
-
  private:
-  // Helper method to be used within FinalizeTopology() to obtain the
-  // topological information that describes the multibody system as a "forest"
-  // of trees.
-  void ExtractForestInfo(const LinkJointGraph& graph);
-
   // is_valid is set to `true` after a successful FinalizeTopology().
   bool is_valid_{false};
-  // Number of levels in the full Forest topology. After FinalizeTopology()
-  // there will be at least one level (level = 0) with the world body.
-  int forest_height_{-1};
-
-  // Topological elements:
-
-  // Total number of generalized positions and velocities in the MultibodyTree
-  // model.
-  int num_positions_{0};
-  int num_velocities_{0};
-  int num_states_{0};
-  int num_actuated_dofs_{0};
-
-  // Number of generalized velocities for the t-th tree.
-  std::vector<int> num_tree_velocities_;
-  // Given the generalized velocities vector v for the entire model, the vector
-  // vt = {v(m) s.t. m ∈ [mₛ, mₑ)}, with mₛ = tree_velocities_start_in_v_[t] and
-  // iₑ = tree_velocities_start_in_v_[t] + num_tree_velocities_[t], are the
-  // generalized velocities for the t-th tree.
-  std::vector<int> tree_velocities_start_in_v_;
-  // t = velocity_to_tree_index_[m] is the tree index to which the m-th velocity
-  // (within the v vector) belongs.
-  std::vector<TreeIndex> velocity_to_tree_index_;
-  // t = rigid_body_to_tree_index_[b] is the index of the tree to which the b-th
-  // RigidBody belongs.
-  std::vector<TreeIndex> rigid_body_to_tree_index_;
 };
 
 }  // namespace internal
diff --git a/multibody/tree/test/multibody_tree_creation_test.cc b/multibody/tree/test/multibody_tree_creation_test.cc
index fe4d50881551..c4064257f9c6 100644
--- a/multibody/tree/test/multibody_tree_creation_test.cc
+++ b/multibody/tree/test/multibody_tree_creation_test.cc
@@ -117,10 +117,10 @@ GTEST_TEST(MultibodyTree, BasicAPIToAddBodiesAndJoints) {
   EXPECT_EQ(model->num_joints(), 2);
 
   // Topology is invalid before MultibodyTree::Finalize().
-  EXPECT_FALSE(model->topology_is_valid());
+  EXPECT_FALSE(model->graph().forest_is_valid());
   // Verifies that the topology of this model gets validated at finalize stage.
   DRAKE_EXPECT_NO_THROW(model->Finalize());
-  EXPECT_TRUE(model->topology_is_valid());
+  EXPECT_TRUE(model->graph().forest_is_valid());
 
   // Body identifiers are unique and are assigned by MultibodyTree in increasing
   // order starting with index = 0 (world_index()) for the "world" body.
@@ -163,12 +163,12 @@ GTEST_TEST(MultibodyTree, TopologicalLoopDisallowed) {
   EXPECT_EQ(model->num_bodies(), 3);
   EXPECT_EQ(model->num_joints(), 3);
 
-  // Topology is invalid before MultibodyTree::Finalize(), and after fail.
-  EXPECT_FALSE(model->topology_is_valid());
+  // Topology is invalid before MultibodyTree::Finalize() or after failure.
+  EXPECT_FALSE(model->graph().forest_is_valid());
   DRAKE_EXPECT_THROWS_MESSAGE(
       model->Finalize(),
       "The bodies and joints of this system form one or more loops.*");
-  EXPECT_FALSE(model->topology_is_valid());
+  EXPECT_FALSE(model->graph().forest_is_valid());
 }
 
 // Tests the correctness of MultibodyElement checks to verify one or more
@@ -329,10 +329,9 @@ class TreeTopologyTests : public ::testing::Test {
 
   void FinalizeModel() { model_->Finalize(); }
 
-  // Performs a number of tests on the BodyNodeTopology corresponding to the
+  // Performs a number of tests on the BodyNode corresponding to the
   // body indexed by `body`.
-  static void TestBodyNode(const MultibodyTreeTopology& topology,
-                           const SpanningForest& forest, BodyIndex body) {
+  static void TestBodyNode(const SpanningForest& forest, BodyIndex body) {
     // In case of merged composites, many links may follow the same mobod.
     // Make sure the link's mobod agrees that the link follows it.
     const LinkJointGraph::Link& link = forest.link_by_index(body);
@@ -354,12 +353,9 @@ class TreeTopologyTests : public ::testing::Test {
                           mobod_index) != child_mobods.end());
   }
 
-  static void VerifyTopology(const MultibodyTreeTopology& topology,
-                             const SpanningForest& forest) {
+  static void VerifyTopology(const SpanningForest& forest) {
     const int kNumRigidBodies = 10;
 
-    EXPECT_EQ(topology.forest_height(), 4);
-
     EXPECT_EQ(forest.num_links(), kNumRigidBodies);
     EXPECT_EQ(forest.num_mobods(), kNumRigidBodies);
     EXPECT_EQ(forest.height(), 4);
@@ -401,7 +397,7 @@ class TreeTopologyTests : public ::testing::Test {
 
     // Checks the correctness of each BodyNode associated with a Link.
     for (BodyIndex index(0); index < kNumRigidBodies; ++index) {
-      TestBodyNode(topology, forest, index);
+      TestBodyNode(forest, index);
     }
 
     // We now verify the precise expected topology. We use our internal
@@ -423,16 +419,6 @@ class TreeTopologyTests : public ::testing::Test {
     }
 
     // Verify the expected forest of trees.
-    EXPECT_EQ(topology.num_trees(), 4);
-    EXPECT_EQ(topology.num_tree_velocities(TreeIndex(0)), 1);
-    EXPECT_EQ(topology.num_tree_velocities(TreeIndex(1)), 2);
-    EXPECT_EQ(topology.num_tree_velocities(TreeIndex(2)), 0);
-    EXPECT_EQ(topology.num_tree_velocities(TreeIndex(3)), 4);
-    EXPECT_EQ(topology.tree_velocities_start_in_v(TreeIndex(0)), 0);
-    EXPECT_EQ(topology.tree_velocities_start_in_v(TreeIndex(1)), 1);
-    EXPECT_EQ(topology.tree_velocities_start_in_v(TreeIndex(2)), 3);
-    EXPECT_EQ(topology.tree_velocities_start_in_v(TreeIndex(3)), 3);
-
     EXPECT_EQ(forest.num_trees(), 4);
     EXPECT_EQ(forest.trees(TreeIndex(0)).nv(), 1);
     EXPECT_EQ(forest.trees(TreeIndex(1)).nv(), 2);
@@ -454,18 +440,10 @@ class TreeTopologyTests : public ::testing::Test {
     // invalid.
     for (const auto& [link_index, tree_index] : expected_link_to_tree) {
       if (link_index == world_index()) {
-        EXPECT_FALSE(topology.body_to_tree_index(link_index).is_valid());
+        EXPECT_FALSE(forest.link_to_tree_index(link_index).is_valid());
         continue;
       }
-      EXPECT_EQ(topology.body_to_tree_index(link_index), tree_index);
-    }
-
-    for (const auto& [link_index, tree_index] : expected_link_to_tree) {
-      if (link_index == world_index()) {
-        EXPECT_FALSE(forest.link_to_tree(link_index).is_valid());
-        continue;
-      }
-      EXPECT_EQ(forest.link_to_tree(link_index), tree_index);
+      EXPECT_EQ(forest.link_to_tree_index(link_index), tree_index);
     }
 
     // No velocities map to Tree 2.
@@ -474,14 +452,9 @@ class TreeTopologyTests : public ::testing::Test {
         {3, TreeIndex(3)}, {4, TreeIndex(3)}, {5, TreeIndex(3)},
         {6, TreeIndex(3)}};
 
-    EXPECT_EQ(topology.num_velocities(), 7);
-    for (const auto& [velocity_index, tree_index] : expected_velocity_to_tree) {
-      EXPECT_EQ(topology.velocity_to_tree_index(velocity_index), tree_index);
-    }
-
     EXPECT_EQ(forest.num_velocities(), 7);
     for (const auto& [velocity_index, tree_index] : expected_velocity_to_tree) {
-      EXPECT_EQ(forest.v_to_tree(velocity_index), tree_index);
+      EXPECT_EQ(forest.v_to_tree_index(velocity_index), tree_index);
     }
   }
 
@@ -502,15 +475,11 @@ TEST_F(TreeTopologyTests, Finalize) {
   EXPECT_EQ(model_->num_bodies(), 10);
   EXPECT_EQ(model_->num_mobilizers(), 10);
 
-  const MultibodyTreeTopology& topology = model_->get_topology();
   const SpanningForest& forest = model_->forest();
-
-  EXPECT_EQ(topology.forest_height(), 4);
-
   EXPECT_EQ(forest.num_mobods(), 10);
   EXPECT_EQ(forest.height(), 4);
 
-  VerifyTopology(topology, forest);
+  VerifyTopology(forest);
 }
 
 // This unit tests verifies the correct number of generalized positions and
@@ -521,16 +490,8 @@ TEST_F(TreeTopologyTests, SizesAndIndexing) {
   EXPECT_EQ(model_->num_mobilizers(), 10);
   EXPECT_EQ(model_->num_joints(), 9);
 
-  // TODO(sherm1) First make sure topology and forest agree, then nuke the
-  //  old topology code.
-  const MultibodyTreeTopology& topology = model_->get_topology();
   const SpanningForest& forest = model_->forest();
 
-  EXPECT_EQ(topology.forest_height(), 4);
-  EXPECT_EQ(topology.num_positions(), 7);
-  EXPECT_EQ(topology.num_velocities(), 7);
-  EXPECT_EQ(topology.num_states(), 14);
-
   EXPECT_EQ(forest.num_mobods(), 10);
   EXPECT_EQ(forest.height(), 4);
   EXPECT_EQ(forest.num_positions(), 7);
@@ -552,8 +513,8 @@ TEST_F(TreeTopologyTests, SizesAndIndexing) {
     positions_index += mobod.nq();
     velocities_index += mobod.nv();
   }
-  EXPECT_EQ(positions_index, topology.num_positions());
-  EXPECT_EQ(velocities_index, topology.num_velocities());
+  EXPECT_EQ(positions_index, forest.num_positions());
+  EXPECT_EQ(velocities_index, forest.num_velocities());
 }
 
 // Verifies that the clone of a given MultibodyTree model created with
@@ -564,25 +525,18 @@ TEST_F(TreeTopologyTests, Clone) {
   EXPECT_EQ(model_->num_bodies(), 10);
   EXPECT_EQ(model_->num_mobilizers(), 10);
   EXPECT_EQ(model_->num_force_elements(), 1);
-  const MultibodyTreeTopology& topology = model_->get_topology();
+  const SpanningForest& forest = model_->forest();
 
   auto cloned_model = model_->Clone();
   EXPECT_EQ(cloned_model->num_bodies(), 10);
   EXPECT_EQ(cloned_model->num_mobilizers(), 10);
   EXPECT_EQ(cloned_model->num_force_elements(), 1);
-  const MultibodyTreeTopology& clone_topology = cloned_model->get_topology();
   const SpanningForest& clone_forest = cloned_model->forest();
 
   // Verify the cloned topology actually is a different object.
-  ASSERT_NE(&topology, &clone_topology);
-
-  // The topology of the clone must be exactly equal to the topology of the
-  // original MultibodyTree.
-  EXPECT_EQ(topology, clone_topology);
+  ASSERT_NE(&forest, &clone_forest);
 
-  // Even though the test above confirms the two topologies are exactly equal,
-  // we perform a number of additional tests.
-  VerifyTopology(clone_topology, clone_forest);
+  VerifyTopology(clone_forest);
 }
 
 // Verifies that the AutoDiffXd version of a given MultibodyTree model created
@@ -592,22 +546,13 @@ TEST_F(TreeTopologyTests, ToAutoDiffXd) {
   model_->Finalize();
   EXPECT_EQ(model_->num_bodies(), 10);
   EXPECT_EQ(model_->num_mobilizers(), 10);
-  const MultibodyTreeTopology& topology = model_->get_topology();
 
   auto autodiff_model = model_->ToAutoDiffXd();
   EXPECT_EQ(autodiff_model->num_bodies(), 10);
   EXPECT_EQ(autodiff_model->num_mobilizers(), 10);
-  const MultibodyTreeTopology& autodiff_topology =
-      autodiff_model->get_topology();
   const SpanningForest& autodiff_forest = autodiff_model->forest();
 
-  // The topology of the clone must be exactly equal to the topology of the
-  // original MultibodyTree.
-  EXPECT_EQ(topology, autodiff_topology);
-
-  // Even though the test above confirms the two topologies are exactly equal,
-  // we perform a number of additional tests.
-  VerifyTopology(autodiff_topology, autodiff_forest);
+  VerifyTopology(autodiff_forest);
 }
 
 // Verifies that the symbolic version of a given MultibodyTree model created
@@ -617,22 +562,13 @@ TEST_F(TreeTopologyTests, ToSymbolic) {
   model_->Finalize();
   EXPECT_EQ(model_->num_bodies(), 10);
   EXPECT_EQ(model_->num_mobilizers(), 10);
-  const MultibodyTreeTopology& topology = model_->get_topology();
 
   auto symbolic_model = model_->CloneToScalar<symbolic::Expression>();
   EXPECT_EQ(symbolic_model->num_bodies(), 10);
   EXPECT_EQ(symbolic_model->num_mobilizers(), 10);
-  const MultibodyTreeTopology& symbolic_topology =
-      symbolic_model->get_topology();
   const SpanningForest& symbolic_forest = symbolic_model->forest();
 
-  // The topology of the clone must be exactly equal to the topology of the
-  // original MultibodyTree.
-  EXPECT_EQ(topology, symbolic_topology);
-
-  // Even though the test above confirms the two topologies are exactly equal,
-  // we perform a number of additional tests.
-  VerifyTopology(symbolic_topology, symbolic_forest);
+  VerifyTopology(symbolic_forest);
 }
 
 // Confirm that the topology methods SpanningForest::FindPathFromWorld() and

From 5c3f2f39b39be1e46ad2af6310a1d72b14ca2f30 Mon Sep 17 00:00:00 2001
From: Michael Sherman <sherm1@gmail.com>
Date: Mon, 13 Oct 2025 17:44:41 -0700
Subject: [PATCH 7/7] Removing references to MbTTopo

---
 multibody/tree/body_node.h         |  3 +--
 multibody/tree/deformable_body.h   |  2 +-
 multibody/tree/force_element.h     |  2 +-
 multibody/tree/frame.h             |  2 +-
 multibody/tree/joint.h             |  2 +-
 multibody/tree/joint_actuator.h    |  4 +---
 multibody/tree/mobilizer.h         |  4 +---
 multibody/tree/model_instance.h    |  2 +-
 multibody/tree/multibody_element.h | 14 ++++++--------
 multibody/tree/multibody_tree.cc   | 12 ++++++------
 multibody/tree/rigid_body.h        |  2 +-
 11 files changed, 21 insertions(+), 28 deletions(-)

diff --git a/multibody/tree/body_node.h b/multibody/tree/body_node.h
index c4f3c61543f8..c6cef8168766 100644
--- a/multibody/tree/body_node.h
+++ b/multibody/tree/body_node.h
@@ -648,8 +648,7 @@ class BodyNode : public MultibodyElement<T> {
   friend class BodyNodeTester;
 
   // Implementation for MultibodyElement::DoSetTopology().
-  // TODO(sherm1) Get rid of this.
-  void DoSetTopology(const MultibodyTreeTopology&) final {
+  void DoSetTopology() final {
     // BodyNode gets everything it needs at construction.
     DRAKE_DEMAND(body_ != nullptr && mobilizer_ != nullptr);
   }
diff --git a/multibody/tree/deformable_body.h b/multibody/tree/deformable_body.h
index b4bf06199504..3bc187ed130a 100644
--- a/multibody/tree/deformable_body.h
+++ b/multibody/tree/deformable_body.h
@@ -408,7 +408,7 @@ class DeformableBody final : public MultibodyElement<T> {
                                    const fem::DeformableBodyConfig<T>& config,
                                    const Vector3<double>& weights);
 
-  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
+  void DoSetTopology() final {
     /* No-op because deformable bodies are not part of the MultibodyTree
      topology. */
   }
diff --git a/multibody/tree/force_element.h b/multibody/tree/force_element.h
index 85399b5f8d43..738d5b027924 100644
--- a/multibody/tree/force_element.h
+++ b/multibody/tree/force_element.h
@@ -275,7 +275,7 @@ class ForceElement : public MultibodyElement<T> {
   // Implementation for MultibodyElement::DoSetTopology().
   // At MultibodyTree::Finalize() time, each force element retrieves its
   // topology from the parent MultibodyTree.
-  void DoSetTopology(const internal::MultibodyTreeTopology&) final {}
+  void DoSetTopology() final {}
 
   // Implementation for MultibodyElement::DoDeclareParameters().
   void DoDeclareParameters(
diff --git a/multibody/tree/frame.h b/multibody/tree/frame.h
index 5fcc798ffc60..fdc4f69212e1 100644
--- a/multibody/tree/frame.h
+++ b/multibody/tree/frame.h
@@ -636,7 +636,7 @@ class Frame : public MultibodyElement<T> {
 
  private:
   // Implementation for MultibodyElement::DoSetTopology().
-  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
+  void DoSetTopology() final {
     // Frame gets everything it needs at construction.
   }
 
diff --git a/multibody/tree/joint.h b/multibody/tree/joint.h
index 8a188531f1d8..719dc57e7ea3 100644
--- a/multibody/tree/joint.h
+++ b/multibody/tree/joint.h
@@ -922,7 +922,7 @@ class Joint : public MultibodyElement<T> {
 
   // Implements MultibodyElement::DoSetTopology(). Joints have no topology
   // though we could require them to have one in the future.
-  void DoSetTopology(const internal::MultibodyTreeTopology&) override {}
+  void DoSetTopology() override {}
 
   /// @name Methods to make a clone, optionally templated on different scalar
   /// types.
diff --git a/multibody/tree/joint_actuator.h b/multibody/tree/joint_actuator.h
index f74e0f9a76fe..d2fcf5d20828 100644
--- a/multibody/tree/joint_actuator.h
+++ b/multibody/tree/joint_actuator.h
@@ -378,9 +378,7 @@ class JointActuator final : public MultibodyElement<T> {
   // This is called at the end of Finalize(). We just need to record
   // that this actuator has been finalized because there are some
   // checks we can't do until then.
-  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
-    is_finalized_ = true;
-  }
+  void DoSetTopology() final { is_finalized_ = true; }
 
   // Implementation for MultibodyElement::DoDeclareParameters().
   void DoDeclareParameters(
diff --git a/multibody/tree/mobilizer.h b/multibody/tree/mobilizer.h
index 351ea3c54157..29f0a102f66b 100644
--- a/multibody/tree/mobilizer.h
+++ b/multibody/tree/mobilizer.h
@@ -901,9 +901,7 @@ class Mobilizer : public MultibodyElement<T> {
 
  private:
   // Implementation for MultibodyElement::DoSetTopology().
-  // At MultibodyTree::Finalize() time, each mobilizer retrieves its topology
-  // from the parent MultibodyTree.
-  void DoSetTopology(const MultibodyTreeTopology&) final {
+  void DoSetTopology() final {
     // Mobod provides topology info at construction.
   }
 
diff --git a/multibody/tree/model_instance.h b/multibody/tree/model_instance.h
index 1426ed7a418e..1d4bd9e66fa9 100644
--- a/multibody/tree/model_instance.h
+++ b/multibody/tree/model_instance.h
@@ -195,7 +195,7 @@ class ModelInstance final : public MultibodyElement<T> {
                             EigenPtr<VectorX<T>> v) const;
 
  private:
-  void DoSetTopology(const MultibodyTreeTopology&) final {}
+  void DoSetTopology() final {}
 
   std::string name_;
 
diff --git a/multibody/tree/multibody_element.h b/multibody/tree/multibody_element.h
index 4198d91ce5ca..824f80ca7dc8 100644
--- a/multibody/tree/multibody_element.h
+++ b/multibody/tree/multibody_element.h
@@ -9,7 +9,6 @@
 #include "drake/multibody/tree/multibody_tree.h"
 #include "drake/multibody/tree/multibody_tree_indexes.h"
 #include "drake/multibody/tree/multibody_tree_system.h"
-#include "drake/multibody/tree/multibody_tree_topology.h"
 
 namespace drake {
 namespace multibody {
@@ -152,16 +151,15 @@ class MultibodyElement {
     return get_parent_tree().tree_system();
   }
 
-  /// Gives MultibodyElement-derived objects the opportunity to retrieve their
-  /// topology after MultibodyTree::Finalize() is invoked.
-  /// NVI to pure virtual method DoSetTopology().
-  void SetTopology(const internal::MultibodyTreeTopology& tree) {
-    DoSetTopology(tree);
-  }
+  /// (Internal use only) Gives MultibodyElement-derived objects the opportunity
+  /// to set data members that depend on topology and coordinate assignments
+  /// having been finalized. This is invoked at the end of
+  /// MultibodyTree::Finalize(). NVI to pure virtual method DoSetTopology().
+  void SetTopology() { DoSetTopology(); }
 
   /// Implementation of the NVI SetTopology(). For advanced use only for
   /// developers implementing new MultibodyTree components.
-  virtual void DoSetTopology(const internal::MultibodyTreeTopology& tree) = 0;
+  virtual void DoSetTopology() = 0;
 
   /// Implementation of the NVI DeclareParameters(). MultibodyElement-derived
   /// objects may override to declare their specific parameters.
diff --git a/multibody/tree/multibody_tree.cc b/multibody/tree/multibody_tree.cc
index a6dd8e4061e0..babe2df9f065 100644
--- a/multibody/tree/multibody_tree.cc
+++ b/multibody/tree/multibody_tree.cc
@@ -866,23 +866,23 @@ void MultibodyTree<T>::FinalizeInternals() {
   // Give different multibody elements the chance to perform any finalize-time
   // setup.
   for (const auto& body_index : rigid_bodies_.indices()) {
-    rigid_bodies_.get_mutable_element(body_index).SetTopology(topology_);
+    rigid_bodies_.get_mutable_element(body_index).SetTopology();
   }
   for (const auto& frame_index : frames_.indices()) {
     // We (re)set the topology on all frames. The rigid body frames' topologies
     // will already have been set in the body loop immediately above, but it
     // doesn't hurt to set them again. The important thing is that the non-body
     // frames are being set here for the first time.
-    frames_.get_mutable_element(frame_index).SetTopology(topology_);
+    frames_.get_mutable_element(frame_index).SetTopology();
   }
   for (const auto& mobilizer : mobilizers_) {
-    mobilizer->SetTopology(topology_);
+    mobilizer->SetTopology();
   }
   for (const auto& force_element : force_elements_) {
-    force_element->SetTopology(topology_);
+    force_element->SetTopology();
   }
   for (const auto& actuator_index : actuators_.indices()) {
-    actuators_.get_mutable_element(actuator_index).SetTopology(topology_);
+    actuators_.get_mutable_element(actuator_index).SetTopology();
   }
 
   // TODO(sherm1) Consider building the level collection while building the
@@ -1026,7 +1026,7 @@ void MultibodyTree<T>::CreateBodyNode(MobodIndex mobod_index) {
     parent_node->add_child_node(body_node.get());
   }
   body_node->set_parent_tree(this, mobod_index);
-  body_node->SetTopology(topology_);
+  body_node->SetTopology();
 
   body_nodes_.push_back(std::move(body_node));
 }
diff --git a/multibody/tree/rigid_body.h b/multibody/tree/rigid_body.h
index 8ef24bea2f9b..82fc5172ea49 100644
--- a/multibody/tree/rigid_body.h
+++ b/multibody/tree/rigid_body.h
@@ -747,7 +747,7 @@ class RigidBody : public MultibodyElement<T> {
   friend class internal::RigidBodyAttorney<T>;
 
   // Called near the end of Finalize().
-  void DoSetTopology(const internal::MultibodyTreeTopology&) final {
+  void DoSetTopology() final {
     DRAKE_DEMAND(mobilizer_ == nullptr);
     const internal::MultibodyTree<T>& tree = this->get_parent_tree();
     const internal::SpanningForest& forest = tree.forest();