rename dataclass_abc to dataclassabc

157 files changed, 1038 insertions, 1246 deletions

diff --git a/polymatrix/__init__.py b/polymatrix/__init__.py
index 64f3d63..8cffe4b 100644
--- a/polymatrix/__init__.py
+++ b/polymatrix/__init__.py
@@ -7,9 +7,8 @@ import numpy as np
 import scipy.sparse
 import sympy
 
-from polymatrix.expression.mixins.expressionmixin import ExpressionMixin as Expression
+from polymatrix.expression.expression import Expression
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-# from polymatrix.expression.mixins.expressionmixin import ExpressionMixin
 from polymatrix.expression.mixins.parametrizeexprmixin import ParametrizeExprMixin
 from polymatrix.expression.mixins.parametrizematrixexprmixin import ParametrizeMatrixExprMixin
 from polymatrix.expressionstate.expressionstate import ExpressionState
@@ -480,7 +479,10 @@ def to_matrix_repr(
             else:
                 sorted_variable_index = variable_index
 
-            assert len(sorted_variable_index) == len(set(sorted_variable_index)), f'{sorted_variable_index=} contains repeated variables. Make sure you give a unique name for each variables.'
+            sorted_variable_index_set = set(sorted_variable_index)
+            if len(sorted_variable_index) != len(sorted_variable_index_set):
+                duplicates = tuple(state.get_name_from_offset(var) for var in sorted_variable_index_set if 1 < sorted_variable_index.count(var))
+                raise Exception(f'{duplicates=}. Make sure you give a unique name for each variables.')
         
         variable_index_map = {old: new for new, old in enumerate(sorted_variable_index)}
 
@@ -575,6 +577,7 @@ def to_matrix_repr(
 
     return init_state_monad(func)
 
+
 def to_constant_repr(
     expr: Expression,
     assert_constant: bool = True,
diff --git a/polymatrix/expression/additionexpr.py b/polymatrix/expression/additionexpr.py
deleted file mode 100644
index 6a43ba3..0000000
--- a/polymatrix/expression/additionexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.additionexprmixin import AdditionExprMixin 
-
-class AdditionExpr(AdditionExprMixin):
-	pass
diff --git a/polymatrix/expression/blockdiagexpr.py b/polymatrix/expression/blockdiagexpr.py
deleted file mode 100644
index e3acee5..0000000
--- a/polymatrix/expression/blockdiagexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.blockdiagexprmixin import BlockDiagExprMixin 
-
-class BlockDiagExpr(BlockDiagExprMixin):
-	pass
diff --git a/polymatrix/expression/cacheexpr.py b/polymatrix/expression/cacheexpr.py
deleted file mode 100644
index 5ae4052..0000000
--- a/polymatrix/expression/cacheexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.cacheexprmixin import CacheExprMixin 
-
-class CacheExpr(CacheExprMixin):
-	pass
diff --git a/polymatrix/expression/combinationsexpr.py b/polymatrix/expression/combinationsexpr.py
deleted file mode 100644
index 3373365..0000000
--- a/polymatrix/expression/combinationsexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.combinationsexprmixin import CombinationsExprMixin 
-
-class CombinationsExpr(CombinationsExprMixin):
-	pass
diff --git a/polymatrix/expression/derivativeexpr.py b/polymatrix/expression/derivativeexpr.py
deleted file mode 100644
index 6805e4b..0000000
--- a/polymatrix/expression/derivativeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.derivativeexprmixin import DerivativeExprMixin 
-
-class DerivativeExpr(DerivativeExprMixin):
-	pass
diff --git a/polymatrix/expression/determinantexpr.py b/polymatrix/expression/determinantexpr.py
deleted file mode 100644
index 6e584f9..0000000
--- a/polymatrix/expression/determinantexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.determinantexprmixin import DeterminantExprMixin 
-
-class DeterminantExpr(DeterminantExprMixin):
-	pass
diff --git a/polymatrix/expression/diagexpr.py b/polymatrix/expression/diagexpr.py
deleted file mode 100644
index 1fcf14e..0000000
--- a/polymatrix/expression/diagexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.diagexprmixin import DiagExprMixin 
-
-class DiagExpr(DiagExprMixin):
-	pass
diff --git a/polymatrix/expression/divergenceexpr.py b/polymatrix/expression/divergenceexpr.py
deleted file mode 100644
index 9207bd2..0000000
--- a/polymatrix/expression/divergenceexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.divergenceexprmixin import DivergenceExprMixin 
-
-class DivergenceExpr(DivergenceExprMixin):
-	pass
diff --git a/polymatrix/expression/divisionexpr.py b/polymatrix/expression/divisionexpr.py
deleted file mode 100644
index 63c95d9..0000000
--- a/polymatrix/expression/divisionexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.divisionexprmixin import DivisionExprMixin 
-
-class DivisionExpr(DivisionExprMixin):
-	pass
diff --git a/polymatrix/expression/elemmultexpr.py b/polymatrix/expression/elemmultexpr.py
deleted file mode 100644
index 1c8ef58..0000000
--- a/polymatrix/expression/elemmultexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.elemmultexprmixin import ElemMultExprMixin 
-
-class ElemMultExpr(ElemMultExprMixin):
-	pass
diff --git a/polymatrix/expression/evalexpr.py b/polymatrix/expression/evalexpr.py
deleted file mode 100644
index 0af72d1..0000000
--- a/polymatrix/expression/evalexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.evalexprmixin import EvalExprMixin 
-
-class EvalExpr(EvalExprMixin):
-	pass
diff --git a/polymatrix/expression/expression.py b/polymatrix/expression/expression.py
index 7f34637..25a8c9b 100644
--- a/polymatrix/expression/expression.py
+++ b/polymatrix/expression/expression.py
@@ -1,4 +1,537 @@
-from polymatrix.expression.mixins.expressionmixin import ExpressionMixin 
+import abc
+import dataclasses
+import dataclassabc
+import typing
+import numpy as np
 
-class Expression(ExpressionMixin):
-	pass
+from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
+from polymatrix.expression.init.initadditionexpr import init_addition_expr
+from polymatrix.expression.init.initcacheexpr import init_cache_expr
+from polymatrix.expression.init.initcombinationsexpr import init_combinations_expr
+from polymatrix.expression.init.initderivativeexpr import init_derivative_expr
+from polymatrix.expression.init.initdeterminantexpr import init_determinant_expr
+from polymatrix.expression.init.initdivergenceexpr import init_divergence_expr
+from polymatrix.expression.init.initdivisionexpr import init_division_expr
+from polymatrix.expression.init.initelemmultexpr import init_elem_mult_expr
+from polymatrix.expression.init.initevalexpr import init_eval_expr
+from polymatrix.expression.init.initfilterexpr import init_filter_expr
+from polymatrix.expression.init.initfromsymmetricmatrixexpr import init_from_symmetric_matrix_expr
+from polymatrix.expression.init.inithalfnewtonpolytopeexpr import init_half_newton_polytope_expr
+from polymatrix.expression.init.initlinearinexpr import init_linear_in_expr
+from polymatrix.expression.init.initfromsympyexpr import init_from_expr_or_none, init_from_sympy_expr
+from polymatrix.expression.init.initgetitemexpr import init_get_item_expr
+from polymatrix.expression.init.initlinearmatrixinexpr import init_linear_matrix_in_expr
+from polymatrix.expression.init.initlinearmonomialsexpr import init_linear_monomials_expr
+from polymatrix.expression.init.initmatrixmultexpr import init_matrix_mult_expr
+from polymatrix.expression.init.initmaxdegreeexpr import init_max_degree_expr
+from polymatrix.expression.init.initmaxexpr import init_max_expr
+from polymatrix.expression.init.initparametrizeexpr import init_parametrize_expr
+from polymatrix.expression.init.initparametrizematrixexpr import init_parametrize_matrix_expr
+from polymatrix.expression.init.initquadraticinexpr import init_quadratic_in_expr
+from polymatrix.expression.init.initrepmatexpr import init_rep_mat_expr
+from polymatrix.expression.init.initreshapeexpr import init_reshape_expr
+from polymatrix.expression.init.initsetelementatexpr import init_set_element_at_expr
+from polymatrix.expression.init.initquadraticmonomialsexpr import init_quadratic_monomials_expr
+from polymatrix.expression.init.initsqueezeexpr import init_squeeze_expr
+from polymatrix.expression.init.initsubstituteexpr import init_substitute_expr
+from polymatrix.expression.init.initsubtractmonomialsexpr import init_subtract_monomials_expr
+from polymatrix.expression.init.initsumexpr import init_sum_expr
+from polymatrix.expression.init.initsymmetricexpr import init_symmetric_expr
+from polymatrix.expression.init.inittoconstantexpr import init_to_constant_expr
+from polymatrix.expression.init.inittoquadraticexpr import init_to_quadratic_expr
+from polymatrix.expression.init.initdiagexpr import init_diag_expr
+from polymatrix.expression.init.inittosortedvariables import init_to_sorted_variables
+from polymatrix.expression.init.inittosymmetricmatrixexpr import init_to_symmetric_matrix_expr
+from polymatrix.expression.init.inittransposeexpr import init_transpose_expr
+from polymatrix.expression.init.inittruncateexpr import init_truncate_expr
+
+from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
+from polymatrix.polymatrix.polymatrix import PolyMatrix
+from polymatrix.expressionstate.expressionstate import ExpressionState
+
+
+class Expression(
+    ExpressionBaseMixin,
+    abc.ABC,
+):
+
+    @property
+    @abc.abstractmethod
+    def underlying(self) -> ExpressionBaseMixin:
+        ...
+
+    # overwrites abstract method of `PolyMatrixExprBaseMixin`
+    def apply(self, state: ExpressionState) -> tuple[ExpressionState, PolyMatrix]:
+        return self.underlying.apply(state)
+
+    def __add__(self, other: ExpressionBaseMixin) -> 'Expression':
+        return self._binary(init_addition_expr, self, other)
+
+    def __getattr__(self, name):
+        attr = getattr(self.underlying, name)
+
+        if isinstance(attr, ExpressionBaseMixin):
+            return dataclasses.replace(
+                self, 
+                underlying=attr,
+            )
+
+        else:
+            return attr
+
+    def __getitem__(self, key: tuple[int, int]):
+        return dataclasses.replace(
+            self, 
+            underlying=init_get_item_expr(
+                underlying=self.underlying,
+                index=key,
+            ),
+        )     
+
+    def __matmul__(self, other: typing.Union[ExpressionBaseMixin, np.ndarray]) -> 'Expression':
+        return self._binary(init_matrix_mult_expr, self, other)
+
+    def __mul__(self, other) -> 'Expression':
+        return self._binary(init_elem_mult_expr, self, other)
+
+    def __pow__(self, num):
+        curr = 1
+
+        for _ in range(num):
+            curr = curr * self
+
+        return curr
+
+    def __neg__(self):
+        return self * (-1)
+
+    def __radd__(self, other):
+        return self._binary(init_addition_expr, other, self)
+
+    def __rmatmul__(self, other):
+        return self._binary(init_matrix_mult_expr, other, self)
+
+    def __rmul__(self, other):
+        return self * other
+    
+    def __rsub__(self, other):
+        return other + (-self)
+
+    def __sub__(self, other):
+        return self + (-other)
+
+    def __truediv__(self, other: ExpressionBaseMixin):
+        return self._binary(init_division_expr, self, other)
+
+    @staticmethod
+    def _binary(op, left, right):
+        if not isinstance(left, Expression):
+            left = init_from_expr_or_none(left)
+
+            if left is None:
+                return NotImplemented
+
+            return dataclasses.replace(
+                right, 
+                underlying=op(left, right),
+            )
+
+        else:
+            right = init_from_expr_or_none(right)
+            
+            if right is None:
+                return NotImplemented
+
+            return dataclasses.replace(
+                left, 
+                underlying=op(left, right),
+            )
+
+    # def _convert_to_expression(self, other):       
+    #     result = init_from_expr_or_none(other)
+
+    #     if result is None:
+    #         return NotImplemented
+        
+    #     return result
+
+    def cache(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_cache_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    # only applies to monomials and variables
+    def combinations(self, number: int):
+        return dataclasses.replace(
+            self, 
+            underlying=init_combinations_expr(
+                monomials=self.underlying,
+                number=number,
+            ),
+        )
+
+    def determinant(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_determinant_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    def diag(self):
+        return dataclasses.replace(
+            self, 
+            underlying=init_diag_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    def diff(
+        self, 
+        variables: 'Expression',
+        introduce_derivatives: bool = None,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_derivative_expr(
+                underlying=self.underlying,
+                variables=variables,
+                introduce_derivatives=introduce_derivatives,
+            ),
+        )
+
+    def divergence(
+        self, 
+        variables: tuple,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_divergence_expr(
+                underlying=self.underlying,
+                variables=variables,
+            ),
+        )
+
+    def eval(
+        self,
+        variable: tuple, 
+        value: tuple[float, ...] = None,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_eval_expr(
+                underlying=self.underlying,
+                variables=variable,
+                values=value,
+            ),
+        )
+
+    # also applies to monomials (and variables?)
+    def filter(
+        self,
+        predicator: 'Expression',
+        inverse: bool = None,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_filter_expr(
+                underlying=self.underlying,
+                predicator=predicator,
+                inverse=inverse,
+            ),
+        )
+
+    # only applies to symmetric matrix
+    def from_symmetric_matrix(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_from_symmetric_matrix_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    # only applies to monomials
+    def half_newton_polytope(
+        self,
+        variables: 'Expression',
+        filter: 'Expression | None' = None,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_half_newton_polytope_expr(
+                monomials=self.underlying,
+                variables=variables,
+                filter=filter,
+            ),
+        )
+
+    def linear_matrix_in(self, variable: 'Expression') -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_linear_matrix_in_expr(
+                underlying=self.underlying,
+                variable=variable,
+            ),
+        )
+
+    def linear_monomials(self, variables: 'Expression') -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_linear_monomials_expr(
+                underlying=self.underlying,
+                variables=variables,
+            ),
+        )
+
+    def linear_in(
+        self, 
+        variables: 'Expression', 
+        monomials: 'Expression' = None,
+        ignore_unmatched: bool = None,    
+    ) -> 'Expression':
+        if monomials is None:
+            monomials = self.linear_monomials(variables)
+
+        return dataclasses.replace(
+            self, 
+            underlying=init_linear_in_expr(
+                underlying=self.underlying,
+                monomials=monomials,
+                variables=variables,
+                ignore_unmatched=ignore_unmatched,
+            ),
+        )
+
+    def max(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_max_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    def max_degree(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_max_degree_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    def parametrize(self, name: str = None) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_parametrize_expr(
+                underlying=self.underlying,
+                name=name,
+            ),
+        )
+    
+    # def parametrize_matrix(self, name: str = None) -> 'ExpressionMixin':
+    #     return dataclasses.replace(
+    #         self, 
+    #         underlying=init_parametrize_matrix_expr(
+    #             underlying=self.underlying,
+    #             name=name,
+    #         ),
+    #     )
+
+    def quadratic_in(self, variables: 'Expression', monomials: 'Expression' = None) -> 'Expression':
+        if monomials is None:
+            monomials = self.quadratic_monomials(variables)
+
+        return dataclasses.replace(
+            self, 
+            underlying=init_quadratic_in_expr(
+                underlying=self.underlying,
+                monomials=monomials,
+                variables=variables,
+            ),
+        )
+
+    def quadratic_monomials(
+        self, 
+        variables: 'Expression',
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_quadratic_monomials_expr(
+                underlying=self.underlying,
+                variables=variables,
+            ),
+        )
+
+    def reshape(self, n: int, m: int) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_reshape_expr(
+                underlying=self.underlying,
+                new_shape=(n, m),
+            ),
+        )
+
+    def rep_mat(self, n: int, m: int) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_rep_mat_expr(
+                underlying=self.underlying,
+                repetition=(n, m),
+            ),
+        )
+
+    def set_element_at(
+        self,
+        row: int,
+        col: int, 
+        value: 'Expression',
+    ) -> 'Expression':
+        if isinstance(value, Expression):
+            value = value.underlying
+        else:
+            value = init_from_sympy_expr(value)
+
+        return dataclasses.replace(
+            self, 
+            underlying=init_set_element_at_expr(
+                underlying=self.underlying,
+                index=(row, col),
+                value=value,
+            ),
+        )
+
+    #todo: remove?
+    def squeeze(
+        self,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_squeeze_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    # only applies to monomials
+    def subtract_monomials(
+        self, 
+        monomials: 'Expression',
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_subtract_monomials_expr(
+                underlying=self.underlying,
+                monomials=monomials,
+            ),
+        )
+
+    def substitute(
+        self,
+        variable: tuple, 
+        values: tuple['Expression', ...] = None,
+    ) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_substitute_expr(
+                underlying=self.underlying,
+                variables=variable,
+                values=values,
+            ),
+        )
+
+    def subs(
+        self,
+        variable: tuple, 
+        values: tuple['Expression', ...] = None,
+    ) -> 'Expression':
+        return self.substitute(
+            variable=variable,
+            values=values,
+        )
+
+    def sum(self):
+        return dataclasses.replace(
+            self, 
+            underlying=init_sum_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    def symmetric(self):
+        return dataclasses.replace(
+            self, 
+            underlying=init_symmetric_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    def transpose(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_transpose_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    @property
+    def T(self) -> 'Expression':
+        return self.transpose()
+
+    def to_constant(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_to_constant_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    # def to_quadratic(self) -> 'ExpressionMixin':
+    #     return dataclasses.replace(
+    #         self, 
+    #         underlying=init_to_quadratic_expr(
+    #             underlying=self.underlying,
+    #         ),
+    #     )
+
+    def to_symmetric_matrix(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_to_symmetric_matrix_expr(
+                underlying=self.underlying,
+            ),
+        )
+
+    # only applies to variables
+    def to_sorted_variables(self) -> 'Expression':
+        return dataclasses.replace(
+            self, 
+            underlying=init_to_sorted_variables(
+                underlying=self.underlying,
+            ),
+        )
+
+    # also applies to monomials?
+    def truncate(
+        self, 
+        variables: tuple, 
+        degrees: tuple[int],
+        inverse: bool = None,    
+    ):
+        return dataclasses.replace(
+            self, 
+            underlying=init_truncate_expr(
+                underlying=self.underlying,
+                variables=variables,
+                degrees=degrees,
+                inverse=inverse,
+            ),
+        )
+
+
+@dataclassabc.dataclassabc(frozen=True, repr=False)
+class ExpressionImpl(Expression):
+	underlying: ExpressionBaseMixin
+
+	def __repr__(self) -> str:
+		return self.underlying.__repr__()
diff --git a/polymatrix/expression/eyeexpr.py b/polymatrix/expression/eyeexpr.py
deleted file mode 100644
index 4e64569..0000000
--- a/polymatrix/expression/eyeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.eyeexprmixin import EyeExprMixin 
-
-class EyeExpr(EyeExprMixin):
-	pass
diff --git a/polymatrix/expression/filterexpr.py b/polymatrix/expression/filterexpr.py
deleted file mode 100644
index e7ca235..0000000
--- a/polymatrix/expression/filterexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.filterexprmixin import FilterExprMixin 
-
-class FilterExpr(FilterExprMixin):
-	pass
diff --git a/polymatrix/expression/fromsymmetricmatrixexpr.py b/polymatrix/expression/fromsymmetricmatrixexpr.py
deleted file mode 100644
index 8ddf2ef..0000000
--- a/polymatrix/expression/fromsymmetricmatrixexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.fromsymmetricmatrixexprmixin import FromSymmetricMatrixExprMixin 
-
-class FromSymmetricMatrixExpr(FromSymmetricMatrixExprMixin):
-	pass
diff --git a/polymatrix/expression/fromsympyexpr.py b/polymatrix/expression/fromsympyexpr.py
deleted file mode 100644
index b1e723a..0000000
--- a/polymatrix/expression/fromsympyexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.fromsympyexprmixin import FromSympyExprMixin 
-
-class FromSympyExpr(FromSympyExprMixin):
-	pass
diff --git a/polymatrix/expression/fromtermsexpr.py b/polymatrix/expression/fromtermsexpr.py
deleted file mode 100644
index 2dbb5aa..0000000
--- a/polymatrix/expression/fromtermsexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.fromtermsexprmixin import FromTermsExprMixin 
-
-class FromTermsExpr(FromTermsExprMixin):
-	pass
diff --git a/polymatrix/expression/getitemexpr.py b/polymatrix/expression/getitemexpr.py
deleted file mode 100644
index e7d32c2..0000000
--- a/polymatrix/expression/getitemexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.getitemexprmixin import GetItemExprMixin 
-
-class GetItemExpr(GetItemExprMixin):
-	pass
diff --git a/polymatrix/expression/halfnewtonpolytopeexpr.py b/polymatrix/expression/halfnewtonpolytopeexpr.py
deleted file mode 100644
index 8240d45..0000000
--- a/polymatrix/expression/halfnewtonpolytopeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.halfnewtonpolytopeexprmixin import HalfNewtonPolytopeExprMixin 
-
-class HalfNewtonPolytopeExpr(HalfNewtonPolytopeExprMixin):
-	pass
diff --git a/polymatrix/expression/impl/__init__.py b/polymatrix/expression/impl/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/polymatrix/expression/impl/__init__.py
+++ /dev/null
diff --git a/polymatrix/expression/impl/additionexprimpl.py b/polymatrix/expression/impl/additionexprimpl.py
deleted file mode 100644
index 2fd7220..0000000
--- a/polymatrix/expression/impl/additionexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.additionexpr import AdditionExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class AdditionExprImpl(AdditionExpr):
-	left: ExpressionBaseMixin
-	right: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/blockdiagexprimpl.py b/polymatrix/expression/impl/blockdiagexprimpl.py
deleted file mode 100644
index a2707d8..0000000
--- a/polymatrix/expression/impl/blockdiagexprimpl.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.blockdiagexpr import BlockDiagExpr 
-
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class BlockDiagExprImpl(BlockDiagExpr):
-	underlying: tuple
diff --git a/polymatrix/expression/impl/cacheexprimpl.py b/polymatrix/expression/impl/cacheexprimpl.py
deleted file mode 100644
index 4ca4bf2..0000000
--- a/polymatrix/expression/impl/cacheexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.cacheexpr import CacheExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-# @dataclass_abc.dataclass_abc(frozen=True, eq=False)
-@dataclass_abc.dataclass_abc(frozen=True)
-class CacheExprImpl(CacheExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/combinationsexprimpl.py b/polymatrix/expression/impl/combinationsexprimpl.py
deleted file mode 100644
index 2438e01..0000000
--- a/polymatrix/expression/impl/combinationsexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.combinationsexpr import CombinationsExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class CombinationsExprImpl(CombinationsExpr):
-	monomials: ExpressionBaseMixin
-	number: int
diff --git a/polymatrix/expression/impl/derivativeexprimpl.py b/polymatrix/expression/impl/derivativeexprimpl.py
deleted file mode 100644
index 87884ab..0000000
--- a/polymatrix/expression/impl/derivativeexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.derivativeexpr import DerivativeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class DerivativeExprImpl(DerivativeExpr):
-	underlying: ExpressionBaseMixin
-	variables: tuple
-	introduce_derivatives: bool
diff --git a/polymatrix/expression/impl/determinantexprimpl.py b/polymatrix/expression/impl/determinantexprimpl.py
deleted file mode 100644
index 3dc4ace..0000000
--- a/polymatrix/expression/impl/determinantexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.determinantexpr import DeterminantExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class DeterminantExprImpl(DeterminantExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/diagexprimpl.py b/polymatrix/expression/impl/diagexprimpl.py
deleted file mode 100644
index 950f2b8..0000000
--- a/polymatrix/expression/impl/diagexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.diagexpr import DiagExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class DiagExprImpl(DiagExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/divergenceexprimpl.py b/polymatrix/expression/impl/divergenceexprimpl.py
deleted file mode 100644
index 0ea9cdb..0000000
--- a/polymatrix/expression/impl/divergenceexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.divergenceexpr import DivergenceExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-from typing import Union 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class DivergenceExprImpl(DivergenceExpr):
-	underlying: ExpressionBaseMixin
-	variables: tuple
diff --git a/polymatrix/expression/impl/divisionexprimpl.py b/polymatrix/expression/impl/divisionexprimpl.py
deleted file mode 100644
index 639210e..0000000
--- a/polymatrix/expression/impl/divisionexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.divisionexpr import DivisionExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True, eq=False)
-class DivisionExprImpl(DivisionExpr):
-	left: ExpressionBaseMixin
-	right: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/elemmultexprimpl.py b/polymatrix/expression/impl/elemmultexprimpl.py
deleted file mode 100644
index a9990e4..0000000
--- a/polymatrix/expression/impl/elemmultexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.elemmultexpr import ElemMultExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class ElemMultExprImpl(ElemMultExpr):
-	left: ExpressionBaseMixin
-	right: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/evalexprimpl.py b/polymatrix/expression/impl/evalexprimpl.py
deleted file mode 100644
index 7f13a78..0000000
--- a/polymatrix/expression/impl/evalexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.evalexpr import EvalExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class EvalExprImpl(EvalExpr):
-	underlying: ExpressionBaseMixin
-	substitutions: tuple
-	# values: tuple
diff --git a/polymatrix/expression/impl/expressionimpl.py b/polymatrix/expression/impl/expressionimpl.py
deleted file mode 100644
index 6f140b5..0000000
--- a/polymatrix/expression/impl/expressionimpl.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.expression import Expression 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True, repr=False)
-class ExpressionImpl(Expression):
-	underlying: ExpressionBaseMixin
-
-	def __repr__(self) -> str:
-		return self.underlying.__repr__()
diff --git a/polymatrix/expression/impl/eyeexprimpl.py b/polymatrix/expression/impl/eyeexprimpl.py
deleted file mode 100644
index 9c50f8a..0000000
--- a/polymatrix/expression/impl/eyeexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.eyeexpr import EyeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class EyeExprImpl(EyeExpr):
-	variable: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/filterexprimpl.py b/polymatrix/expression/impl/filterexprimpl.py
deleted file mode 100644
index 547ad9e..0000000
--- a/polymatrix/expression/impl/filterexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.filterexpr import FilterExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class FilterExprImpl(FilterExpr):
-	underlying: ExpressionBaseMixin
-	predicator: ExpressionBaseMixin
-	inverse: bool == None
diff --git a/polymatrix/expression/impl/fromsymmetricmatrixexprimpl.py b/polymatrix/expression/impl/fromsymmetricmatrixexprimpl.py
deleted file mode 100644
index 1c54162..0000000
--- a/polymatrix/expression/impl/fromsymmetricmatrixexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.fromsymmetricmatrixexpr import FromSymmetricMatrixExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class FromSymmetricMatrixExprImpl(FromSymmetricMatrixExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/fromsympyexprimpl.py b/polymatrix/expression/impl/fromsympyexprimpl.py
deleted file mode 100644
index 986612b..0000000
--- a/polymatrix/expression/impl/fromsympyexprimpl.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.fromsympyexpr import FromSympyExpr 
-
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class FromSympyExprImpl(FromSympyExpr):
-	data: tuple[tuple[float]]
diff --git a/polymatrix/expression/impl/fromtermsexprimpl.py b/polymatrix/expression/impl/fromtermsexprimpl.py
deleted file mode 100644
index 92bb6a7..0000000
--- a/polymatrix/expression/impl/fromtermsexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.fromtermsexpr import FromTermsExpr 
-
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class FromTermsExprImpl(FromTermsExpr):
-	terms: tuple
-	shape: tuple[int, int]
diff --git a/polymatrix/expression/impl/getitemexprimpl.py b/polymatrix/expression/impl/getitemexprimpl.py
deleted file mode 100644
index 578d4c7..0000000
--- a/polymatrix/expression/impl/getitemexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.getitemexpr import GetItemExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class GetItemExprImpl(GetItemExpr):
-	underlying: ExpressionBaseMixin
-	index: tuple[tuple[int, ...], tuple[int, ...]]
diff --git a/polymatrix/expression/impl/halfnewtonpolytopeexprimpl.py b/polymatrix/expression/impl/halfnewtonpolytopeexprimpl.py
deleted file mode 100644
index 6fef1da..0000000
--- a/polymatrix/expression/impl/halfnewtonpolytopeexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.halfnewtonpolytopeexpr import HalfNewtonPolytopeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class HalfNewtonPolytopeExprImpl(HalfNewtonPolytopeExpr):
-	monomials: ExpressionBaseMixin
-	variables: ExpressionBaseMixin
-	filter: ExpressionBaseMixin | None
diff --git a/polymatrix/expression/impl/impl.py b/polymatrix/expression/impl/impl.py
new file mode 100644
index 0000000..7a919e5
--- /dev/null
+++ b/polymatrix/expression/impl/impl.py
@@ -0,0 +1,320 @@
+import dataclassabc
+
+from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
+from polymatrix.expression.mixins.additionexprmixin import AdditionExprMixin
+from polymatrix.expression.mixins.blockdiagexprmixin import BlockDiagExprMixin
+from polymatrix.expression.mixins.cacheexprmixin import CacheExprMixin
+from polymatrix.expression.mixins.combinationsexprmixin import \
+    CombinationsExprMixin
+from polymatrix.expression.mixins.derivativeexprmixin import \
+    DerivativeExprMixin
+from polymatrix.expression.mixins.determinantexprmixin import \
+    DeterminantExprMixin
+from polymatrix.expression.mixins.diagexprmixin import DiagExprMixin
+from polymatrix.expression.mixins.divergenceexprmixin import \
+    DivergenceExprMixin
+from polymatrix.expression.mixins.divisionexprmixin import DivisionExprMixin
+from polymatrix.expression.mixins.elemmultexprmixin import ElemMultExprMixin
+from polymatrix.expression.mixins.evalexprmixin import EvalExprMixin
+from polymatrix.expression.mixins.eyeexprmixin import EyeExprMixin
+from polymatrix.expression.mixins.filterexprmixin import FilterExprMixin
+from polymatrix.expression.mixins.fromsymmetricmatrixexprmixin import \
+    FromSymmetricMatrixExprMixin
+from polymatrix.expression.mixins.fromsympyexprmixin import FromSympyExprMixin
+from polymatrix.expression.mixins.fromtermsexprmixin import FromTermsExprMixin
+from polymatrix.expression.mixins.getitemexprmixin import GetItemExprMixin
+from polymatrix.expression.mixins.halfnewtonpolytopeexprmixin import \
+    HalfNewtonPolytopeExprMixin
+from polymatrix.expression.mixins.linearinexprmixin import LinearInExprMixin
+from polymatrix.expression.mixins.linearmatrixinexprmixin import \
+    LinearMatrixInExprMixin
+from polymatrix.expression.mixins.linearmonomialsexprmixin import \
+    LinearMonomialsExprMixin
+from polymatrix.expression.mixins.matrixmultexprmixin import \
+    MatrixMultExprMixin
+from polymatrix.expression.mixins.maxdegreeexprmixin import MaxDegreeExprMixin
+from polymatrix.expression.mixins.maxexprmixin import MaxExprMixin
+from polymatrix.expression.mixins.parametrizeexprmixin import \
+    ParametrizeExprMixin
+from polymatrix.expression.mixins.parametrizematrixexprmixin import \
+    ParametrizeMatrixExprMixin
+from polymatrix.expression.mixins.quadraticinexprmixin import \
+    QuadraticInExprMixin
+from polymatrix.expression.mixins.quadraticmonomialsexprmixin import \
+    QuadraticMonomialsExprMixin
+from polymatrix.expression.mixins.repmatexprmixin import RepMatExprMixin
+from polymatrix.expression.mixins.reshapeexprmixin import ReshapeExprMixin
+from polymatrix.expression.mixins.setelementatexprmixin import \
+    SetElementAtExprMixin
+from polymatrix.expression.mixins.squeezeexprmixin import SqueezeExprMixin
+from polymatrix.expression.mixins.substituteexprmixin import \
+    SubstituteExprMixin
+from polymatrix.expression.mixins.subtractmonomialsexprmixin import \
+    SubtractMonomialsExprMixin
+from polymatrix.expression.mixins.sumexprmixin import SumExprMixin
+from polymatrix.expression.mixins.symmetricexprmixin import SymmetricExprMixin
+from polymatrix.expression.mixins.toconstantexprmixin import \
+    ToConstantExprMixin
+from polymatrix.expression.mixins.toquadraticexprmixin import \
+    ToQuadraticExprMixin
+from polymatrix.expression.mixins.tosymmetricmatrixexprmixin import \
+    ToSymmetricMatrixExprMixin
+from polymatrix.expression.mixins.transposeexprmixin import TransposeExprMixin
+from polymatrix.expression.mixins.truncateexprmixin import TruncateExprMixin
+from polymatrix.expression.mixins.vstackexprmixin import VStackExprMixin
+from polymatrix.expression.mixins.tosortedvariablesmixin import ToSortedVariablesExprMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class AdditionExprImpl(AdditionExprMixin):
+	left: ExpressionBaseMixin
+	right: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class BlockDiagExprImpl(BlockDiagExprMixin):
+	underlying: tuple
+
+
+# @dataclassabc.dataclassabc(frozen=True, eq=False)
+@dataclassabc.dataclassabc(frozen=True)
+class CacheExprImpl(CacheExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class CombinationsExprImpl(CombinationsExprMixin):
+	monomials: ExpressionBaseMixin
+	number: int
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class DerivativeExprImpl(DerivativeExprMixin):
+	underlying: ExpressionBaseMixin
+	variables: tuple
+	introduce_derivatives: bool
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class DeterminantExprImpl(DeterminantExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class DiagExprImpl(DiagExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class DivergenceExprImpl(DivergenceExprMixin):
+	underlying: ExpressionBaseMixin
+	variables: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True, eq=False)
+class DivisionExprImpl(DivisionExprMixin):
+	left: ExpressionBaseMixin
+	right: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ElemMultExprImpl(ElemMultExprMixin):
+	left: ExpressionBaseMixin
+	right: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class EvalExprImpl(EvalExprMixin):
+	underlying: ExpressionBaseMixin
+	substitutions: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class EyeExprImpl(EyeExprMixin):
+	variable: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class FilterExprImpl(FilterExprMixin):
+	underlying: ExpressionBaseMixin
+	predicator: ExpressionBaseMixin
+	inverse: bool == None
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class FromSymmetricMatrixExprImpl(FromSymmetricMatrixExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class FromSympyExprImpl(FromSympyExprMixin):
+	data: tuple[tuple[float]]
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class FromTermsExprImpl(FromTermsExprMixin):
+	terms: tuple
+	shape: tuple[int, int]
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class GetItemExprImpl(GetItemExprMixin):
+	underlying: ExpressionBaseMixin
+	index: tuple[tuple[int, ...], tuple[int, ...]]
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class HalfNewtonPolytopeExprImpl(HalfNewtonPolytopeExprMixin):
+	monomials: ExpressionBaseMixin
+	variables: ExpressionBaseMixin
+	filter: ExpressionBaseMixin | None
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class LinearInExprImpl(LinearInExprMixin):
+	underlying: ExpressionBaseMixin
+	monomials: ExpressionBaseMixin
+	variables: ExpressionBaseMixin
+	ignore_unmatched: bool
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class LinearMatrixInExprImpl(LinearMatrixInExprMixin):
+	underlying: ExpressionBaseMixin
+	variable: int
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class LinearMonomialsExprImpl(LinearMonomialsExprMixin):
+	underlying: ExpressionBaseMixin
+	variables: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class MatrixMultExprImpl(MatrixMultExprMixin):
+	left: ExpressionBaseMixin
+	right: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class MaxDegreeExprImpl(MaxDegreeExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class MaxExprImpl(MaxExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+# @dataclassabc.dataclassabc(frozen=True, eq=False, repr=False)
+@dataclassabc.dataclassabc(frozen=True, repr=False)
+class ParametrizeExprImpl(ParametrizeExprMixin):
+	underlying: ExpressionBaseMixin
+	name: str
+
+	def __repr__(self) -> str:
+		return f'{self.__class__.__name__}(name={repr(self.name)})'
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ParametrizeMatrixExprImpl(ParametrizeMatrixExprMixin):
+	underlying: ExpressionBaseMixin
+	name: str
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class QuadraticInExprImpl(QuadraticInExprMixin):
+	underlying: ExpressionBaseMixin
+	monomials: ExpressionBaseMixin
+	variables: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class QuadraticMonomialsExprImpl(QuadraticMonomialsExprMixin):
+	underlying: ExpressionBaseMixin
+	variables: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class RepMatExprImpl(RepMatExprMixin):
+	underlying: ExpressionBaseMixin
+	repetition: tuple
+
+
+# @dataclassabc.dataclassabc(frozen=True)
+# class ReshapeExprImpl(ReshapeExprMixin):
+# 	underlying: ExpressionBaseMixin
+# 	new_shape: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class SetElementAtExprImpl(SetElementAtExprMixin):
+	underlying: ExpressionBaseMixin
+	index: tuple
+	value: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class SqueezeExprImpl(SqueezeExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class SubstituteExprImpl(SubstituteExprMixin):
+	underlying: ExpressionBaseMixin
+	# variables: tuple
+	substitutions: tuple
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class SubtractMonomialsExprImpl(SubtractMonomialsExprMixin):
+	underlying: ExpressionBaseMixin
+	monomials: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class SumExprImpl(SumExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class SymmetricExprImpl(SymmetricExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ToConstantExprImpl(ToConstantExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ToQuadraticExprImpl(ToQuadraticExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ToSortedVariablesImpl(ToSortedVariablesExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ToSymmetricMatrixExprImpl(ToSymmetricMatrixExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class TransposeExprImpl(TransposeExprMixin):
+	underlying: ExpressionBaseMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class TruncateExprImpl(TruncateExprMixin):
+	underlying: ExpressionBaseMixin
+	variables: ExpressionBaseMixin
+	degrees: tuple[int]
+	inverse: bool
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class VStackExprImpl(VStackExprMixin):
+	underlying: tuple
diff --git a/polymatrix/expression/impl/linearinexprimpl.py b/polymatrix/expression/impl/linearinexprimpl.py
deleted file mode 100644
index 346b19b..0000000
--- a/polymatrix/expression/impl/linearinexprimpl.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.linearinexpr import LinearInExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class LinearInExprImpl(LinearInExpr):
-	underlying: ExpressionBaseMixin
-	monomials: ExpressionBaseMixin
-	variables: ExpressionBaseMixin
-	ignore_unmatched: bool
diff --git a/polymatrix/expression/impl/linearmatrixinexprimpl.py b/polymatrix/expression/impl/linearmatrixinexprimpl.py
deleted file mode 100644
index b40e6a6..0000000
--- a/polymatrix/expression/impl/linearmatrixinexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.linearmatrixinexpr import LinearMatrixInExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class LinearMatrixInExprImpl(LinearMatrixInExpr):
-	underlying: ExpressionBaseMixin
-	variable: int
diff --git a/polymatrix/expression/impl/linearmonomialsexprimpl.py b/polymatrix/expression/impl/linearmonomialsexprimpl.py
deleted file mode 100644
index 905ec77..0000000
--- a/polymatrix/expression/impl/linearmonomialsexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.linearmonomialsexpr import LinearMonomialsExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class LinearMonomialsExprImpl(LinearMonomialsExpr):
-	underlying: ExpressionBaseMixin
-	variables: tuple
diff --git a/polymatrix/expression/impl/matrixmultexprimpl.py b/polymatrix/expression/impl/matrixmultexprimpl.py
deleted file mode 100644
index 0b093ab..0000000
--- a/polymatrix/expression/impl/matrixmultexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.matrixmultexpr import MatrixMultExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class MatrixMultExprImpl(MatrixMultExpr):
-	left: ExpressionBaseMixin
-	right: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/maxdegreeexprimpl.py b/polymatrix/expression/impl/maxdegreeexprimpl.py
deleted file mode 100644
index 5327659..0000000
--- a/polymatrix/expression/impl/maxdegreeexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.maxdegreeexpr import MaxDegreeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class MaxDegreeExprImpl(MaxDegreeExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/maxexprimpl.py b/polymatrix/expression/impl/maxexprimpl.py
deleted file mode 100644
index ae2fe90..0000000
--- a/polymatrix/expression/impl/maxexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.maxexpr import MaxExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class MaxExprImpl(MaxExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/parametrizeexprimpl.py b/polymatrix/expression/impl/parametrizeexprimpl.py
deleted file mode 100644
index 4278a68..0000000
--- a/polymatrix/expression/impl/parametrizeexprimpl.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.parametrizeexpr import ParametrizeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-# @dataclass_abc.dataclass_abc(frozen=True, eq=False, repr=False)
-@dataclass_abc.dataclass_abc(frozen=True, repr=False)
-class ParametrizeExprImpl(ParametrizeExpr):
-	underlying: ExpressionBaseMixin
-	name: str
-
-	def __repr__(self) -> str:
-		return f'{self.__class__.__name__}(name={repr(self.name)})'
-
-	# def __eq__(self, other: object) -> bool:
-	# 	return self.name == other.name
-
-	# def __hash__(self) -> bool:
-	# 	return hash(self.name)
diff --git a/polymatrix/expression/impl/quadraticinexprimpl.py b/polymatrix/expression/impl/quadraticinexprimpl.py
deleted file mode 100644
index da8fa21..0000000
--- a/polymatrix/expression/impl/quadraticinexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.quadraticinexpr import QuadraticInExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class QuadraticInExprImpl(QuadraticInExpr):
-	underlying: ExpressionBaseMixin
-	monomials: ExpressionBaseMixin
-	variables: tuple
diff --git a/polymatrix/expression/impl/quadraticmonomialsexprimpl.py b/polymatrix/expression/impl/quadraticmonomialsexprimpl.py
deleted file mode 100644
index 5930764..0000000
--- a/polymatrix/expression/impl/quadraticmonomialsexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.quadraticmonomialsexpr import QuadraticMonomialsExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class QuadraticMonomialsExprImpl(QuadraticMonomialsExpr):
-	underlying: ExpressionBaseMixin
-	variables: tuple
diff --git a/polymatrix/expression/impl/repmatexprimpl.py b/polymatrix/expression/impl/repmatexprimpl.py
deleted file mode 100644
index f8cee79..0000000
--- a/polymatrix/expression/impl/repmatexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.repmatexpr import RepMatExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class RepMatExprImpl(RepMatExpr):
-	underlying: ExpressionBaseMixin
-	repetition: tuple
diff --git a/polymatrix/expression/impl/reshapeexprimpl.py b/polymatrix/expression/impl/reshapeexprimpl.py
deleted file mode 100644
index 7c16f16..0000000
--- a/polymatrix/expression/impl/reshapeexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.reshapeexpr import ReshapeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class ReshapeExprImpl(ReshapeExpr):
-	underlying: ExpressionBaseMixin
-	new_shape: tuple
diff --git a/polymatrix/expression/impl/reshapeexprmixin.py b/polymatrix/expression/impl/reshapeexprmixin.py
new file mode 100644
index 0000000..00a93b8
--- /dev/null
+++ b/polymatrix/expression/impl/reshapeexprmixin.py
@@ -0,0 +1,10 @@
+import dataclassabc
+
+from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
+from polymatrix.expression.mixins.reshapeexprmixin import ReshapeExprMixin
+
+
+@dataclassabc.dataclassabc(frozen=True)
+class ReshapeExprImpl(ReshapeExprMixin):
+	underlying: ExpressionBaseMixin
+	new_shape: tuple
diff --git a/polymatrix/expression/impl/setelementatexprimpl.py b/polymatrix/expression/impl/setelementatexprimpl.py
deleted file mode 100644
index 6d070ac..0000000
--- a/polymatrix/expression/impl/setelementatexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.setelementatexpr import SetElementAtExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class SetElementAtExprImpl(SetElementAtExpr):
-	underlying: ExpressionBaseMixin
-	index: tuple
-	value: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/squeezeexprimpl.py b/polymatrix/expression/impl/squeezeexprimpl.py
deleted file mode 100644
index b60af68..0000000
--- a/polymatrix/expression/impl/squeezeexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.squeezeexpr import SqueezeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class SqueezeExprImpl(SqueezeExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/substituteexprimpl.py b/polymatrix/expression/impl/substituteexprimpl.py
deleted file mode 100644
index 086f17e..0000000
--- a/polymatrix/expression/impl/substituteexprimpl.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.substituteexpr import SubstituteExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class SubstituteExprImpl(SubstituteExpr):
-	underlying: ExpressionBaseMixin
-	# variables: tuple
-	substitutions: tuple
diff --git a/polymatrix/expression/impl/subtractmonomialsexprimpl.py b/polymatrix/expression/impl/subtractmonomialsexprimpl.py
deleted file mode 100644
index 211f7b1..0000000
--- a/polymatrix/expression/impl/subtractmonomialsexprimpl.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.subtractmonomialsexpr import SubtractMonomialsExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class SubtractMonomialsExprImpl(SubtractMonomialsExpr):
-	underlying: ExpressionBaseMixin
-	monomials: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/sumexprimpl.py b/polymatrix/expression/impl/sumexprimpl.py
deleted file mode 100644
index b148b43..0000000
--- a/polymatrix/expression/impl/sumexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.sumexpr import SumExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class SumExprImpl(SumExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/symmetricexprimpl.py b/polymatrix/expression/impl/symmetricexprimpl.py
deleted file mode 100644
index b15b8a0..0000000
--- a/polymatrix/expression/impl/symmetricexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.symmetricexpr import SymmetricExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class SymmetricExprImpl(SymmetricExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/toconstantexprimpl.py b/polymatrix/expression/impl/toconstantexprimpl.py
deleted file mode 100644
index 9e3d13d..0000000
--- a/polymatrix/expression/impl/toconstantexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.toconstantexpr import ToConstantExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class ToConstantExprImpl(ToConstantExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/toquadraticexprimpl.py b/polymatrix/expression/impl/toquadraticexprimpl.py
deleted file mode 100644
index 63a2cdb..0000000
--- a/polymatrix/expression/impl/toquadraticexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.toquadraticexpr import ToQuadraticExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class ToQuadraticExprImpl(ToQuadraticExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/tosortedvariablesimpl.py b/polymatrix/expression/impl/tosortedvariablesimpl.py
deleted file mode 100644
index 249e55e..0000000
--- a/polymatrix/expression/impl/tosortedvariablesimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.tosortedvariables import ToSortedVariables 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class ToSortedVariablesImpl(ToSortedVariables):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/tosymmetricmatrixexprimpl.py b/polymatrix/expression/impl/tosymmetricmatrixexprimpl.py
deleted file mode 100644
index da43157..0000000
--- a/polymatrix/expression/impl/tosymmetricmatrixexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.tosymmetricmatrixexpr import ToSymmetricMatrixExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class ToSymmetricMatrixExprImpl(ToSymmetricMatrixExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/transposeexprimpl.py b/polymatrix/expression/impl/transposeexprimpl.py
deleted file mode 100644
index 59b1a53..0000000
--- a/polymatrix/expression/impl/transposeexprimpl.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.transposeexpr import TransposeExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class TransposeExprImpl(TransposeExpr):
-	underlying: ExpressionBaseMixin
diff --git a/polymatrix/expression/impl/truncateexprimpl.py b/polymatrix/expression/impl/truncateexprimpl.py
deleted file mode 100644
index 5bd45f3..0000000
--- a/polymatrix/expression/impl/truncateexprimpl.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.truncateexpr import TruncateExpr 
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin 
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class TruncateExprImpl(TruncateExpr):
-	underlying: ExpressionBaseMixin
-	variables: ExpressionBaseMixin
-	degrees: tuple[int]
-	inverse: bool
diff --git a/polymatrix/expression/impl/vstackexprimpl.py b/polymatrix/expression/impl/vstackexprimpl.py
deleted file mode 100644
index 9ee582d..0000000
--- a/polymatrix/expression/impl/vstackexprimpl.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import dataclass_abc
-from polymatrix.expression.vstackexpr import VStackExpr 
-
-
-@dataclass_abc.dataclass_abc(frozen=True)
-class VStackExprImpl(VStackExpr):
-	underlying: tuple
diff --git a/polymatrix/expression/init/initadditionexpr.py b/polymatrix/expression/init/initadditionexpr.py
index e5b31c8..cdc97b1 100644
--- a/polymatrix/expression/init/initadditionexpr.py
+++ b/polymatrix/expression/init/initadditionexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.additionexprimpl import AdditionExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_addition_expr(
 		left: ExpressionBaseMixin,
 		right: ExpressionBaseMixin,
 ):
-	return AdditionExprImpl(
+	return polymatrix.expression.impl.impl.AdditionExprImpl(
 		left=left,
 		right=right,
 )
diff --git a/polymatrix/expression/init/initblockdiagexpr.py b/polymatrix/expression/init/initblockdiagexpr.py
index 930385f..a9ad8a6 100644
--- a/polymatrix/expression/init/initblockdiagexpr.py
+++ b/polymatrix/expression/init/initblockdiagexpr.py
@@ -1,9 +1,7 @@
-from polymatrix.expression.impl.blockdiagexprimpl import BlockDiagExprImpl
-
-
+import polymatrix.expression.impl.impl
 def init_block_diag_expr(
 		underlying: tuple,
 ):
-	return BlockDiagExprImpl(
+	return polymatrix.expression.impl.impl.BlockDiagExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initcacheexpr.py b/polymatrix/expression/init/initcacheexpr.py
index 977e033..861ffa1 100644
--- a/polymatrix/expression/init/initcacheexpr.py
+++ b/polymatrix/expression/init/initcacheexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.cacheexprimpl import CacheExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_cache_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return CacheExprImpl(
+	return polymatrix.expression.impl.impl.CacheExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initcombinationsexpr.py b/polymatrix/expression/init/initcombinationsexpr.py
index 80bf4d0..10931e6 100644
--- a/polymatrix/expression/init/initcombinationsexpr.py
+++ b/polymatrix/expression/init/initcombinationsexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.combinationsexprimpl import CombinationsExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_combinations_expr(
 		monomials: ExpressionBaseMixin,
 		number: int,
 ):
-	return CombinationsExprImpl(
+	return polymatrix.expression.impl.impl.CombinationsExprImpl(
 		monomials=monomials,
 		number=number,
 )
diff --git a/polymatrix/expression/init/initderivativeexpr.py b/polymatrix/expression/init/initderivativeexpr.py
index a6ca06c..b1c9405 100644
--- a/polymatrix/expression/init/initderivativeexpr.py
+++ b/polymatrix/expression/init/initderivativeexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.derivativeexprimpl import DerivativeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_derivative_expr(
@@ -13,7 +13,7 @@ def init_derivative_expr(
 	if introduce_derivatives is None:
 		introduce_derivatives = False
 
-	return DerivativeExprImpl(
+	return polymatrix.expression.impl.impl.DerivativeExprImpl(
 		underlying=underlying,
 		variables=variables,
 		introduce_derivatives=introduce_derivatives,
diff --git a/polymatrix/expression/init/initdeterminantexpr.py b/polymatrix/expression/init/initdeterminantexpr.py
index f0d1bb5..660f3ae 100644
--- a/polymatrix/expression/init/initdeterminantexpr.py
+++ b/polymatrix/expression/init/initdeterminantexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.determinantexprimpl import DeterminantExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_determinant_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return DeterminantExprImpl(
+	return polymatrix.expression.impl.impl.DeterminantExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initdiagexpr.py b/polymatrix/expression/init/initdiagexpr.py
index db9b6d4..794c5bf 100644
--- a/polymatrix/expression/init/initdiagexpr.py
+++ b/polymatrix/expression/init/initdiagexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.diagexprimpl import DiagExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_diag_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return DiagExprImpl(
+	return polymatrix.expression.impl.impl.DiagExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initdivergenceexpr.py b/polymatrix/expression/init/initdivergenceexpr.py
index d1aa02c..6f5d99d 100644
--- a/polymatrix/expression/init/initdivergenceexpr.py
+++ b/polymatrix/expression/init/initdivergenceexpr.py
@@ -1,13 +1,13 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
 from typing import Union
-from polymatrix.expression.impl.divergenceexprimpl import DivergenceExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_divergence_expr(
 		underlying: ExpressionBaseMixin,
 		variables: tuple,
 ):
-	return DivergenceExprImpl(
+	return polymatrix.expression.impl.impl.DivergenceExprImpl(
 		underlying=underlying,
 		variables=variables,
 )
diff --git a/polymatrix/expression/init/initdivisionexpr.py b/polymatrix/expression/init/initdivisionexpr.py
index 2a701a9..d7870bc 100644
--- a/polymatrix/expression/init/initdivisionexpr.py
+++ b/polymatrix/expression/init/initdivisionexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.divisionexprimpl import DivisionExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_division_expr(
 		left: ExpressionBaseMixin,
 		right: ExpressionBaseMixin,
 ):
-	return DivisionExprImpl(
+	return polymatrix.expression.impl.impl.DivisionExprImpl(
 		left=left,
 		right=right,
 )
diff --git a/polymatrix/expression/init/initelemmultexpr.py b/polymatrix/expression/init/initelemmultexpr.py
index ae0e85f..ef66c68 100644
--- a/polymatrix/expression/init/initelemmultexpr.py
+++ b/polymatrix/expression/init/initelemmultexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.elemmultexprimpl import ElemMultExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_elem_mult_expr(
 		left: ExpressionBaseMixin,
 		right: ExpressionBaseMixin,
 ):
-	return ElemMultExprImpl(
+	return polymatrix.expression.impl.impl.ElemMultExprImpl(
 		left=left,
 		right=right,
 )
diff --git a/polymatrix/expression/init/initevalexpr.py b/polymatrix/expression/init/initevalexpr.py
index 0fad8e5..c59a8d5 100644
--- a/polymatrix/expression/init/initevalexpr.py
+++ b/polymatrix/expression/init/initevalexpr.py
@@ -2,7 +2,7 @@ import typing
 import numpy as np
 from polymatrix.expression.init.initsubstituteexpr import format_substitutions
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.evalexprimpl import EvalExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_eval_expr(
@@ -31,7 +31,7 @@ def init_eval_expr(
 
 	substitutions = tuple((variable, formatted_values(value)) for variable, value in substitutions)
 
-	return EvalExprImpl(
+	return polymatrix.expression.impl.impl.EvalExprImpl(
 		underlying=underlying,
 		substitutions=substitutions,
 	)
diff --git a/polymatrix/expression/init/initexpression.py b/polymatrix/expression/init/initexpression.py
index 7262e47..3c3258c 100644
--- a/polymatrix/expression/init/initexpression.py
+++ b/polymatrix/expression/init/initexpression.py
@@ -1,5 +1,5 @@
+from polymatrix.expression.expression import ExpressionImpl
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.expressionimpl import ExpressionImpl
 
 
 def init_expression(
diff --git a/polymatrix/expression/init/initeyeexpr.py b/polymatrix/expression/init/initeyeexpr.py
index e691b03..642e4c6 100644
--- a/polymatrix/expression/init/initeyeexpr.py
+++ b/polymatrix/expression/init/initeyeexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.eyeexprimpl import EyeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_eye_expr(
 		variable: ExpressionBaseMixin,
 ):
-	return EyeExprImpl(
+	return polymatrix.expression.impl.impl.EyeExprImpl(
 		variable=variable,
 )
diff --git a/polymatrix/expression/init/initfilterexpr.py b/polymatrix/expression/init/initfilterexpr.py
index c47036f..7164183 100644
--- a/polymatrix/expression/init/initfilterexpr.py
+++ b/polymatrix/expression/init/initfilterexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.filterexprimpl import FilterExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_filter_expr(
@@ -10,7 +10,7 @@ def init_filter_expr(
 	if inverse is None:
 		inverse = False
 
-	return FilterExprImpl(
+	return polymatrix.expression.impl.impl.FilterExprImpl(
 		underlying=underlying,
 		predicator=predicator,
 		inverse=inverse,
diff --git a/polymatrix/expression/init/initfromsymmetricmatrixexpr.py b/polymatrix/expression/init/initfromsymmetricmatrixexpr.py
index 3af7dc3..b3ef782 100644
--- a/polymatrix/expression/init/initfromsymmetricmatrixexpr.py
+++ b/polymatrix/expression/init/initfromsymmetricmatrixexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.fromsymmetricmatrixexprimpl import FromSymmetricMatrixExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_from_symmetric_matrix_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return FromSymmetricMatrixExprImpl(
+	return polymatrix.expression.impl.impl.FromSymmetricMatrixExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initfromsympyexpr.py b/polymatrix/expression/init/initfromsympyexpr.py
index 2ab6ded..4ca6fcf 100644
--- a/polymatrix/expression/init/initfromsympyexpr.py
+++ b/polymatrix/expression/init/initfromsympyexpr.py
@@ -2,14 +2,13 @@ import typing
 import numpy as np
 import sympy
 
-from polymatrix.expression.impl.fromsympyexprimpl import FromSympyExprImpl
+from polymatrix.expression.impl.impl import FromSympyExprImpl
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
 
 
-def init_from_sympy_expr(
-		data: typing.Union[np.ndarray, tuple[tuple[float]]],
-):
-
+def init_from_expr_or_none(
+	data: typing.Union[np.ndarray, tuple[tuple[float]]],
+) -> ExpressionBaseMixin | None:
 	match data:
 		case np.ndarray():
 			assert len(data.shape) <= 2
@@ -37,21 +36,33 @@ def init_from_sympy_expr(
 				case _:
 					data = tuple((e,) for e in data)
 
-		case np.number:
-			data = ((float(data),),)
+		case sympy.Expr():
+			data = ((sympy.expand(data),),)
 
 		case ExpressionBaseMixin():
 			return data
 
-		case sympy.Expr():
-			data = ((sympy.expand(data),),)
-
 		case _:
-			if not isinstance(data, (float, int)):
-				raise Exception(f'{data=}, {type(data)=}')
+			if not isinstance(data, (float, int, np.number)):
+			# 	raise Exception(f'{data=}, {type(data)=}')
+				return None
 
 			data = ((data,),)
 
 	return FromSympyExprImpl(
-		data=data,
+			data=data,
 	)
+
+
+def init_from_sympy_expr(
+		data: typing.Union[np.ndarray, tuple[tuple[float]]],
+):
+	# if isinstance(data, ExpressionBaseMixin):
+	# 	return data
+
+	expr = init_from_expr_or_none(data)
+
+	if expr is None:
+		raise Exception(f'{data=}')
+
+	return expr
diff --git a/polymatrix/expression/init/initfromtermsexpr.py b/polymatrix/expression/init/initfromtermsexpr.py
index c2080c6..b2c1dc3 100644
--- a/polymatrix/expression/init/initfromtermsexpr.py
+++ b/polymatrix/expression/init/initfromtermsexpr.py
@@ -1,6 +1,6 @@
 import typing
-from polymatrix.expression.impl.fromtermsexprimpl import FromTermsExprImpl
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
+import polymatrix.expression.impl.impl
 
 
 def init_from_terms_expr(
@@ -27,7 +27,7 @@ def init_from_terms_expr(
 	# Expression needs to be hashable
 	terms_formatted = tuple((key, tuple(monomials.items())) for key, monomials in gen_terms)
 
-	return FromTermsExprImpl(
+	return polymatrix.expression.impl.impl.FromTermsExprImpl(
 		terms=terms_formatted,
 		shape=shape,
 	)
diff --git a/polymatrix/expression/init/initgetitemexpr.py b/polymatrix/expression/init/initgetitemexpr.py
index 5fea7a5..f7fc0c9 100644
--- a/polymatrix/expression/init/initgetitemexpr.py
+++ b/polymatrix/expression/init/initgetitemexpr.py
@@ -1,6 +1,6 @@
 from numpy import isin
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.getitemexprimpl import GetItemExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_get_item_expr(
@@ -10,13 +10,13 @@ def init_get_item_expr(
 
 	def get_hashable_slice(index):
 		if isinstance(index, slice):
-			return GetItemExprImpl.Slice(start=index.start, stop=index.stop, step=index.step)
+			return polymatrix.expression.impl.impl.GetItemExprImpl.Slice(start=index.start, stop=index.stop, step=index.step)
 		else:
 			return index
 
 	proper_index = (get_hashable_slice(index[0]), get_hashable_slice(index[1]))
 
-	return GetItemExprImpl(
+	return polymatrix.expression.impl.impl.GetItemExprImpl(
 		underlying=underlying,
 		index=proper_index,
 )
diff --git a/polymatrix/expression/init/inithalfnewtonpolytopeexpr.py b/polymatrix/expression/init/inithalfnewtonpolytopeexpr.py
index e4ab6a2..794c938 100644
--- a/polymatrix/expression/init/inithalfnewtonpolytopeexpr.py
+++ b/polymatrix/expression/init/inithalfnewtonpolytopeexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.halfnewtonpolytopeexprimpl import HalfNewtonPolytopeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_half_newton_polytope_expr(
@@ -7,7 +7,7 @@ def init_half_newton_polytope_expr(
 		variables: ExpressionBaseMixin,
 		filter: ExpressionBaseMixin | None = None,
 ):
-	return HalfNewtonPolytopeExprImpl(
+	return polymatrix.expression.impl.impl.HalfNewtonPolytopeExprImpl(
 		monomials=monomials,
 		variables=variables,
 		filter=filter
diff --git a/polymatrix/expression/init/initlinearinexpr.py b/polymatrix/expression/init/initlinearinexpr.py
index b869aee..30705e2 100644
--- a/polymatrix/expression/init/initlinearinexpr.py
+++ b/polymatrix/expression/init/initlinearinexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.linearinexprimpl import LinearInExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_linear_in_expr(
@@ -10,7 +10,7 @@ def init_linear_in_expr(
 ):
 	assert isinstance(variables, ExpressionBaseMixin), f'{variables=}'
 
-	return LinearInExprImpl(
+	return polymatrix.expression.impl.impl.LinearInExprImpl(
 		underlying=underlying,
 		monomials=monomials,
 		variables=variables,
diff --git a/polymatrix/expression/init/initlinearmatrixinexpr.py b/polymatrix/expression/init/initlinearmatrixinexpr.py
index cd4ce97..83e9aea 100644
--- a/polymatrix/expression/init/initlinearmatrixinexpr.py
+++ b/polymatrix/expression/init/initlinearmatrixinexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.linearmatrixinexprimpl import LinearMatrixInExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_linear_matrix_in_expr(
 		underlying: ExpressionBaseMixin,
 		variable: int,
 ):
-	return LinearMatrixInExprImpl(
+	return polymatrix.expression.impl.impl.LinearMatrixInExprImpl(
 		underlying=underlying,
 		variable=variable,
 )
diff --git a/polymatrix/expression/init/initlinearmonomialsexpr.py b/polymatrix/expression/init/initlinearmonomialsexpr.py
index 8083715..f830542 100644
--- a/polymatrix/expression/init/initlinearmonomialsexpr.py
+++ b/polymatrix/expression/init/initlinearmonomialsexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.linearmonomialsexprimpl import LinearMonomialsExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_linear_monomials_expr(
@@ -9,7 +9,7 @@ def init_linear_monomials_expr(
 
 	assert isinstance(variables, ExpressionBaseMixin), f'{variables=}'
 
-	return LinearMonomialsExprImpl(
+	return polymatrix.expression.impl.impl.LinearMonomialsExprImpl(
 		underlying=underlying,
 		variables=variables,
 	)
diff --git a/polymatrix/expression/init/initmatrixmultexpr.py b/polymatrix/expression/init/initmatrixmultexpr.py
index 9081368..20bffec 100644
--- a/polymatrix/expression/init/initmatrixmultexpr.py
+++ b/polymatrix/expression/init/initmatrixmultexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.matrixmultexprimpl import MatrixMultExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_matrix_mult_expr(
 		left: ExpressionBaseMixin,
 		right: ExpressionBaseMixin,
 ):
-	return MatrixMultExprImpl(
+	return polymatrix.expression.impl.impl.MatrixMultExprImpl(
 		left=left,
 		right=right,
 )
diff --git a/polymatrix/expression/init/initmaxdegreeexpr.py b/polymatrix/expression/init/initmaxdegreeexpr.py
index 60fc40a..d232163 100644
--- a/polymatrix/expression/init/initmaxdegreeexpr.py
+++ b/polymatrix/expression/init/initmaxdegreeexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.maxdegreeexprimpl import MaxDegreeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_max_degree_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return MaxDegreeExprImpl(
+	return polymatrix.expression.impl.impl.MaxDegreeExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initmaxexpr.py b/polymatrix/expression/init/initmaxexpr.py
index b0b1e4d..41dde90 100644
--- a/polymatrix/expression/init/initmaxexpr.py
+++ b/polymatrix/expression/init/initmaxexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.maxexprimpl import MaxExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_max_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return MaxExprImpl(
+	return polymatrix.expression.impl.impl.MaxExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initparametrizeexpr.py b/polymatrix/expression/init/initparametrizeexpr.py
index c5b77a3..178d963 100644
--- a/polymatrix/expression/init/initparametrizeexpr.py
+++ b/polymatrix/expression/init/initparametrizeexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.parametrizeexprimpl import ParametrizeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_parametrize_expr(
@@ -9,7 +9,7 @@ def init_parametrize_expr(
 	if name is None:
 		name = 'undefined'
 
-	return ParametrizeExprImpl(
+	return polymatrix.expression.impl.impl.ParametrizeExprImpl(
 		underlying=underlying,
 		name=name,
 )
diff --git a/polymatrix/expression/init/initparametrizematrixexpr.py b/polymatrix/expression/init/initparametrizematrixexpr.py
new file mode 100644
index 0000000..bf90510
--- /dev/null
+++ b/polymatrix/expression/init/initparametrizematrixexpr.py
@@ -0,0 +1,12 @@
+from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
+import polymatrix.expression.impl.impl
+
+
+def init_parametrize_matrix_expr(
+		underlying: ExpressionBaseMixin,
+		name: str,
+):
+	return polymatrix.expression.impl.impl.ParametrizeMatrixExprImpl(
+		underlying=underlying,
+		name=name,
+)
diff --git a/polymatrix/expression/init/initquadraticinexpr.py b/polymatrix/expression/init/initquadraticinexpr.py
index 6555b4b..9569cd3 100644
--- a/polymatrix/expression/init/initquadraticinexpr.py
+++ b/polymatrix/expression/init/initquadraticinexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.quadraticinexprimpl import QuadraticInExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_quadratic_in_expr(
@@ -10,7 +10,7 @@ def init_quadratic_in_expr(
 
 	assert isinstance(variables, ExpressionBaseMixin), f'{variables=}'
 
-	return QuadraticInExprImpl(
+	return polymatrix.expression.impl.impl.QuadraticInExprImpl(
 		underlying=underlying,
 		monomials=monomials,
 		variables=variables,
diff --git a/polymatrix/expression/init/initquadraticmonomialsexpr.py b/polymatrix/expression/init/initquadraticmonomialsexpr.py
index 190f7df..c965312 100644
--- a/polymatrix/expression/init/initquadraticmonomialsexpr.py
+++ b/polymatrix/expression/init/initquadraticmonomialsexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.quadraticmonomialsexprimpl import QuadraticMonomialsExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_quadratic_monomials_expr(
@@ -9,7 +9,7 @@ def init_quadratic_monomials_expr(
 
 	assert isinstance(variables, ExpressionBaseMixin), f'{variables=}'
 
-	return QuadraticMonomialsExprImpl(
+	return polymatrix.expression.impl.impl.QuadraticMonomialsExprImpl(
 		underlying=underlying,
 		variables=variables,
 	)
diff --git a/polymatrix/expression/init/initrepmatexpr.py b/polymatrix/expression/init/initrepmatexpr.py
index 2f7fb7c..152fff8 100644
--- a/polymatrix/expression/init/initrepmatexpr.py
+++ b/polymatrix/expression/init/initrepmatexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.repmatexprimpl import RepMatExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_rep_mat_expr(
 		underlying: ExpressionBaseMixin,
 		repetition: tuple,
 ):
-	return RepMatExprImpl(
+	return polymatrix.expression.impl.impl.RepMatExprImpl(
 		underlying=underlying,
 		repetition=repetition,
 )
diff --git a/polymatrix/expression/init/initreshapeexpr.py b/polymatrix/expression/init/initreshapeexpr.py
index f95fb00..4e6ab57 100644
--- a/polymatrix/expression/init/initreshapeexpr.py
+++ b/polymatrix/expression/init/initreshapeexpr.py
@@ -1,5 +1,5 @@
+from polymatrix.expression.impl.reshapeexprmixin import ReshapeExprImpl
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.reshapeexprimpl import ReshapeExprImpl
 
 
 def init_reshape_expr(
diff --git a/polymatrix/expression/init/initsetelementatexpr.py b/polymatrix/expression/init/initsetelementatexpr.py
index 86df5aa..250c35b 100644
--- a/polymatrix/expression/init/initsetelementatexpr.py
+++ b/polymatrix/expression/init/initsetelementatexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.setelementatexprimpl import SetElementAtExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_set_element_at_expr(
@@ -7,7 +7,7 @@ def init_set_element_at_expr(
 		index: tuple,
 		value: ExpressionBaseMixin,
 ):
-	return SetElementAtExprImpl(
+	return polymatrix.expression.impl.impl.SetElementAtExprImpl(
 		underlying=underlying,
 		index=index,
 		value=value,
diff --git a/polymatrix/expression/init/initsqueezeexpr.py b/polymatrix/expression/init/initsqueezeexpr.py
index d71a9b5..d539453 100644
--- a/polymatrix/expression/init/initsqueezeexpr.py
+++ b/polymatrix/expression/init/initsqueezeexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.squeezeexprimpl import SqueezeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_squeeze_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return SqueezeExprImpl(
+	return polymatrix.expression.impl.impl.SqueezeExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initsubstituteexpr.py b/polymatrix/expression/init/initsubstituteexpr.py
index 50cbee0..15a6566 100644
--- a/polymatrix/expression/init/initsubstituteexpr.py
+++ b/polymatrix/expression/init/initsubstituteexpr.py
@@ -3,12 +3,12 @@ import numpy as np
 
 from polymatrix.expression.init.initfromsympyexpr import init_from_sympy_expr
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.substituteexprimpl import SubstituteExprImpl
+import polymatrix.expression.impl.impl
 
 
 def format_substitutions(
 	variables: typing.Union[typing.Any, tuple, dict],
-	values: typing.Union[float, tuple] = None,
+	values: float | tuple = None,
 ):
 	"""
 	(variables = x, values = 1.0)							# ok
@@ -63,12 +63,13 @@ def init_substitute_expr(
 	def formatted_values(value) -> ExpressionBaseMixin:
 		if isinstance(value, ExpressionBaseMixin):
 			return value
+		
 		else:
 			return init_from_sympy_expr(value)
 
 	substitutions = tuple((variable, formatted_values(value)) for variable, value in substitutions)
 
-	return SubstituteExprImpl(
+	return polymatrix.expression.impl.impl.SubstituteExprImpl(
 		underlying=underlying,
 		substitutions=substitutions,
 	)
diff --git a/polymatrix/expression/init/initsubtractmonomialsexpr.py b/polymatrix/expression/init/initsubtractmonomialsexpr.py
index 131401b..de720bd 100644
--- a/polymatrix/expression/init/initsubtractmonomialsexpr.py
+++ b/polymatrix/expression/init/initsubtractmonomialsexpr.py
@@ -1,12 +1,12 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.subtractmonomialsexprimpl import SubtractMonomialsExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_subtract_monomials_expr(
 		underlying: ExpressionBaseMixin,
 		monomials: ExpressionBaseMixin,
 ):
-	return SubtractMonomialsExprImpl(
+	return polymatrix.expression.impl.impl.SubtractMonomialsExprImpl(
 		underlying=underlying,
 		monomials=monomials,
 )
diff --git a/polymatrix/expression/init/initsumexpr.py b/polymatrix/expression/init/initsumexpr.py
index 606d86b..288ae72 100644
--- a/polymatrix/expression/init/initsumexpr.py
+++ b/polymatrix/expression/init/initsumexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.sumexprimpl import SumExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_sum_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return SumExprImpl(
+	return polymatrix.expression.impl.impl.SumExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/initsymmetricexpr.py b/polymatrix/expression/init/initsymmetricexpr.py
index 87be3ed..dc321e5 100644
--- a/polymatrix/expression/init/initsymmetricexpr.py
+++ b/polymatrix/expression/init/initsymmetricexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.symmetricexprimpl import SymmetricExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_symmetric_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return SymmetricExprImpl(
+	return polymatrix.expression.impl.impl.SymmetricExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/inittoconstantexpr.py b/polymatrix/expression/init/inittoconstantexpr.py
index ead35f8..a0084a1 100644
--- a/polymatrix/expression/init/inittoconstantexpr.py
+++ b/polymatrix/expression/init/inittoconstantexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.toconstantexprimpl import ToConstantExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_to_constant_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return ToConstantExprImpl(
+	return polymatrix.expression.impl.impl.ToConstantExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/inittoquadraticexpr.py b/polymatrix/expression/init/inittoquadraticexpr.py
index dfc0567..77e6943 100644
--- a/polymatrix/expression/init/inittoquadraticexpr.py
+++ b/polymatrix/expression/init/inittoquadraticexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.toquadraticexprimpl import ToQuadraticExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_to_quadratic_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return ToQuadraticExprImpl(
+	return polymatrix.expression.impl.impl.ToQuadraticExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/inittosortedvariables.py b/polymatrix/expression/init/inittosortedvariables.py
index 5d669c9..3f5222a 100644
--- a/polymatrix/expression/init/inittosortedvariables.py
+++ b/polymatrix/expression/init/inittosortedvariables.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.tosortedvariablesimpl import ToSortedVariablesImpl
+import polymatrix.expression.impl.impl
 
 
 def init_to_sorted_variables(
 		underlying: ExpressionBaseMixin,
 ):
-	return ToSortedVariablesImpl(
+	return polymatrix.expression.impl.impl.ToSortedVariablesImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/inittosymmetricmatrixexpr.py b/polymatrix/expression/init/inittosymmetricmatrixexpr.py
index 89fc46c..68b27fe 100644
--- a/polymatrix/expression/init/inittosymmetricmatrixexpr.py
+++ b/polymatrix/expression/init/inittosymmetricmatrixexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.tosymmetricmatrixexprimpl import ToSymmetricMatrixExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_to_symmetric_matrix_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return ToSymmetricMatrixExprImpl(
+	return polymatrix.expression.impl.impl.ToSymmetricMatrixExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/inittransposeexpr.py b/polymatrix/expression/init/inittransposeexpr.py
index 9ca9d91..7807e4d 100644
--- a/polymatrix/expression/init/inittransposeexpr.py
+++ b/polymatrix/expression/init/inittransposeexpr.py
@@ -1,10 +1,10 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.transposeexprimpl import TransposeExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_transpose_expr(
 		underlying: ExpressionBaseMixin,
 ):
-	return TransposeExprImpl(
+	return polymatrix.expression.impl.impl.TransposeExprImpl(
 		underlying=underlying,
 )
diff --git a/polymatrix/expression/init/inittruncateexpr.py b/polymatrix/expression/init/inittruncateexpr.py
index 4582bcb..d36db03 100644
--- a/polymatrix/expression/init/inittruncateexpr.py
+++ b/polymatrix/expression/init/inittruncateexpr.py
@@ -1,5 +1,5 @@
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.expression.impl.truncateexprimpl import TruncateExprImpl
+import polymatrix.expression.impl.impl
 
 
 def init_truncate_expr(
@@ -14,7 +14,7 @@ def init_truncate_expr(
 	if inverse is None:
 		inverse = False
 
-	return TruncateExprImpl(
+	return polymatrix.expression.impl.impl.TruncateExprImpl(
 		underlying=underlying,
 		variables=variables,
 		degrees=degrees,
diff --git a/polymatrix/expression/init/initvstackexpr.py b/polymatrix/expression/init/initvstackexpr.py
index 1edc716..3d47979 100644
--- a/polymatrix/expression/init/initvstackexpr.py
+++ b/polymatrix/expression/init/initvstackexpr.py
@@ -1,6 +1,6 @@
-from polymatrix.expression.impl.vstackexprimpl import VStackExprImpl
 from polymatrix.expression.init.initfromsympyexpr import init_from_sympy_expr
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
+import polymatrix.expression.impl.impl
 
 
 def init_v_stack_expr(
@@ -15,6 +15,6 @@ def init_v_stack_expr(
 			else:
 				yield init_from_sympy_expr(e)
 
-	return VStackExprImpl(
+	return polymatrix.expression.impl.impl.VStackExprImpl(
 		underlying=tuple(gen_underlying()),
 )
diff --git a/polymatrix/expression/linearinexpr.py b/polymatrix/expression/linearinexpr.py
deleted file mode 100644
index 4edf8b3..0000000
--- a/polymatrix/expression/linearinexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.linearinexprmixin import LinearInExprMixin 
-
-class LinearInExpr(LinearInExprMixin):
-	pass
diff --git a/polymatrix/expression/linearmatrixinexpr.py b/polymatrix/expression/linearmatrixinexpr.py
deleted file mode 100644
index 2bce2e7..0000000
--- a/polymatrix/expression/linearmatrixinexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.linearmatrixinexprmixin import LinearMatrixInExprMixin 
-
-class LinearMatrixInExpr(LinearMatrixInExprMixin):
-	pass
diff --git a/polymatrix/expression/linearmonomialsexpr.py b/polymatrix/expression/linearmonomialsexpr.py
deleted file mode 100644
index 9ff6337..0000000
--- a/polymatrix/expression/linearmonomialsexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.linearmonomialsexprmixin import LinearMonomialsExprMixin 
-
-class LinearMonomialsExpr(LinearMonomialsExprMixin):
-	pass
diff --git a/polymatrix/expression/matrixmultexpr.py b/polymatrix/expression/matrixmultexpr.py
deleted file mode 100644
index 62f0cf3..0000000
--- a/polymatrix/expression/matrixmultexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.matrixmultexprmixin import MatrixMultExprMixin 
-
-class MatrixMultExpr(MatrixMultExprMixin):
-	pass
diff --git a/polymatrix/expression/maxdegreeexpr.py b/polymatrix/expression/maxdegreeexpr.py
deleted file mode 100644
index ec8ad47..0000000
--- a/polymatrix/expression/maxdegreeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.maxdegreeexprmixin import MaxDegreeExprMixin 
-
-class MaxDegreeExpr(MaxDegreeExprMixin):
-	pass
diff --git a/polymatrix/expression/maxexpr.py b/polymatrix/expression/maxexpr.py
deleted file mode 100644
index dc0996c..0000000
--- a/polymatrix/expression/maxexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.maxexprmixin import MaxExprMixin 
-
-class MaxExpr(MaxExprMixin):
-	pass
diff --git a/polymatrix/expression/mixins/additionexprmixin.py b/polymatrix/expression/mixins/additionexprmixin.py
index 20ff5d0..e247ebd 100644
--- a/polymatrix/expression/mixins/additionexprmixin.py
+++ b/polymatrix/expression/mixins/additionexprmixin.py
@@ -1,9 +1,7 @@
-
 import abc
-import collections
 import math
 import typing
-import dataclass_abc
+import dataclassabc
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -36,7 +34,7 @@ class AdditionExprMixin(ExpressionBaseMixin):
 
         if left.shape != (1, 1) and right.shape == (1, 1):
 
-            @dataclass_abc.dataclass_abc(frozen=True)
+            @dataclassabc.dataclassabc(frozen=True)
             class BroadCastedPolyMatrix(PolyMatrixMixin):
                 underlying_monomials: tuple[tuple[int], float]
                 shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/assertdegreeexprmixin.py b/polymatrix/expression/mixins/assertdegreeexprmixin.py
index a41e6ba..e57de1c 100644
--- a/polymatrix/expression/mixins/assertdegreeexprmixin.py
+++ b/polymatrix/expression/mixins/assertdegreeexprmixin.py
@@ -1,7 +1,7 @@
 
 import abc
 import itertools
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -28,7 +28,7 @@ class AssertDegreeExprMixin(ExpressionBaseMixin):
     
         state, underlying = self.underlying.apply(state)
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class AssertDegreePolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
             degrees: tuple[int, ...]
diff --git a/polymatrix/expression/mixins/blockdiagexprmixin.py b/polymatrix/expression/mixins/blockdiagexprmixin.py
index eff8de8..b210d27 100644
--- a/polymatrix/expression/mixins/blockdiagexprmixin.py
+++ b/polymatrix/expression/mixins/blockdiagexprmixin.py
@@ -1,7 +1,7 @@
 
 import abc
 import itertools
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -28,7 +28,7 @@ class BlockDiagExprMixin(ExpressionBaseMixin):
 
         # assert all(underlying.shape[0] == underlying.shape[1] for underlying in all_underlying)
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class BlockDiagPolyMatrix(PolyMatrixMixin):
             all_underlying: tuple[PolyMatrixMixin]
             underlying_row_col_range: tuple[tuple[int, int], ...]
diff --git a/polymatrix/expression/mixins/diagexprmixin.py b/polymatrix/expression/mixins/diagexprmixin.py
index 7eded9e..26c75d0 100644
--- a/polymatrix/expression/mixins/diagexprmixin.py
+++ b/polymatrix/expression/mixins/diagexprmixin.py
@@ -1,5 +1,5 @@
 import abc
-import dataclass_abc
+import dataclassabc
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
 from polymatrix.expressionstate.mixins.expressionstatemixin import ExpressionStateMixin
@@ -20,7 +20,7 @@ class DiagExprMixin(ExpressionBaseMixin):
         state, underlying = self.underlying.apply(state)
 
         if underlying.shape[1] == 1:
-            @dataclass_abc.dataclass_abc(frozen=True)
+            @dataclassabc.dataclassabc(frozen=True)
             class DiagPolyMatrix(PolyMatrixMixin):
                 underlying: PolyMatrixMixin
                 shape: tuple[int, int]
@@ -39,7 +39,7 @@ class DiagExprMixin(ExpressionBaseMixin):
         else:
             assert underlying.shape[0] == underlying.shape[1], f'{underlying.shape=}'
 
-            @dataclass_abc.dataclass_abc(frozen=True)
+            @dataclassabc.dataclassabc(frozen=True)
             class TracePolyMatrix(PolyMatrixMixin):
                 underlying: PolyMatrixMixin
                 shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/elemmultexprmixin.py b/polymatrix/expression/mixins/elemmultexprmixin.py
index ab1f265..2edf9e6 100644
--- a/polymatrix/expression/mixins/elemmultexprmixin.py
+++ b/polymatrix/expression/mixins/elemmultexprmixin.py
@@ -2,7 +2,7 @@
 import abc
 import itertools
 import typing
-import dataclass_abc
+import dataclassabc
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -42,7 +42,7 @@ class ElemMultExprMixin(ExpressionBaseMixin):
         if right.shape == (1, 1):
             right_poly = right.get_poly(0, 0)
 
-            @dataclass_abc.dataclass_abc(frozen=True)
+            @dataclassabc.dataclassabc(frozen=True)
             class BroadCastedPolyMatrix(PolyMatrixMixin):
                 underlying: tuple[tuple[int], float]
                 shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/evalexprmixin.py b/polymatrix/expression/mixins/evalexprmixin.py
index cbf4ce8..e769d8b 100644
--- a/polymatrix/expression/mixins/evalexprmixin.py
+++ b/polymatrix/expression/mixins/evalexprmixin.py
@@ -102,7 +102,6 @@ class EvalExprMixin(ExpressionBaseMixin):
 
         return state, poly_matrix   
 
-
         # if len(self.values) == 1:
         #     values = tuple(self.values[0] for _ in self.variables)
 
diff --git a/polymatrix/expression/mixins/expressionmixin.py b/polymatrix/expression/mixins/expressionmixin.py
deleted file mode 100644
index 22702ca..0000000
--- a/polymatrix/expression/mixins/expressionmixin.py
+++ /dev/null
@@ -1,534 +0,0 @@
-import abc
-import dataclasses
-import typing
-import numpy as np
-import sympy
-
-from polymatrix.expression.init.initadditionexpr import init_addition_expr
-from polymatrix.expression.init.initcacheexpr import init_cache_expr
-from polymatrix.expression.init.initcombinationsexpr import init_combinations_expr
-from polymatrix.expression.init.initderivativeexpr import init_derivative_expr
-from polymatrix.expression.init.initdeterminantexpr import init_determinant_expr
-from polymatrix.expression.init.initdivergenceexpr import init_divergence_expr
-from polymatrix.expression.init.initdivisionexpr import init_division_expr
-from polymatrix.expression.init.initelemmultexpr import init_elem_mult_expr
-from polymatrix.expression.init.initevalexpr import init_eval_expr
-from polymatrix.expression.init.initfilterexpr import init_filter_expr
-from polymatrix.expression.init.initfromsymmetricmatrixexpr import init_from_symmetric_matrix_expr
-from polymatrix.expression.init.inithalfnewtonpolytopeexpr import init_half_newton_polytope_expr
-from polymatrix.expression.init.initlinearinexpr import init_linear_in_expr
-from polymatrix.expression.init.initfromsympyexpr import init_from_sympy_expr
-from polymatrix.expression.init.initgetitemexpr import init_get_item_expr
-from polymatrix.expression.init.initlinearmatrixinexpr import init_linear_matrix_in_expr
-from polymatrix.expression.init.initlinearmonomialsexpr import init_linear_monomials_expr
-from polymatrix.expression.init.initmatrixmultexpr import init_matrix_mult_expr
-from polymatrix.expression.init.initmaxdegreeexpr import init_max_degree_expr
-from polymatrix.expression.init.initmaxexpr import init_max_expr
-from polymatrix.expression.init.initparametrizeexpr import init_parametrize_expr
-from polymatrix.expression.init.initparametrizematrixexpr import init_parametrize_matrix_expr
-from polymatrix.expression.init.initquadraticinexpr import init_quadratic_in_expr
-from polymatrix.expression.init.initrepmatexpr import init_rep_mat_expr
-from polymatrix.expression.init.initreshapeexpr import init_reshape_expr
-from polymatrix.expression.init.initsetelementatexpr import init_set_element_at_expr
-from polymatrix.expression.init.initquadraticmonomialsexpr import init_quadratic_monomials_expr
-from polymatrix.expression.init.initsqueezeexpr import init_squeeze_expr
-from polymatrix.expression.init.initsubstituteexpr import init_substitute_expr
-from polymatrix.expression.init.initsubtractmonomialsexpr import init_subtract_monomials_expr
-from polymatrix.expression.init.initsumexpr import init_sum_expr
-from polymatrix.expression.init.initsymmetricexpr import init_symmetric_expr
-from polymatrix.expression.init.inittoconstantexpr import init_to_constant_expr
-from polymatrix.expression.init.inittoquadraticexpr import init_to_quadratic_expr
-from polymatrix.expression.init.initdiagexpr import init_diag_expr
-from polymatrix.expression.init.inittosortedvariables import init_to_sorted_variables
-from polymatrix.expression.init.inittosymmetricmatrixexpr import init_to_symmetric_matrix_expr
-from polymatrix.expression.init.inittransposeexpr import init_transpose_expr
-from polymatrix.expression.init.inittruncateexpr import init_truncate_expr
-
-from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
-from polymatrix.polymatrix.polymatrix import PolyMatrix
-from polymatrix.expressionstate.expressionstate import ExpressionState
-
-
-class ExpressionMixin(
-    ExpressionBaseMixin,
-    abc.ABC,
-):
-
-    @property
-    @abc.abstractmethod
-    def underlying(self) -> ExpressionBaseMixin:
-        ...
-
-    # overwrites abstract method of `PolyMatrixExprBaseMixin`
-    def apply(self, state: ExpressionState) -> tuple[ExpressionState, PolyMatrix]:
-        return self.underlying.apply(state)
-
-    def __add__(self, other: ExpressionBaseMixin) -> 'ExpressionMixin':
-        if other is None:
-            return self
-
-        right = self._convert_to_expression(other)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_addition_expr(
-                left=self.underlying,
-                right=right,
-            ),
-        )
-
-    def __getattr__(self, name):
-        attr = getattr(self.underlying, name)
-
-        if isinstance(attr, ExpressionBaseMixin):
-            return dataclasses.replace(
-                self, 
-                underlying=attr,
-            )
-
-        else:
-            return attr
-
-    def __getitem__(self, key: tuple[int, int]):
-        return dataclasses.replace(
-            self, 
-            underlying=init_get_item_expr(
-                underlying=self.underlying,
-                index=key,
-            ),
-        )     
-
-    def __matmul__(self, other: typing.Union[ExpressionBaseMixin, np.ndarray]) -> 'ExpressionMixin':
-        right = self._convert_to_expression(other)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_matrix_mult_expr(
-                left=self.underlying,
-                right=right,
-            ),
-        )
-
-    def __mul__(self, other) -> 'ExpressionMixin':
-        right = self._convert_to_expression(other)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_elem_mult_expr(
-                left=self.underlying,
-                right=right,
-            ),
-        )
-
-    def __pow__(self, num):
-        curr = 1
-
-        for _ in range(num):
-            curr = curr * self
-
-        return curr
-
-    def __neg__(self):
-        return self * (-1)
-
-    def __radd__(self, other):
-        return self + other
-
-    def __rmatmul__(self, other):
-        left = self._convert_to_expression(other)
-
-        return left @ self
-
-    def __rmul__(self, other):
-        return self * other
-
-    def __sub__(self, other):
-        return self + other * (-1)
-
-    def __truediv__(self, other: ExpressionBaseMixin):
-        if isinstance(other, (int, float)):
-            return self * (1/other)
-
-        right = self._convert_to_expression(other)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_division_expr(
-                left=self.underlying,
-                right=right,
-            ),
-        )
-
-    def _convert_to_expression(self, other):
-        if isinstance(other, ExpressionBaseMixin):
-            return other
-
-        # can_convert = isinstance(other, (float, int, sympy.Expr, np.ndarray))
-
-        # if not can_convert:
-        #     raise Exception(f'{other} cannot be converted to an Expression')
-        # else:
-
-        return init_from_sympy_expr(other)
-
-    def cache(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_cache_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def combinations(self, number: int):
-        return dataclasses.replace(
-            self, 
-            underlying=init_combinations_expr(
-                monomials=self.underlying,
-                number=number,
-            ),
-        )
-
-    def determinant(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_determinant_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def diag(self):
-        return dataclasses.replace(
-            self, 
-            underlying=init_diag_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def diff(
-        self, 
-        variables: 'ExpressionMixin',
-        introduce_derivatives: bool = None,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_derivative_expr(
-                underlying=self.underlying,
-                variables=variables,
-                introduce_derivatives=introduce_derivatives,
-            ),
-        )
-
-    def divergence(
-        self, 
-        variables: tuple,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_divergence_expr(
-                underlying=self.underlying,
-                variables=variables,
-            ),
-        )
-
-    def eval(
-        self,
-        variable: tuple, 
-        value: tuple[float, ...] = None,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_eval_expr(
-                underlying=self.underlying,
-                variables=variable,
-                values=value,
-            ),
-        )
-
-    def filter(
-        self,
-        predicator: 'ExpressionMixin',
-        inverse: bool = None,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_filter_expr(
-                underlying=self.underlying,
-                predicator=predicator,
-                inverse=inverse,
-            ),
-        )
-
-    def from_symmetric_matrix(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_from_symmetric_matrix_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def half_newton_polytope(
-        self,
-        variables: 'ExpressionMixin',
-        filter: 'ExpressionMixin | None' = None,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_half_newton_polytope_expr(
-                monomials=self.underlying,
-                variables=variables,
-                filter=filter,
-            ),
-        )
-
-    def linear_matrix_in(self, variable: 'ExpressionMixin') -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_linear_matrix_in_expr(
-                underlying=self.underlying,
-                variable=variable,
-            ),
-        )
-
-    def linear_monomials(self, variables: 'ExpressionMixin') -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_linear_monomials_expr(
-                underlying=self.underlying,
-                variables=variables,
-            ),
-        )
-
-    def linear_in(
-        self, 
-        variables: 'ExpressionMixin', 
-        monomials: 'ExpressionMixin' = None,
-        ignore_unmatched: bool = None,    
-    ) -> 'ExpressionMixin':
-        if monomials is None:
-            monomials = self.linear_monomials(variables)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_linear_in_expr(
-                underlying=self.underlying,
-                monomials=monomials,
-                variables=variables,
-                ignore_unmatched=ignore_unmatched,
-            ),
-        )
-
-    def max(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_max_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def max_degree(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_max_degree_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def parametrize(self, name: str = None) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_parametrize_expr(
-                underlying=self.underlying,
-                name=name,
-            ),
-        )
-    
-    # def parametrize_matrix(self, name: str = None) -> 'ExpressionMixin':
-    #     return dataclasses.replace(
-    #         self, 
-    #         underlying=init_parametrize_matrix_expr(
-    #             underlying=self.underlying,
-    #             name=name,
-    #         ),
-    #     )
-
-    def quadratic_in(self, variables: 'ExpressionMixin', monomials: 'ExpressionMixin' = None) -> 'ExpressionMixin':
-        if monomials is None:
-            monomials = self.quadratic_monomials(variables)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_quadratic_in_expr(
-                underlying=self.underlying,
-                monomials=monomials,
-                variables=variables,
-            ),
-        )
-
-    def quadratic_monomials(
-        self, 
-        variables: 'ExpressionMixin',
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_quadratic_monomials_expr(
-                underlying=self.underlying,
-                variables=variables,
-            ),
-        )
-
-    def reshape(self, n: int, m: int) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_reshape_expr(
-                underlying=self.underlying,
-                new_shape=(n, m),
-            ),
-        )
-
-    def rep_mat(self, n: int, m: int) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_rep_mat_expr(
-                underlying=self.underlying,
-                repetition=(n, m),
-            ),
-        )
-
-    def set_element_at(
-        self,
-        row: int,
-        col: int, 
-        value: 'ExpressionMixin',
-    ) -> 'ExpressionMixin':
-        if isinstance(value, ExpressionMixin):
-            value = value.underlying
-        else:
-            value = init_from_sympy_expr(value)
-
-        return dataclasses.replace(
-            self, 
-            underlying=init_set_element_at_expr(
-                underlying=self.underlying,
-                index=(row, col),
-                value=value,
-            ),
-        )
-
-    def squeeze(
-        self,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_squeeze_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def subtract_monomials(
-        self, 
-        monomials: 'ExpressionMixin',
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_subtract_monomials_expr(
-                underlying=self.underlying,
-                monomials=monomials,
-            ),
-        )
-
-    def substitute(
-        self,
-        variable: tuple, 
-        values: tuple['ExpressionMixin', ...] = None,
-    ) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_substitute_expr(
-                underlying=self.underlying,
-                variables=variable,
-                values=values,
-            ),
-        )
-
-    def subs(
-        self,
-        variable: tuple, 
-        values: tuple['ExpressionMixin', ...] = None,
-    ) -> 'ExpressionMixin':
-        return self.substitute(
-            variable=variable,
-            values=values,
-        )
-
-    def sum(self):
-        return dataclasses.replace(
-            self, 
-            underlying=init_sum_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def symmetric(self):
-        return dataclasses.replace(
-            self, 
-            underlying=init_symmetric_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    @property
-    def T(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_transpose_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def to_constant(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_to_constant_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    # def to_quadratic(self) -> 'ExpressionMixin':
-    #     return dataclasses.replace(
-    #         self, 
-    #         underlying=init_to_quadratic_expr(
-    #             underlying=self.underlying,
-    #         ),
-    #     )
-
-    def to_symmetric_matrix(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_to_symmetric_matrix_expr(
-                underlying=self.underlying,
-            ),
-        )
-
-    def to_sorted_variables(self) -> 'ExpressionMixin':
-        return dataclasses.replace(
-            self, 
-            underlying=init_to_sorted_variables(
-                underlying=self.underlying,
-            ),
-        )
-
-    def truncate(
-        self, 
-        variables: tuple, 
-        degrees: tuple[int],
-        inverse: bool = None,    
-    ):
-        return dataclasses.replace(
-            self, 
-            underlying=init_truncate_expr(
-                underlying=self.underlying,
-                variables=variables,
-                degrees=degrees,
-                inverse=inverse,
-            ),
-        )
diff --git a/polymatrix/expression/mixins/eyeexprmixin.py b/polymatrix/expression/mixins/eyeexprmixin.py
index 47e83f9..7d844ce 100644
--- a/polymatrix/expression/mixins/eyeexprmixin.py
+++ b/polymatrix/expression/mixins/eyeexprmixin.py
@@ -1,7 +1,7 @@
 
 import abc
 import itertools
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -23,7 +23,7 @@ class EyeExprMixin(ExpressionBaseMixin):
     
         state, variable = self.variable.apply(state)
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class EyePolyMatrix(PolyMatrixMixin):
             shape: tuple[int, int]
 
diff --git a/polymatrix/expression/mixins/fromsympyexprmixin.py b/polymatrix/expression/mixins/fromsympyexprmixin.py
index 4728bbb..25edde0 100644
--- a/polymatrix/expression/mixins/fromsympyexprmixin.py
+++ b/polymatrix/expression/mixins/fromsympyexprmixin.py
@@ -27,7 +27,7 @@ class FromSympyExprMixin(ExpressionBaseMixin):
         for poly_row, col_data in enumerate(self.data):
             for poly_col, poly_data in enumerate(col_data):
 
-                if isinstance(poly_data, (int, float)):
+                if isinstance(poly_data, (int, float, np.number)):
                     if math.isclose(poly_data, 0):
                         polynomial = {}
                     else:
diff --git a/polymatrix/expression/mixins/getitemexprmixin.py b/polymatrix/expression/mixins/getitemexprmixin.py
index 1d0586f..60adac1 100644
--- a/polymatrix/expression/mixins/getitemexprmixin.py
+++ b/polymatrix/expression/mixins/getitemexprmixin.py
@@ -2,7 +2,7 @@
 import abc
 import dataclasses
 import typing
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
@@ -65,7 +65,7 @@ class GetItemExprMixin(ExpressionBaseMixin):
             get_proper_index(self.index[1], underlying.shape[1]),
         )
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class GetItemPolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
             index: tuple[int, int]
diff --git a/polymatrix/expression/mixins/quadraticinexprmixin.py b/polymatrix/expression/mixins/quadraticinexprmixin.py
index 5c32f45..4568286 100644
--- a/polymatrix/expression/mixins/quadraticinexprmixin.py
+++ b/polymatrix/expression/mixins/quadraticinexprmixin.py
@@ -39,7 +39,6 @@ class QuadraticInExprMixin(ExpressionBaseMixin):
 
         assert underlying.shape == (1, 1), f'underlying shape is {underlying.shape}'
 
-        terms = collections.defaultdict(dict)
         terms = collections.defaultdict(lambda: collections.defaultdict(float))
 
         for monomial, value in underlying.get_poly(0, 0).items():
@@ -59,14 +58,10 @@ class QuadraticInExprMixin(ExpressionBaseMixin):
             except ValueError:
                 raise ValueError(f'{right=} not in {sos_monomials=}')
 
-            # monomial_terms = terms[row, col]
-            # if p_monomial not in monomial_terms:
-            #     monomial_terms[p_monomial] = 0
-
             terms[row, col][p_monomial] += value
 
         poly_matrix = init_poly_matrix(
-            terms=dict(terms),
+            terms=dict((k, dict(v)) for k, v in terms.items()),
             shape=2*(len(sos_monomials),),
         )
 
diff --git a/polymatrix/expression/mixins/repmatexprmixin.py b/polymatrix/expression/mixins/repmatexprmixin.py
index d45cca2..8ed4811 100644
--- a/polymatrix/expression/mixins/repmatexprmixin.py
+++ b/polymatrix/expression/mixins/repmatexprmixin.py
@@ -1,5 +1,5 @@
 import abc
-import dataclass_abc
+import dataclassabc
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
 from polymatrix.expressionstate.mixins.expressionstatemixin import ExpressionStateMixin
@@ -24,7 +24,7 @@ class RepMatExprMixin(ExpressionBaseMixin):
 
         state, underlying = self.underlying.apply(state)
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class RepMatPolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
             shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/reshapeexprmixin.py b/polymatrix/expression/mixins/reshapeexprmixin.py
index a73c00e..683d2fa 100644
--- a/polymatrix/expression/mixins/reshapeexprmixin.py
+++ b/polymatrix/expression/mixins/reshapeexprmixin.py
@@ -1,7 +1,7 @@
 import abc
 import functools
 import operator
-import dataclass_abc
+import dataclassabc
 import numpy as np
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -27,7 +27,7 @@ class ReshapeExprMixin(ExpressionBaseMixin):
 
         state, underlying = self.underlying.apply(state)
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class ReshapePolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
             shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/setelementatexprmixin.py b/polymatrix/expression/mixins/setelementatexprmixin.py
index a111d20..8af695c 100644
--- a/polymatrix/expression/mixins/setelementatexprmixin.py
+++ b/polymatrix/expression/mixins/setelementatexprmixin.py
@@ -2,7 +2,7 @@
 import abc
 import dataclasses
 import typing
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
@@ -47,7 +47,7 @@ class SetElementAtExprMixin(ExpressionBaseMixin):
         if polynomial is None:
             polynomial = 0
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class SetElementAtPolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
             shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/squeezeexprmixin.py b/polymatrix/expression/mixins/squeezeexprmixin.py
index 14cf1f3..6800890 100644
--- a/polymatrix/expression/mixins/squeezeexprmixin.py
+++ b/polymatrix/expression/mixins/squeezeexprmixin.py
@@ -1,8 +1,5 @@
 
 import abc
-import collections
-import typing
-import dataclass_abc
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
diff --git a/polymatrix/expression/mixins/substituteexprmixin.py b/polymatrix/expression/mixins/substituteexprmixin.py
index f69c870..e693de1 100644
--- a/polymatrix/expression/mixins/substituteexprmixin.py
+++ b/polymatrix/expression/mixins/substituteexprmixin.py
@@ -4,6 +4,7 @@ import collections
 import itertools
 import math
 import typing
+from polymatrix.expression.impl.reshapeexprmixin import ReshapeExprImpl
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -29,6 +30,7 @@ class SubstituteExprMixin(ExpressionBaseMixin):
         self, 
         state: ExpressionState,
     ) -> tuple[ExpressionState, PolyMatrix]:
+        
         state, underlying = self.underlying.apply(state=state)
 
         def acc_substitutions(acc, next):
@@ -40,9 +42,14 @@ class SubstituteExprMixin(ExpressionBaseMixin):
             if indices is None:
                 return acc
 
-            state, substitution = expr.apply(state)
+            state, substitution = ReshapeExprImpl(
+                underlying=expr,
+                new_shape=(-1, 1),
+            ).apply(state)
 
-            assert substitution.shape[1] == 1, f'The following expression has to be a vector {expr=}'
+            # # todo: improve this?
+            # substitution = substitution.reshape(-1, 1)
+            # assert substitution.shape[1] == 1, f'The substitutions have to be a vector {substitution=}'
 
             def gen_polynomials():
                 for row in range(substitution.shape[0]):
diff --git a/polymatrix/expression/mixins/symmetricexprmixin.py b/polymatrix/expression/mixins/symmetricexprmixin.py
index e41e889..2677501 100644
--- a/polymatrix/expression/mixins/symmetricexprmixin.py
+++ b/polymatrix/expression/mixins/symmetricexprmixin.py
@@ -2,7 +2,7 @@
 import abc
 import collections
 import itertools
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -26,7 +26,7 @@ class SymmetricExprMixin(ExpressionBaseMixin):
 
         assert underlying.shape[0] == underlying.shape[1]
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class SymmetricPolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
 
diff --git a/polymatrix/expression/mixins/tosortedvariablesmixin.py b/polymatrix/expression/mixins/tosortedvariablesmixin.py
index b4c8d19..eb80597 100644
--- a/polymatrix/expression/mixins/tosortedvariablesmixin.py
+++ b/polymatrix/expression/mixins/tosortedvariablesmixin.py
@@ -8,7 +8,7 @@ from polymatrix.polymatrix.polymatrix import PolyMatrix
 from polymatrix.expressionstate.expressionstate import ExpressionState
 
 
-class ToSortedVariablesMixin(ExpressionBaseMixin):
+class ToSortedVariablesExprMixin(ExpressionBaseMixin):
     @property
     @abc.abstractmethod
     def underlying(self) -> ExpressionBaseMixin:
diff --git a/polymatrix/expression/mixins/transposeexprmixin.py b/polymatrix/expression/mixins/transposeexprmixin.py
index 4153518..5aa59e2 100644
--- a/polymatrix/expression/mixins/transposeexprmixin.py
+++ b/polymatrix/expression/mixins/transposeexprmixin.py
@@ -2,7 +2,7 @@
 import abc
 import dataclasses
 import typing
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.polymatrix.init.initpolymatrix import init_poly_matrix
@@ -24,7 +24,7 @@ class TransposeExprMixin(ExpressionBaseMixin):
     ) -> tuple[ExpressionState, PolyMatrix]:
         state, underlying = self.underlying.apply(state=state)
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class TransposePolyMatrix(PolyMatrixMixin):
             underlying: PolyMatrixMixin
             shape: tuple[int, int]
diff --git a/polymatrix/expression/mixins/vstackexprmixin.py b/polymatrix/expression/mixins/vstackexprmixin.py
index 8d6c25d..fd68ca3 100644
--- a/polymatrix/expression/mixins/vstackexprmixin.py
+++ b/polymatrix/expression/mixins/vstackexprmixin.py
@@ -1,7 +1,7 @@
 
 import abc
 import itertools
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.mixins.polymatrixmixin import PolyMatrixMixin
 
 from polymatrix.expression.mixins.expressionbasemixin import ExpressionBaseMixin
@@ -29,7 +29,7 @@ class VStackExprMixin(ExpressionBaseMixin):
         for underlying in all_underlying:
             assert underlying.shape[1] == all_underlying[0].shape[1], f'{underlying.shape[1]} not equal {all_underlying[0].shape[1]}'
 
-        @dataclass_abc.dataclass_abc(frozen=True)
+        @dataclassabc.dataclassabc(frozen=True)
         class VStackPolyMatrix(PolyMatrixMixin):
             all_underlying: tuple[PolyMatrixMixin]
             underlying_row_range: tuple[tuple[int, int], ...]
diff --git a/polymatrix/expression/parametrizeexpr.py b/polymatrix/expression/parametrizeexpr.py
deleted file mode 100644
index f98fdcd..0000000
--- a/polymatrix/expression/parametrizeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.parametrizeexprmixin import ParametrizeExprMixin 
-
-class ParametrizeExpr(ParametrizeExprMixin):
-	pass
diff --git a/polymatrix/expression/quadraticinexpr.py b/polymatrix/expression/quadraticinexpr.py
deleted file mode 100644
index bab76f6..0000000
--- a/polymatrix/expression/quadraticinexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.quadraticinexprmixin import QuadraticInExprMixin 
-
-class QuadraticInExpr(QuadraticInExprMixin):
-	pass
diff --git a/polymatrix/expression/quadraticmonomialsexpr.py b/polymatrix/expression/quadraticmonomialsexpr.py
deleted file mode 100644
index 77753a5..0000000
--- a/polymatrix/expression/quadraticmonomialsexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.quadraticmonomialsexprmixin import QuadraticMonomialsExprMixin 
-
-class QuadraticMonomialsExpr(QuadraticMonomialsExprMixin):
-	pass
diff --git a/polymatrix/expression/repmatexpr.py b/polymatrix/expression/repmatexpr.py
deleted file mode 100644
index bb983be..0000000
--- a/polymatrix/expression/repmatexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.repmatexprmixin import RepMatExprMixin 
-
-class RepMatExpr(RepMatExprMixin):
-	pass
diff --git a/polymatrix/expression/reshapeexpr.py b/polymatrix/expression/reshapeexpr.py
deleted file mode 100644
index 01ea7dd..0000000
--- a/polymatrix/expression/reshapeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.reshapeexprmixin import ReshapeExprMixin 
-
-class ReshapeExpr(ReshapeExprMixin):
-	pass
diff --git a/polymatrix/expression/setelementatexpr.py b/polymatrix/expression/setelementatexpr.py
deleted file mode 100644
index 147d1f8..0000000
--- a/polymatrix/expression/setelementatexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.setelementatexprmixin import SetElementAtExprMixin 
-
-class SetElementAtExpr(SetElementAtExprMixin):
-	pass
diff --git a/polymatrix/expression/squeezeexpr.py b/polymatrix/expression/squeezeexpr.py
deleted file mode 100644
index 5472764..0000000
--- a/polymatrix/expression/squeezeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.squeezeexprmixin import SqueezeExprMixin 
-
-class SqueezeExpr(SqueezeExprMixin):
-	pass
diff --git a/polymatrix/expression/substituteexpr.py b/polymatrix/expression/substituteexpr.py
deleted file mode 100644
index 3fd4916..0000000
--- a/polymatrix/expression/substituteexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.substituteexprmixin import SubstituteExprMixin 
-
-class SubstituteExpr(SubstituteExprMixin):
-	pass
diff --git a/polymatrix/expression/subtractmonomialsexpr.py b/polymatrix/expression/subtractmonomialsexpr.py
deleted file mode 100644
index 9bc92ea..0000000
--- a/polymatrix/expression/subtractmonomialsexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.subtractmonomialsexprmixin import SubtractMonomialsExprMixin 
-
-class SubtractMonomialsExpr(SubtractMonomialsExprMixin):
-	pass
diff --git a/polymatrix/expression/sumexpr.py b/polymatrix/expression/sumexpr.py
deleted file mode 100644
index 7b62e59..0000000
--- a/polymatrix/expression/sumexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.sumexprmixin import SumExprMixin 
-
-class SumExpr(SumExprMixin):
-	pass
diff --git a/polymatrix/expression/symmetricexpr.py b/polymatrix/expression/symmetricexpr.py
deleted file mode 100644
index ffbaa90..0000000
--- a/polymatrix/expression/symmetricexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.symmetricexprmixin import SymmetricExprMixin 
-
-class SymmetricExpr(SymmetricExprMixin):
-	pass
diff --git a/polymatrix/expression/toconstantexpr.py b/polymatrix/expression/toconstantexpr.py
deleted file mode 100644
index d1fb2a9..0000000
--- a/polymatrix/expression/toconstantexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.toconstantexprmixin import ToConstantExprMixin 
-
-class ToConstantExpr(ToConstantExprMixin):
-	pass
diff --git a/polymatrix/expression/toquadraticexpr.py b/polymatrix/expression/toquadraticexpr.py
deleted file mode 100644
index ff78d8c..0000000
--- a/polymatrix/expression/toquadraticexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.toquadraticexprmixin import ToQuadraticExprMixin 
-
-class ToQuadraticExpr(ToQuadraticExprMixin):
-	pass
diff --git a/polymatrix/expression/tosortedvariables.py b/polymatrix/expression/tosortedvariables.py
deleted file mode 100644
index 89ca315..0000000
--- a/polymatrix/expression/tosortedvariables.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.tosortedvariablesmixin import ToSortedVariablesMixin 
-
-class ToSortedVariables(ToSortedVariablesMixin):
-	pass
diff --git a/polymatrix/expression/tosymmetricmatrixexpr.py b/polymatrix/expression/tosymmetricmatrixexpr.py
deleted file mode 100644
index 119e13b..0000000
--- a/polymatrix/expression/tosymmetricmatrixexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.tosymmetricmatrixexprmixin import ToSymmetricMatrixExprMixin 
-
-class ToSymmetricMatrixExpr(ToSymmetricMatrixExprMixin):
-	pass
diff --git a/polymatrix/expression/transposeexpr.py b/polymatrix/expression/transposeexpr.py
deleted file mode 100644
index 908a9e4..0000000
--- a/polymatrix/expression/transposeexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.transposeexprmixin import TransposeExprMixin 
-
-class TransposeExpr(TransposeExprMixin):
-	pass
diff --git a/polymatrix/expression/truncateexpr.py b/polymatrix/expression/truncateexpr.py
deleted file mode 100644
index b555480..0000000
--- a/polymatrix/expression/truncateexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.truncateexprmixin import TruncateExprMixin 
-
-class TruncateExpr(TruncateExprMixin):
-	pass
diff --git a/polymatrix/expression/vstackexpr.py b/polymatrix/expression/vstackexpr.py
deleted file mode 100644
index 7e9a1d7..0000000
--- a/polymatrix/expression/vstackexpr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from polymatrix.expression.mixins.vstackexprmixin import VStackExprMixin 
-
-class VStackExpr(VStackExprMixin):
-	pass
diff --git a/polymatrix/expressionstate/impl/expressionstateimpl.py b/polymatrix/expressionstate/impl/expressionstateimpl.py
index 31710fb..3890a27 100644
--- a/polymatrix/expressionstate/impl/expressionstateimpl.py
+++ b/polymatrix/expressionstate/impl/expressionstateimpl.py
@@ -1,10 +1,10 @@
 from functools import cached_property
-import dataclass_abc
+import dataclassabc
 from polymatrix.expressionstate.expressionstate import ExpressionState 
 
 from typing import Optional 
 
-@dataclass_abc.dataclass_abc(frozen=True)
+@dataclassabc.dataclassabc(frozen=True)
 class ExpressionStateImpl(ExpressionState):
 	n_param: int
 	offset_dict: dict
diff --git a/polymatrix/polymatrix/impl/polymatriximpl.py b/polymatrix/polymatrix/impl/polymatriximpl.py
index 0c269ca..cfca663 100644
--- a/polymatrix/polymatrix/impl/polymatriximpl.py
+++ b/polymatrix/polymatrix/impl/polymatriximpl.py
@@ -1,8 +1,8 @@
-import dataclass_abc
+import dataclassabc
 from polymatrix.polymatrix.polymatrix import PolyMatrix 
 
 
-@dataclass_abc.dataclass_abc(frozen=True)
+@dataclassabc.dataclassabc(frozen=True)
 class PolyMatrixImpl(PolyMatrix):
 	terms: dict
 	shape: tuple[int, ...]
diff --git a/polymatrix/statemonad/impl/statemonadimpl.py b/polymatrix/statemonad/impl/statemonadimpl.py
index 5f8c6b8..6b9270a 100644
--- a/polymatrix/statemonad/impl/statemonadimpl.py
+++ b/polymatrix/statemonad/impl/statemonadimpl.py
@@ -1,8 +1,8 @@
-import dataclass_abc
+import dataclassabc
 from polymatrix.statemonad.statemonad import StateMonad 
 
 from typing import Callable 
 
-@dataclass_abc.dataclass_abc(frozen=True)
+@dataclassabc.dataclassabc(frozen=True)
 class StateMonadImpl(StateMonad):
 	apply_func: Callable