Removing inverse.

Inverse limts the type of transform one can use,
And it doesn't seem to have case that will require log_prob on target space

src/jimgw/prior.py

@@ -132,14 +132,14 @@ def sample(
 
     def log_prob(self, x: dict[str, Float]) -> Float:
         """
-        Requiring inverse transform in log_prob may not be the best option,
-        may need alternative
+        log_prob has to be evaluated in the space of the base_prior.
+
+
         """
-        output = 0.0
-        for transform in reversed(self.transforms):
-            x, log_jacobian = transform.inverse_transform(x)
-            output += log_jacobian
-        output += self.base_prior.log_prob(x)
+        output = self.base_prior.log_prob(x)
+        for transform in self.transforms:
+            x, log_jacobian = transform.transform(x)
+            output -= log_jacobian
         return output
 
 # class Combine(Prior):

src/jimgw/transforms.py

@@ -8,7 +8,6 @@
 from chex import assert_rank
 from jaxtyping import Array, Float, jaxtyped
 
-
 class Transform(ABC):
     """
     Base class for transform.
@@ -18,8 +17,6 @@ class Transform(ABC):
 
     name_mapping: tuple[list[str], list[str]]
     transform_func: Callable[[dict[str, Float]], dict[str, Float]]
-    inverse_func: Callable[[dict[str, Float]], dict[str, Float]]
-
     def __init__(
         self,
         name_mapping: tuple[list[str], list[str]],
@@ -49,23 +46,6 @@ def transform(self, x: dict[str, Float]) -> tuple[dict[str, Float], Float]:
         """
         raise NotImplementedError
 
-    @abstractmethod
-    def inverse_transform(self, x: dict[str, Float]) -> dict[str, Float]:
-        """
-        Inverse transform the input x to transformed coordinate y.
-
-        Parameters
-        ----------
-        x : dict[str, Float]
-                The input dictionary.
-
-        Returns
-        -------
-        y : dict[str, Float]
-                The transformed dictionary.
-        """
-        raise NotImplementedError
-
     @abstractmethod
     def forward(self, x: dict[str, Float]) -> dict[str, Float]:
         """
@@ -82,23 +62,6 @@ def forward(self, x: dict[str, Float]) -> dict[str, Float]:
                 The transformed dictionary.
         """
         raise NotImplementedError
-
-    @abstractmethod
-    def backward(self, x: dict[str, Float]) -> dict[str, Float]:
-        """
-        Pull back the input x to transformed coordinate y.
-
-        Parameters
-        ----------
-        x : dict[str, Float]
-                The input dictionary.
-
-        Returns
-        -------
-        y : dict[str, Float]
-                The transformed dictionary.
-        """
-        raise NotImplementedError
 
     def propagate_name(self, x: list[str]) -> list[str]:
         input_set = set(x)
@@ -123,29 +86,13 @@ def transform(self, x: dict[str, Float]) -> tuple[dict[str, Float], Float]:
         x[self.name_mapping[1][0]] = output_params
         return x, jnp.log(jacobian)
 
-    def inverse_transform(self, x: dict[str, Float]) -> dict[str, Float]:
-        output_params = x.pop(self.name_mapping[1][0])
-        assert_rank(output_params, 0)
-        input_params = self.inverse_func(output_params)
-        jacobian = jax.jacfwd(self.inverse_func)(output_params)
-        x[self.name_mapping[0][0]] = input_params
-        return x, jnp.log(jacobian)
-
     def forward(self, x: dict[str, Float]) -> dict[str, Float]:
         input_params = x.pop(self.name_mapping[0][0])
         assert_rank(input_params, 0)
         output_params = self.transform_func(input_params)
         x[self.name_mapping[1][0]] = output_params
         return x
 
-    def backward(self, x: dict[str, Float]) -> dict[str, Float]:
-        output_params = x.pop(self.name_mapping[1][0])
-        assert_rank(output_params, 0)
-        input_params = self.inverse_func(output_params)
-        x[self.name_mapping[0][0]] = input_params
-        return x
-
-
 class Scale(UnivariateTransform):
     scale: Float
 
@@ -157,7 +104,6 @@ def __init__(
         super().__init__(name_mapping)
         self.scale = scale
         self.transform_func = lambda x: x * self.scale
-        self.inverse_func = lambda x: x / self.scale
 
 class Offset(UnivariateTransform):
     offset: Float
@@ -170,7 +116,6 @@ def __init__(
         super().__init__(name_mapping)
         self.offset = offset
         self.transform_func = lambda x: x + self.offset
-        self.inverse_func = lambda x: x - self.offset
 
 class Logit(UnivariateTransform):
     """
@@ -189,7 +134,6 @@ def __init__(
     ):
         super().__init__(name_mapping)
         self.transform_func = lambda x: 1 / (1 + jnp.exp(-x))
-        self.inverse_func = lambda x: jnp.log(x / (1 - x))
 
 class Sine(UnivariateTransform):
     """