WIP

Signed-off-by: nstarman <nstarman@users.noreply.github.com>

Author: nstarman

README.md

@@ -88,14 +88,14 @@ import coordinax.charts as cxc
 import coordinax.transforms as cxt
 
 q = {"x": u.Q(1.0, "km"), "y": u.Q(2.0, "km"), "z": u.Q(3.0, "km")}
-q_sph = cxt.point_transform(cxc.sph3d, cxc.cart3d, q)
+q_sph = cxt.point_transition(cxc.sph3d, cxc.cart3d, q)
 ```
 
 We can also transform physical vector components between reps:
 
 ```
 v = {"x": u.Q(4.0, "km/s"), "y": u.Q(5.0, "km/s"), "z": u.Q(6.0, "km/s")}
-v_sph = cxt.physical_tangent_transform(cxc.sph3d, cxc.cart3d, v, at=q)
+v_sph = cxt.phys_tangent_basis_change(cxc.sph3d, cxc.cart3d, v, at=q)
 ```
 
 ## Metrics

docs/_spec.md

@@ -25,7 +25,7 @@ sph = cxc.sph3d  # Spherical3D
 
 # Transform coordinates between charts
 p = {"x": u.Q(1, "km"), "y": u.Q(2, "km"), "z": u.Q(3, "km")}
-p_sph = cxt.point_transform(sph, cart, p)
+p_sph = cxt.point_transition(sph, cart, p)
 ```
 
 ## Available Charts

docs/api/charts.md

@@ -40,15 +40,15 @@ pos_role = cxr.PhysDisp()
 
 ```
 AbstractRole
-├── Point         # Affine location (transforms via point_transform)
+├── Point         # Affine location (transforms via point_transition)
 ├── AbstractPhysRole
-│   ├── PhysDisp       # Physical displacement (physical_tangent_transform; needs at=)
-│   ├── PhysVel        # Physical velocity (physical_tangent_transform; needs at=)
-│   └── PhysAcc        # Physical acceleration (physical_tangent_transform; needs at=)
+│   ├── PhysDisp       # Physical displacement (phys_tangent_basis_change; needs at=)
+│   ├── PhysVel        # Physical velocity (phys_tangent_basis_change; needs at=)
+│   └── PhysAcc        # Physical acceleration (phys_tangent_basis_change; needs at=)
 └── AbstractCoordRole
-    ├── CoordDisp      # Coordinate-basis displacement (coord_tangent_transform; needs at=)
-    ├── CoordVel       # Coordinate-basis velocity (coord_tangent_transform; needs at=)
-    └── CoordAcc       # Coordinate-basis acceleration (coord_tangent_transform; needs at=)
+    ├── CoordDisp      # Coordinate-basis displacement (coord_tangent_pushforward; needs at=)
+    ├── CoordVel       # Coordinate-basis velocity (coord_tangent_pushforward; needs at=)
+    └── CoordAcc       # Coordinate-basis acceleration (coord_tangent_pushforward; needs at=)
 ```
 
 ## Role Semantics

docs/api/roles.md

@@ -20,17 +20,17 @@ import unxt as u
 
 # Transform a point from Cartesian to spherical (with Quantities)
 p_cart = {"x": u.Q(1, "km"), "y": u.Q(2, "km"), "z": u.Q(3, "km")}
-p_sph = cxt.point_transform(cxc.sph3d, cxc.cart3d, p_cart)
+p_sph = cxt.point_transition(cxc.sph3d, cxc.cart3d, p_cart)
 
 # Transform a point (with bare arrays - no units)
 p_cart_arr = {"x": 1.0, "y": 2.0, "z": 3.0}
