note the direction of those arrows. I remember the situation from the last discussion. I realize I’m coming up with notations ad hoc and they might look conflicting because they’re taking shape as I deal with this. I don’t have formal education in robotics/mechatronics, just the usual university math and “introductory” computer graphics where they handwave over lots of the “craft” of math.
my sense for arrows in this thread is that an arrow goes from base to gripper, if you have the pose of the gripper relative to the base frame. I would say the transformation “originates” from the base and describes the gripper’s pose (goes forward/outward). the matrix describes the gripper’s pose in/relative to the base frame, but it also translates coordinates from the gripper frame to the base frame (is pulled “back down”).
now the camera/base situation… initially you have the base’s pose in the camera frame because that’s what the camera gives you. I’ll call that camera_base
and my arrow in the graphic would go camera → base. it transforms coordinates from the base frame (right side of the matrix) into the camera frame (left side of matrix).
if you need base_cam
(a matrix inversion), which expresses the cam’s pose in the base frame, or equivalently the transformation that converts things from the cam frame into the base frame.
I’d always think in terms of frames (forward/outward) rather than how things are converted from one frame to another (pulled back down).
now, assuming
 your robot (its API) can handle the math for its “changed” topology due to the attached gripper, i.e. its topology can be treated as transparent to you
 base is the native frame of the robot and its gripper
 you want the part pose equaling the place pose

base_gripper
is the variable to solve for, it commands the robot to move such that you get your desired outcome
place == part // goal in arbitrary frames
base_place == base_part // goal in the base frame
base_place == base_gripper * gripper_part // expanded into values we have and the variable we want
// note how ..._gripper*gripper_...., the matrices lock into each other
// now we need to isolate base_gripper on the right side, so we "subtract"/divide gripper_part
(base_place) * (gripper_part⁻¹) == (base_gripper * gripper_part) * (gripper_part⁻¹) // multiply from the right, both sides
base_place * (gripper_part⁻¹) == base_gripper * (gripper_part * gripper_part⁻¹) // moving parens, you'll see...
base_place * (gripper_part⁻¹) == base_gripper * I // poof, an identity
base_place * (gripper_part⁻¹) == base_gripper
that’s the calculation:
base_gripper := (base_place) * (gripper_part⁻¹)
some more explanation:
base_place * (gripper_part⁻¹) == base_gripper
base_place * part_gripper == base_gripper // that's the same but naming the legs "forward"
base_place * place_gripper == base_gripper // since place == part
base_part * part_gripper == base_gripper // since place == part
(gripper_part⁻¹) == part_gripper
is where the gripper goes, if you are in the part frame, which equals the place frame… so that’s where the gripper goes in the place frame.
now checking your question…
// translating into my notation
base_part * inv (base_place) = transform // ?
base_part * place_base = transform
base_place * place_base = transform
base_base = transform
// assuming senses are mixed up
Part_Base * inv (Place_Base) = transform
Part_Base * base_place = transform
Part_place = transform
not quite then. you’d be getting an identity in the first part (base_base
), or should want an identity (part = place) in the second half.