-p_sph_arr = cxt.point_transform(
+p_sph_arr = cxt.point_transition(
     cxc.sph3d, cxc.cart3d, p_cart_arr, usys=u.unitsystems.galactic
 )
 
 # Transform a velocity vector (requires base point)
 v_cart = {"x": u.Q(10, "km/s"), "y": u.Q(20, "km/s"), "z": u.Q(30, "km/s")}
-v_sph = cxt.physical_tangent_transform(cxc.sph3d, cxc.cart3d, v_cart, at=p_cart)
+v_sph = cxt.phys_tangent_basis_change(cxc.sph3d, cxc.cart3d, v_cart, at=p_cart)
 ```
 
 ## Core Functions
@@ -42,7 +42,7 @@ Transform point coordinates from one chart to another:
 <!-- skip: next -->
 
 ```python
-p_new = cxt.point_transform(to_chart, from_chart, p)
+p_new = cxt.point_transition(to_chart, from_chart, p)
 ```
 
 The transformation is a coordinate-wise map that preserves the geometric
@@ -62,12 +62,12 @@ import unxt as u
 
 # With Quantities (explicit units)
 p_qty = {"r": u.Q(10, "m")}
-p_cart = cxt.point_transform(cxc.cart1d, cxc.radial1d, p_qty)
+p_cart = cxt.point_transition(cxc.cart1d, cxc.radial1d, p_qty)
 # Result: {'x': Quantity(Array(10, dtype=int64, ...), unit='m')}
 
 # With bare values (no units)
 p_arr = {"r": 5}
-p_cart = cxt.point_transform(cxc.cart1d, cxc.radial1d, p_arr, usys=u.unitsystems.si)
+p_cart = cxt.point_transition(cxc.cart1d, cxc.radial1d, p_arr, usys=u.unitsystems.si)
 # Result: {'x': 5}
 ```
 
@@ -78,7 +78,7 @@ Transform tangent vectors (velocities, accelerations) between charts:
 <!-- skip: next -->
 
 ```python
-v_new = cxt.physical_tangent_transform(to_chart, from_chart, v, at=p)
+v_new = cxt.phys_tangent_basis_change(to_chart, from_chart, v, at=p)
 ```
 
 This uses the Jacobian of the coordinate transformation to correctly transform

docs/api/transforms.md

@@ -177,7 +177,7 @@ v_mixed = {"rho": u.Q(1.0, "m/s"), "phi": u.Q(0.1, "rad/s"), "z": u.Q(0.5, "m/s"
 # This would be coordinate differentials, not physical vectors
 ```
 
-The bundle automatically uses `coordinax.transforms.physical_tangent_transform`
+The bundle automatically uses `coordinax.transforms.phys_tangent_basis_change`
 for fibre conversions, which expects homogeneous physical components.
 
 ### Batched Bundles
@@ -359,4 +359,4 @@ See [API Documentation](../api/vecs.md) for detailed method signatures.
 - [Coordinate Representations](charts.md) - Available coordinate systems
 - [Operators](operators.md) - Geometric operations on vectors
 - API: `coordinax.PointedVector`
-- API: `coordinax.transforms.physical_tangent_transform`
+- API: `coordinax.transforms.phys_tangent_basis_change`

docs/guides/anchored_vector_bundle.md

@@ -22,7 +22,7 @@ and shows how to transform parameter dictionaries and vectors.
   units (e.g. all speed or all acceleration).
 - Coordinate derivatives: time derivatives of coordinate components (e.g.
   \dot\theta, \ddot\phi); these may have heterogeneous units and are not what
-  `physical_tangent_transform`/`vconvert` uses for physical vectors.
+  `phys_tangent_basis_change`/`vconvert` uses for physical vectors.
 
 ## Distances and Angles
 
@@ -36,9 +36,9 @@ a = u.Angle(30.0, "deg")
 
 ## Representations and Coordinate Maps
 
-The `point_transform` function converts coordinates between different charts. It
-accepts `CsDict` values that can be either **Quantities** (values with explicit
-units) or **bare arrays** (dimensionless values).
+The `point_transition` function converts coordinates between different charts.
+It accepts `CsDict` values that can be either **Quantities** (values with
+explicit units) or **bare arrays** (dimensionless values).
 
 ### With Quantities
 
@@ -54,7 +54,7 @@ rep_sph = cxc.sph3d
 
 q = {"x": u.Q(1, "km"), "y": u.Q(2, "km"), "z": u.Q(3, "km")}
 
-q_sph = cxt.point_transform(rep_sph, rep_cart, q)
+q_sph = cxt.point_transition(rep_sph, rep_cart, q)
 # Result: {'r': Quantity(..., unit='km'), 'theta': ..., 'phi': ...}
 ```
 
@@ -69,13 +69,13 @@ import unxt as u
 
 # 1D example: Radial to Cartesian
 to_chart, from_chart = cxc.cart1d, cxc.radial1d
-cxt.point_transform(to_chart, from_chart, {"r": 5})
+cxt.point_transition(to_chart, from_chart, {"r": 5})
 # Result: {'x': 5}
 
 # 2D example: Polar to Cartesian
 import jax.numpy as jnp
 p_polar = {"r": 1.0, "theta": jnp.pi / 4}
-p_cart = cxt.point_transform(cxc.cart2d, cxc.polar2d, p_polar, usys=u.unitsystems.galactic)
+p_cart = cxt.point_transition(cxc.cart2d, cxc.polar2d, p_polar, usys=u.unitsystems.galactic)
 # Result: {'x': 0.707..., 'y': 0.707...}
 ```
 

docs/guides/charts.md

@@ -22,11 +22,11 @@ physical components are pushed forward and projected using orthonormal frames.
   units (e.g. all speed or all acceleration).
 - Coordinate derivatives: time derivatives of coordinate components (e.g.
   \dot\theta, \ddot\phi); these may have heterogeneous units and are not what
-  `physical_tangent_transform`/`vconvert` uses for physical vectors.
+  `phys_tangent_basis_change`/`vconvert` uses for physical vectors.
 
 ## Physical components vs coordinate derivatives
 
-Physical components are the inputs to `physical_tangent_transform` and
+Physical components are the inputs to `phys_tangent_basis_change` and
 `vconvert`. Coordinate derivatives can mix units and are not transformed by
 these routines:
 

docs/guides/embedded_manifolds.md

@@ -22,11 +22,11 @@ physical components are interpreted and compared.
   units (e.g. all speed or all acceleration).
 - Coordinate derivatives: time derivatives of coordinate components (e.g.
   \dot\theta, \ddot\phi); these may have heterogeneous units and are not what
-  `physical_tangent_transform`/`vconvert` uses for physical vectors.
+  `phys_tangent_basis_change`/`vconvert` uses for physical vectors.
 
 ## Physical components vs coordinate derivatives
 
-Physical components are the inputs to `physical_tangent_transform` and
+Physical components are the inputs to `phys_tangent_basis_change` and
 `vconvert`. Coordinate derivatives can mix units and are not transformed by
 these routines:
 

docs/guides/metrics.md

@@ -24,12 +24,12 @@ displacement can be added to a point** to yield a new point.
 **This is the most important concept**: positions and displacements transform
 differently under coordinate changes.
 
-| Role       | Geometric Object              | Transformation Rule                            | Function                     | Base Point? |
-| ---------- | ----------------------------- | ---------------------------------------------- | ---------------------------- | ----------- |
-| `Point`    | Point $p \in M$               | Position transform: $p_S = f_{R \to S}(p_R)$   | `point_transform`            | No          |
-| `PhysDisp` | Physical vector $v \in T_p M$ | Tangent transform: $v_S = B_S(p)^T B_R(p) v_R$ | `physical_tangent_transform` | Sometimes\* |
-| `PhysVel`  | Physical vector $v \in T_p M$ | Tangent transform: $v_S = B_S(p)^T B_R(p) v_R$ | `physical_tangent_transform` | Sometimes\* |
-| `PhysAcc`  | Physical vector $a \in T_p M$ | Tangent transform: $a_S = B_S(p)^T B_R(p) v_R$ | `physical_tangent_transform` | Sometimes\* |
+| Role       | Geometric Object              | Transformation Rule                            | Function                    | Base Point? |
+| ---------- | ----------------------------- | ---------------------------------------------- | --------------------------- | ----------- |
+| `Point`    | Point $p \in M$               | Position transform: $p_S = f_{R \to S}(p_R)$   | `point_transition`          | No          |
+| `PhysDisp` | Physical vector $v \in T_p M$ | Tangent transform: $v_S = B_S(p)^T B_R(p) v_R$ | `phys_tangent_basis_change` | Sometimes\* |
+| `PhysVel`  | Physical vector $v \in T_p M$ | Tangent transform: $v_S = B_S(p)^T B_R(p) v_R$ | `phys_tangent_basis_change` | Sometimes\* |
+| `PhysAcc`  | Physical vector $a \in T_p M$ | Tangent transform: $a_S = B_S(p)^T B_R(p) v_R$ | `phys_tangent_basis_change` | Sometimes\* |
 
 \*Base point required for:
 
@@ -42,13 +42,13 @@ differently under coordinate changes.
 The distinction between these transformation types is formalized in coordinax
 through two separate functions:
 
-1. **`point_transform(to_chart, from_chart, p)`**: Chart-to-chart mapping
+1. **`point_transition(to_chart, from_chart, p)`**: Chart-to-chart mapping
    - Maps points between coordinate charts: $p_{\text{new}} = f(p_{\text{old}})$
    - Used for: Position vectors (role `PhysDisp`)
    - Does not require a base point
    - Example: Converting a position from Cartesian to spherical coordinates
 
-2. **`physical_tangent_transform(to_chart, from_chart, v, at=p_base)`**:
+2. **`phys_tangent_basis_change(to_chart, from_chart, v, at=p_base)`**:
    Frame-based mapping at a point
    - Maps tangent vectors at a point via the frame transformation:
      $v_S = B_S(p)^T B_R(p) v_R$
@@ -259,7 +259,7 @@ origin = cx.Vector.from_([0, 0, 0], "m")
 
 # Get displacement in spherical representation
 disp_sph = cx.as_disp(pos, origin, chart=cxc.sph3d, at=pos)
-# Uses physical_tangent_transform to convert to spherical at base point 'pos'
+# Uses phys_tangent_basis_change to convert to spherical at base point 'pos'
 ```
 
 ## Euclidean vs Non-Euclidean Representations