pyoframe 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

pyoframe/{constraints.py → core.py}

@@ -8,6 +8,7 @@ from typing import (
     overload,
     Union,
     Optional,
+    TYPE_CHECKING,
 )
 from abc import ABC, abstractmethod
 
@@ -21,20 +22,36 @@ from pyoframe.constants import (
     CONSTRAINT_KEY,
     DUAL_KEY,
     RESERVED_COL_KEYS,
+    SLACK_COL,
     VAR_KEY,
+    SOLUTION_KEY,
+    RC_COL,
+    VType,
+    VTypeValue,
     Config,
     ConstraintSense,
     UnmatchedStrategy,
+    PyoframeError,
+    ObjSense,
 )
 from pyoframe.util import (
-    IdCounterMixin,
     cast_coef_to_string,
     concat_dimensions,
     get_obj_repr,
     parse_inputs_as_iterable,
+    unwrap_single_values,
+    dataframe_to_tupled_list,
+    FuncArgs,
 )
 
-from pyoframe.model_element import ModelElement
+from pyoframe.model_element import (
+    ModelElement,
+    ModelElementWithId,
+    SupportPolarsMethodMixin,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from pyoframe.model import Model
 
 VAR_TYPE = pl.UInt32
 
@@ -54,9 +71,10 @@ class SupportsToExpr(Protocol):
 class SupportsMath(ABC, SupportsToExpr):
     """Any object that can be converted into an expression."""
 
-    def __init__(self):
+    def __init__(self, **kwargs):
         self.unmatched_strategy = UnmatchedStrategy.UNSET
         self.allowed_new_dims: List[str] = []
+        super().__init__(**kwargs)
 
     def keep_unmatched(self):
         self.unmatched_strategy = UnmatchedStrategy.KEEP
@@ -71,8 +89,7 @@ class SupportsMath(ABC, SupportsToExpr):
         return self
 
     @abstractmethod
-    def to_expr(self) -> "Expression":
-        raise NotImplementedError
+    def to_expr(self) -> "Expression": ...
 
     __add__ = _forward_to_expression("__add__")
     __mul__ = _forward_to_expression("__mul__")
@@ -145,16 +162,17 @@ SetTypes = Union[
     SupportsMath,
     Mapping[str, Sequence[object]],
     "Set",
+    "Constraint",
 ]
 
 
-class Set(ModelElement, SupportsMath):
+class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
     def __init__(self, *data: SetTypes | Iterable[SetTypes], **named_data):
         data_list = list(data)
         for name, set in named_data.items():
             data_list.append({name: set})
         df = self._parse_acceptable_sets(*data_list)
-        if df.is_duplicated().any():
+        if not df.is_empty() and df.is_duplicated().any():
             raise ValueError("Duplicate rows found in input data.")
         super().__init__(df)
 
@@ -224,20 +242,34 @@ class Set(ModelElement, SupportsMath):
 
     def __add__(self, other):
         if isinstance(other, Set):
-            raise ValueError("Cannot add two sets.")
+            try:
+                return self._new(
+                    pl.concat([self.data, other.data]).unique(maintain_order=True)
+                )
+            except pl.ShapeError as e:
+                if "unable to vstack, column names don't match" in str(e):
+                    raise PyoframeError(
+                        f"Failed to add sets '{self.friendly_name}' and '{other.friendly_name}' because dimensions do not match ({self.dimensions} != {other.dimensions}) "
+                    ) from e
+                raise e
+
         return super().__add__(other)
 
     def __repr__(self):
         return (
             get_obj_repr(self, ("name",), size=self.data.height, dimensions=self.shape)
             + "\n"
-            + self.to_expr().to_str(max_line_len=80, max_rows=10)
+            + dataframe_to_tupled_list(
+                self.data, num_max_elements=Config.print_max_set_elements
+            )
         )
 
     @staticmethod
     def _set_to_polars(set: "SetTypes") -> pl.DataFrame:
         if isinstance(set, dict):
             df = pl.DataFrame(set)
+        elif isinstance(set, Constraint):
+            df = set.data.select(set.dimensions_unsafe)
         elif isinstance(set, SupportsMath):
             df = set.to_expr().data.drop(RESERVED_COL_KEYS).unique(maintain_order=True)
         elif isinstance(set, pd.Index):
@@ -267,7 +299,7 @@ class Set(ModelElement, SupportsMath):
         return df
 
 
-class Expression(ModelElement, SupportsMath):
+class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
     """A linear expression."""
 
     def __init__(self, data: pl.DataFrame):
@@ -275,7 +307,7 @@ class Expression(ModelElement, SupportsMath):
         >>> import pandas as pd
         >>> from pyoframe import Variable, Model
         >>> df = pd.DataFrame({"item" : [1, 1, 1, 2, 2], "time": ["mon", "tue", "wed", "mon", "tue"], "cost": [1, 2, 3, 4, 5]}).set_index(["item", "time"])
-        >>> m = Model()
+        >>> m = Model("min")
         >>> m.Time = Variable(df.index)
         >>> m.Size = Variable(df.index)
         >>> expr = df["cost"] * m.Time + df["cost"] * m.Size
@@ -292,14 +324,31 @@ class Expression(ModelElement, SupportsMath):
         assert COEF_KEY in data.columns, "Missing coefficient column."
 
         # Sanity check no duplicates indices
-        if data.drop(COEF_KEY).is_duplicated().any():
-            duplicated_data = data.filter(data.drop(COEF_KEY).is_duplicated())
-            raise ValueError(
-                f"Cannot create an expression with duplicate indices:\n{duplicated_data}."
-            )
+        if Config.enable_is_duplicated_expression_safety_check:
+            duplicated_mask = data.drop(COEF_KEY).is_duplicated()
+            # In theory this should never happen unless there's a bug in the library
+            if duplicated_mask.any():  # pragma: no cover
+                duplicated_data = data.filter(duplicated_mask)
+                raise ValueError(
+                    f"Cannot create an expression with duplicate indices:\n{duplicated_data}."
+                )
 
         super().__init__(data)
 
+    # Might add this in later
+    # @classmethod
+    # def empty(cls, dimensions=[], type=None):
+    #     data = {COEF_KEY: [], VAR_KEY: []}
+    #     data.update({d: [] for d in dimensions})
+    #     schema = {COEF_KEY: pl.Float64, VAR_KEY: pl.UInt32}
+    #     if type is not None:
+    #         schema.update({d: t for d, t in zip(dimensions, type)})
+    #     return Expression(
+    #         pl.DataFrame(data).with_columns(
+    #             *[pl.col(c).cast(t) for c, t in schema.items()]
+    #         )
+    #     )
+
     def sum(self, over: Union[str, Iterable[str]]):
         """
         Examples:
@@ -358,18 +407,18 @@ class Expression(ModelElement, SupportsMath):
 
         >>> import polars as pl
         >>> from pyoframe import Variable, Model
-        >>> pop_data = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "population": [10, 2, 8]}).to_expr()
+        >>> pop_data = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "year": [2024, 2024, 2024], "population": [10, 2, 8]}).to_expr()
         >>> cities_and_countries = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "country": ["Canada", "Canada", "USA"]})
         >>> pop_data.map(cities_and_countries)
-        <Expression size=2 dimensions={'country': 2} terms=2>
-        [Canada]: 12
-        [USA]: 8
+        <Expression size=2 dimensions={'year': 1, 'country': 2} terms=2>
+        [2024,Canada]: 12
+        [2024,USA]: 8
 
         >>> pop_data.map(cities_and_countries, drop_shared_dims=False)
-        <Expression size=3 dimensions={'city': 3, 'country': 2} terms=3>
-        [Toronto,Canada]: 10
-        [Vancouver,Canada]: 2
-        [Boston,USA]: 8
+        <Expression size=3 dimensions={'city': 3, 'year': 1, 'country': 2} terms=3>
+        [Toronto,2024,Canada]: 10
+        [Vancouver,2024,Canada]: 2
+        [Boston,2024,USA]: 8
         """
         mapping_set = Set(mapping_set)
 
@@ -422,7 +471,7 @@ class Expression(ModelElement, SupportsMath):
             >>> import polars as pl
             >>> from pyoframe import Variable, Model
             >>> cost = pl.DataFrame({"item" : [1, 1, 1, 2, 2], "time": [1, 2, 3, 1, 2], "cost": [1, 2, 3, 4, 5]})
-            >>> m = Model()
+            >>> m = Model("min")
             >>> m.quantity = Variable(cost[["item", "time"]])
             >>> (m.quantity * cost).rolling_sum(over="time", window_size=2)
             <Expression size=5 dimensions={'item': 2, 'time': 3} terms=8>
@@ -501,7 +550,7 @@ class Expression(ModelElement, SupportsMath):
             >>> var + pd.DataFrame({"dim1": [1,2], "add": [10, 20]})
             Traceback (most recent call last):
             ...
-            pyoframe._arithmetic.PyoframeError: Failed to add expressions:
+            pyoframe.constants.PyoframeError: Failed to add expressions:
             <Expression size=3 dimensions={'dim1': 3} terms=3> + <Expression size=2 dimensions={'dim1': 2} terms=2>
             Due to error:
             Dataframe has unmatched values. If this is intentional, use .drop_unmatched() or .keep_unmatched()
@@ -630,11 +679,59 @@ class Expression(ModelElement, SupportsMath):
     def variable_terms(self):
         return self.data.filter(pl.col(VAR_KEY) != CONST_TERM)
 
+    @property
+    @unwrap_single_values
+    def value(self) -> pl.DataFrame:
+        """
+        The value of the expression. Only available after the model has been solved.
+
+        Examples:
+            >>> import pyoframe as pf
+            >>> m = pf.Model("max")
+            >>> m.X = pf.Variable({"dim1": [1, 2, 3]}, ub=10)
+            >>> m.expr_1 = 2 * m.X
+            >>> m.expr_2 = pf.sum(m.expr_1)
+            >>> m.objective = m.expr_2 + 3
+            >>> result = m.solve(log_to_console=False)
+            >>> m.expr_1.value
+            shape: (3, 2)
+            ┌──────┬──────────┐
+            │ dim1 ┆ solution │
+            │ ---  ┆ ---      │
+            │ i64  ┆ f64      │
+            ╞══════╪══════════╡
+            │ 1    ┆ 20.0     │
+            │ 2    ┆ 20.0     │
+            │ 3    ┆ 20.0     │
+            └──────┴──────────┘
+            >>> m.expr_2.value
+            60.0
+            >>> m.objective.value
+            63.0
+        """
+        if self._model.result is None or self._model.result.solution is None:
+            raise ValueError(
+                "Can't obtain value of expression since the model has not been solved."
+            )
+
+        df = (
+            self.data.join(self._model.result.solution.primal, on=VAR_KEY, how="left")
+            .drop(VAR_KEY)
+            .with_columns((pl.col(SOLUTION_KEY) * pl.col(COEF_KEY)))
+            .drop(COEF_KEY)
+        )
+
+        dims = self.dimensions
+        if dims is not None:
+            df = df.group_by(dims, maintain_order=True)
+        return df.sum()
+
     def to_str_table(
         self,
         max_line_len=None,
         max_rows=None,
         include_const_term=True,
+        include_const_variable=False,
         var_map=None,
         float_precision=None,
     ):
@@ -650,12 +747,15 @@ class Expression(ModelElement, SupportsMath):
             data = data.with_columns(
                 pl.concat_str(pl.lit("x"), VAR_KEY).alias("str_var")
             )
-        data = data.with_columns(
-            pl.when(pl.col(VAR_KEY) == CONST_TERM)
-            .then(pl.lit(""))
-            .otherwise("str_var")
-            .alias(VAR_KEY)
-        ).drop("str_var")
+        if include_const_variable:
+            data = data.drop(VAR_KEY).rename({"str_var": VAR_KEY})
+        else:
+            data = data.with_columns(
+                pl.when(pl.col(VAR_KEY) == CONST_TERM)
+                .then(pl.lit(""))
+                .otherwise("str_var")
+                .alias(VAR_KEY)
+            ).drop("str_var")
 
         dimensions = self.dimensions
 
@@ -709,6 +809,7 @@ class Expression(ModelElement, SupportsMath):
         max_line_len=None,
         max_rows=None,
         include_const_term=True,
+        include_const_variable=False,
         var_map=None,
         include_prefix=True,
         include_header=False,
@@ -727,6 +828,7 @@ class Expression(ModelElement, SupportsMath):
                 max_line_len=max_line_len,
                 max_rows=max_rows,
                 include_const_term=include_const_term,
+                include_const_variable=include_const_variable,
                 var_map=var_map,
                 float_precision=float_precision,
             )
@@ -749,11 +851,11 @@ class Expression(ModelElement, SupportsMath):
 
 
 @overload
-def sum(over: Union[str, Sequence[str]], expr: SupportsToExpr): ...
+def sum(over: Union[str, Sequence[str]], expr: SupportsToExpr) -> "Expression": ...
 
 
 @overload
-def sum(over: SupportsToExpr): ...
+def sum(over: SupportsToExpr) -> "Expression": ...
 
 
 def sum(
@@ -786,10 +888,10 @@ def sum_by(by: Union[str, Sequence[str]], expr: SupportsToExpr) -> "Expression":
     return sum(over=remaining_dims, expr=expr)
 
 
-class Constraint(Expression, IdCounterMixin):
+class Constraint(ModelElementWithId):
     """A linear programming constraint."""
 
-    def __init__(self, lhs: Expression | pl.DataFrame, sense: ConstraintSense):
+    def __init__(self, lhs: Expression, sense: ConstraintSense):
         """Initialize a constraint.
 
         Parameters:
@@ -798,53 +900,57 @@ class Constraint(Expression, IdCounterMixin):
             sense: Sense
                 The sense of the constraint.
         """
-        if isinstance(lhs, Expression):
-            data = lhs.data
-        else:
-            data = lhs
-        super().__init__(data)
-        if isinstance(lhs, Expression):
-            self._model = lhs._model
+        self.lhs = lhs
+        self._model = lhs._model
         self.sense = sense
+        self.to_relax: Optional[FuncArgs] = None
 
-        dims = self.dimensions
-        data_per_constraint = (
-            pl.DataFrame() if dims is None else self.data.select(dims).unique()
-        )
-        self.data_per_constraint = self._assign_ids(data_per_constraint)
+        dims = self.lhs.dimensions
+        data = pl.DataFrame() if dims is None else self.lhs.data.select(dims).unique()
+
+        super().__init__(data)
+
+    def on_add_to_model(self, model: "Model", name: str):
+        super().on_add_to_model(model, name)
+        if self.to_relax is not None:
+            self.relax(*self.to_relax.args, **self.to_relax.kwargs)
 
     @property
+    @unwrap_single_values
+    def slack(self):
+        """
+        The slack of the constraint.
+        Will raise an error if the model has not already been solved.
+        The first call to this property will load the slack values from the solver (lazy loading).
+        """
+        if SLACK_COL not in self.data.columns:
+            if self._model.solver is None:
+                raise ValueError("The model has not been solved yet.")
+            self._model.solver.load_slack()
+        return self.data.select(self.dimensions_unsafe + [SLACK_COL])
+
+    @slack.setter
+    def slack(self, value):
+        self._extend_dataframe_by_id(value)
+
+    @property
+    @unwrap_single_values
     def dual(self) -> Union[pl.DataFrame, float]:
-        if DUAL_KEY not in self.data_per_constraint.columns:
+        if DUAL_KEY not in self.data.columns:
             raise ValueError(f"No dual values founds for constraint '{self.name}'")
-        result = self.data_per_constraint.select(self.dimensions_unsafe + [DUAL_KEY])
-        if result.shape == (1, 1):
-            return result.item()
-        return result
+        return self.data.select(self.dimensions_unsafe + [DUAL_KEY])
 
     @dual.setter
     def dual(self, value):
-        assert sorted(value.columns) == sorted([DUAL_KEY, CONSTRAINT_KEY])
-        df = self.data_per_constraint
-        if DUAL_KEY in df.columns:
-            df = df.drop(DUAL_KEY)
-        self.data_per_constraint = df.join(
-            value, on=CONSTRAINT_KEY, how="left", validate="1:1"
-        )
+        self._extend_dataframe_by_id(value)
 
     @classmethod
     def get_id_column_name(cls):
         return CONSTRAINT_KEY
 
-    @property
-    def ids(self) -> pl.DataFrame:
-        return self.data_per_constraint.select(
-            self.dimensions_unsafe + [CONSTRAINT_KEY]
-        )
-
     def to_str_create_prefix(self, data, const_map=None):
         if const_map is None:
-            return super().to_str_create_prefix(data)
+            return self.lhs.to_str_create_prefix(data)
 
         data_map = const_map.apply(self.ids, to_col=None)
 
@@ -860,6 +966,107 @@ class Constraint(Expression, IdCounterMixin):
             pl.concat_str(CONSTRAINT_KEY, pl.lit(": "), "expr").alias("expr")
         ).drop(CONSTRAINT_KEY)
 
+    def filter(self, *args, **kwargs) -> pl.DataFrame:
+        return self.lhs.data.filter(*args, **kwargs)
+
+    def relax(
+        self, cost: SupportsToExpr, max: Optional[SupportsToExpr] = None
+    ) -> Constraint:
+        """
+        Relaxes the constraint by adding a variable to the constraint that can be non-zero at a cost.
+
+        Parameters:
+            cost: SupportsToExpr
+                The cost of relaxing the constraint. Costs should be positives as they will automatically
+                become negative for maximization problems.
+            max: SupportsToExpr, default None
+                The maximum value of the relaxation variable.
+
+        Returns:
+            The same constraint
+
+        Examples:
+            >>> import pyoframe as pf
+            >>> m = pf.Model("max")
+            >>> homework_due_tomorrow = pl.DataFrame({"project": ["A", "B", "C"], "cost_per_hour_underdelivered": [10, 20, 30], "hours_to_finish": [9, 9, 9], "max_underdelivered": [1, 9, 9]})
+            >>> m.hours_spent = pf.Variable(homework_due_tomorrow[["project"]], lb=0)
+            >>> m.must_finish_project = m.hours_spent >= homework_due_tomorrow[["project", "hours_to_finish"]]
+            >>> m.only_one_day = sum("project", m.hours_spent) <= 24
+            >>> m.solve(log_to_console=False)
+            Status: warning
+            Termination condition: infeasible
+            <BLANKLINE>
+
+            >>> _ = m.must_finish_project.relax(homework_due_tomorrow[["project", "cost_per_hour_underdelivered"]], max=homework_due_tomorrow[["project", "max_underdelivered"]])
+            >>> result = m.solve(log_to_console=False)
+            >>> m.hours_spent.solution
+            shape: (3, 2)
+            ┌─────────┬──────────┐
+            │ project ┆ solution │
+            │ ---     ┆ ---      │
+            │ str     ┆ f64      │
+            ╞═════════╪══════════╡
+            │ A       ┆ 8.0      │
+            │ B       ┆ 7.0      │
+            │ C       ┆ 9.0      │
+            └─────────┴──────────┘
+
+
+            >>> # It can also be done all in one go!
+            >>> m = pf.Model("max")
+            >>> homework_due_tomorrow = pl.DataFrame({"project": ["A", "B", "C"], "cost_per_hour_underdelivered": [10, 20, 30], "hours_to_finish": [9, 9, 9], "max_underdelivered": [1, 9, 9]})
+            >>> m.hours_spent = pf.Variable(homework_due_tomorrow[["project"]], lb=0)
+            >>> m.must_finish_project = (m.hours_spent >= homework_due_tomorrow[["project", "hours_to_finish"]]).relax(5)
+            >>> m.only_one_day = (sum("project", m.hours_spent) <= 24).relax(1)
+            >>> _ = m.solve(log_to_console=False)
+            >>> m.objective.value
+            -3.0
+            >>> m.hours_spent.solution
+            shape: (3, 2)
+            ┌─────────┬──────────┐
+            │ project ┆ solution │
+            │ ---     ┆ ---      │
+            │ str     ┆ f64      │
+            ╞═════════╪══════════╡
+            │ A       ┆ 9.0      │
+            │ B       ┆ 9.0      │
+            │ C       ┆ 9.0      │
+            └─────────┴──────────┘
+        """
+        m = self._model
+        if m is None or self.name is None:
+            self.to_relax = FuncArgs(args=[cost, max])
+            return self
+
+        var_name = f"{self.name}_relaxation"
+        assert not hasattr(
+            m, var_name
+        ), "Conflicting names, relaxation variable already exists on the model."
+        var = Variable(self, lb=0, ub=max)
+
+        if self.sense == ConstraintSense.LE:
+            self.lhs -= var
+        elif self.sense == ConstraintSense.GE:
+            self.lhs += var
+        else:  # pragma: no cover
+            # TODO
+            raise NotImplementedError(
+                "Relaxation for equalities has not yet been implemented. Submit a pull request!"
+            )
+
+        setattr(m, var_name, var)
+        penalty = var * cost
+        if self.dimensions:
+            penalty = sum(self.dimensions, penalty)
+        if m.sense == ObjSense.MAX:
+            penalty *= -1
+        if m.objective is None:
+            m.objective = penalty
+        else:
+            m.objective += penalty
+
+        return self
+
     def to_str(
         self,
         max_line_len=None,
@@ -867,16 +1074,16 @@ class Constraint(Expression, IdCounterMixin):
         var_map=None,
         float_precision=None,
         const_map=None,
-    ):
+    ) -> str:
         dims = self.dimensions
-        str_table = self.to_str_table(
+        str_table = self.lhs.to_str_table(
             max_line_len=max_line_len,
             max_rows=max_rows,
             include_const_term=False,
             var_map=var_map,
         )
         str_table = self.to_str_create_prefix(str_table, const_map=const_map)
-        rhs = self.constant_terms.with_columns(pl.col(COEF_KEY) * -1)
+        rhs = self.lhs.constant_terms.with_columns(pl.col(COEF_KEY) * -1)
         rhs = cast_coef_to_string(rhs, drop_ones=False, float_precision=float_precision)
         # Remove leading +
         rhs = rhs.with_columns(pl.col(COEF_KEY).str.strip_chars(characters=" +"))
@@ -899,13 +1106,222 @@ class Constraint(Expression, IdCounterMixin):
                 sense=f"'{self.sense.value}'",
                 size=len(self),
                 dimensions=self.shape,
-                terms=len(self.data),
+                terms=len(self.lhs.data),
             )
             + "\n"
             + self.to_str(max_line_len=80, max_rows=15)
         )
 
+
+class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
+    """
+    Represents one or many decision variable in an optimization model.
+
+    Parameters:
+        *indexing_sets: SetTypes (typically a DataFrame or Set)
+            If no indexing_sets are provided, a single variable with no dimensions is created.
+            Otherwise, a variable is created for each element in the Cartesian product of the indexing_sets (see Set for details on behaviour).
+        lb: float
+            The lower bound for all variables.
+        ub: float
+            The upper bound for all variables.
+        vtype: VType | VTypeValue
+            The type of the variable. Can be either a VType enum or a string. Default is VType.CONTINUOUS.
+        equals: SupportsToExpr
+            When specified, a variable is created and a constraint is added to make the variable equal to the provided expression.
+
+    Examples:
+        >>> import pandas as pd
+        >>> from pyoframe import Variable
+        >>> df = pd.DataFrame({"dim1": [1, 1, 2, 2, 3, 3], "dim2": ["a", "b", "a", "b", "a", "b"]})
+        >>> Variable(df)
+        <Variable lb=-inf ub=inf size=6 dimensions={'dim1': 3, 'dim2': 2}>
+        [1,a]: x1
+        [1,b]: x2
+        [2,a]: x3
+        [2,b]: x4
+        [3,a]: x5
+        [3,b]: x6
+        >>> Variable(df[["dim1"]])
+        Traceback (most recent call last):
+        ...
+        ValueError: Duplicate rows found in input data.
+        >>> Variable(df[["dim1"]].drop_duplicates())
+        <Variable lb=-inf ub=inf size=3 dimensions={'dim1': 3}>
+        [1]: x7
+        [2]: x8
+        [3]: x9
+    """
+
+    # TODO: Breaking change, remove support for Iterable[AcceptableSets]
+    def __init__(
+        self,
+        *indexing_sets: SetTypes | Iterable[SetTypes],
+        lb: float | int | SupportsToExpr | None = None,
+        ub: float | int | SupportsToExpr | None = None,
+        vtype: VType | VTypeValue = VType.CONTINUOUS,
+        equals: SupportsToExpr = None,
+    ):
+        if lb is None:
+            lb = float("-inf")
+        if ub is None:
+            ub = float("inf")
+        if equals is not None:
+            assert (
+                len(indexing_sets) == 0
+            ), "Cannot specify both 'equals' and 'indexing_sets'"
+            indexing_sets = (equals,)
+
+        data = Set(*indexing_sets).data if len(indexing_sets) > 0 else pl.DataFrame()
+        super().__init__(data)
+
+        self.vtype: VType = VType(vtype)
+        self._equals = equals
+
+        # Tightening the bounds is not strictly necessary, but it adds clarity
+        if self.vtype == VType.BINARY:
+            lb, ub = 0, 1
+
+        if isinstance(lb, (float, int)):
+            self.lb, self.lb_constraint = lb, None
+        else:
+            self.lb, self.lb_constraint = float("-inf"), lb <= self
+
+        if isinstance(ub, (float, int)):
+            self.ub, self.ub_constraint = ub, None
+        else:
+            self.ub, self.ub_constraint = float("inf"), self <= ub
+
+    def on_add_to_model(self, model: "Model", name: str):
+        super().on_add_to_model(model, name)
+        if self.lb_constraint is not None:
+            setattr(model, f"{name}_lb", self.lb_constraint)
+        if self.ub_constraint is not None:
+            setattr(model, f"{name}_ub", self.ub_constraint)
+        if self._equals is not None:
+            setattr(model, f"{name}_equals", self == self._equals)
+
+    @classmethod
+    def get_id_column_name(cls):
+        return VAR_KEY
+
+    @property
+    @unwrap_single_values
+    def solution(self):
+        if SOLUTION_KEY not in self.data.columns:
+            raise ValueError(f"No solution solution found for Variable '{self.name}'.")
+
+        return self.data.select(self.dimensions_unsafe + [SOLUTION_KEY])
+
+    @property
+    @unwrap_single_values
+    def RC(self):
+        """
+        The reduced cost of the variable.
+        Will raise an error if the model has not already been solved.
+        The first call to this property will load the reduced costs from the solver (lazy loading).
+        """
+        if RC_COL not in self.data.columns:
+            if self._model.solver is None:
+                raise ValueError("The model has not been solved yet.")
+            self._model.solver.load_rc()
+        return self.data.select(self.dimensions_unsafe + [RC_COL])
+
+    @RC.setter
+    def RC(self, value):
+        self._extend_dataframe_by_id(value)
+
+    @solution.setter
+    def solution(self, value):
+        self._extend_dataframe_by_id(value)
+
+    def __repr__(self):
+        return (
+            get_obj_repr(
+                self, ("name", "lb", "ub"), size=self.data.height, dimensions=self.shape
+            )
+            + "\n"
+            + self.to_expr().to_str(max_line_len=80, max_rows=10)
+        )
+
+    def to_expr(self) -> Expression:
+        return self._new(self.data.drop(SOLUTION_KEY))
+
     def _new(self, data: pl.DataFrame):
-        c = Constraint(data, self.sense)
-        c._model = self._model
-        return c
+        e = Expression(data.with_columns(pl.lit(1.0).alias(COEF_KEY)))
+        e._model = self._model
+        # We propogate the unmatched strategy intentionally. Without this a .keep_unmatched() on a variable would always be lost.
+        e.unmatched_strategy = self.unmatched_strategy
+        e.allowed_new_dims = self.allowed_new_dims
+        return e
+
+    def next(self, dim: str, wrap_around: bool = False) -> Expression:
+        """
+        Creates an expression where the variable at each index is the next variable in the specified dimension.
+
+        Parameters:
+            dim:
+                The dimension over which to shift the variable.
+            wrap_around:
+                If True, the last index in the dimension is connected to the first index.
+
+        Examples:
+            >>> import pandas as pd
+            >>> from pyoframe import Variable, Model
+            >>> time_dim = pd.DataFrame({"time": ["00:00", "06:00", "12:00", "18:00"]})
+            >>> space_dim = pd.DataFrame({"city": ["Toronto", "Berlin"]})
+            >>> m = Model("min")
+            >>> m.bat_charge = Variable(time_dim, space_dim)
+            >>> m.bat_flow = Variable(time_dim, space_dim)
+            >>> # Fails because the dimensions are not the same
+            >>> m.bat_charge + m.bat_flow == m.bat_charge.next("time")
+            Traceback (most recent call last):
+            ...
+            pyoframe.constants.PyoframeError: Failed to add expressions:
+            <Expression size=8 dimensions={'time': 4, 'city': 2} terms=16> + <Expression size=6 dimensions={'city': 2, 'time': 3} terms=6>
+            Due to error:
+            Dataframe has unmatched values. If this is intentional, use .drop_unmatched() or .keep_unmatched()
+            shape: (2, 4)
+            ┌───────┬─────────┬────────────┬────────────┐
+            │ time  ┆ city    ┆ time_right ┆ city_right │
+            │ ---   ┆ ---     ┆ ---        ┆ ---        │
+            │ str   ┆ str     ┆ str        ┆ str        │
+            ╞═══════╪═════════╪════════════╪════════════╡
+            │ 18:00 ┆ Toronto ┆ null       ┆ null       │
+            │ 18:00 ┆ Berlin  ┆ null       ┆ null       │
+            └───────┴─────────┴────────────┴────────────┘
+
+            >>> (m.bat_charge + m.bat_flow).drop_unmatched() == m.bat_charge.next("time")
+            <Constraint sense='=' size=6 dimensions={'time': 3, 'city': 2} terms=18>
+            [00:00,Berlin]: bat_charge[00:00,Berlin] + bat_flow[00:00,Berlin] - bat_charge[06:00,Berlin] = 0
+            [00:00,Toronto]: bat_charge[00:00,Toronto] + bat_flow[00:00,Toronto] - bat_charge[06:00,Toronto] = 0
+            [06:00,Berlin]: bat_charge[06:00,Berlin] + bat_flow[06:00,Berlin] - bat_charge[12:00,Berlin] = 0
+            [06:00,Toronto]: bat_charge[06:00,Toronto] + bat_flow[06:00,Toronto] - bat_charge[12:00,Toronto] = 0
+            [12:00,Berlin]: bat_charge[12:00,Berlin] + bat_flow[12:00,Berlin] - bat_charge[18:00,Berlin] = 0
+            [12:00,Toronto]: bat_charge[12:00,Toronto] + bat_flow[12:00,Toronto] - bat_charge[18:00,Toronto] = 0
+
+            >>> (m.bat_charge + m.bat_flow) == m.bat_charge.next("time", wrap_around=True)
+            <Constraint sense='=' size=8 dimensions={'time': 4, 'city': 2} terms=24>
+            [00:00,Berlin]: bat_charge[00:00,Berlin] + bat_flow[00:00,Berlin] - bat_charge[06:00,Berlin] = 0
+            [00:00,Toronto]: bat_charge[00:00,Toronto] + bat_flow[00:00,Toronto] - bat_charge[06:00,Toronto] = 0
+            [06:00,Berlin]: bat_charge[06:00,Berlin] + bat_flow[06:00,Berlin] - bat_charge[12:00,Berlin] = 0
+            [06:00,Toronto]: bat_charge[06:00,Toronto] + bat_flow[06:00,Toronto] - bat_charge[12:00,Toronto] = 0
+            [12:00,Berlin]: bat_charge[12:00,Berlin] + bat_flow[12:00,Berlin] - bat_charge[18:00,Berlin] = 0
+            [12:00,Toronto]: bat_charge[12:00,Toronto] + bat_flow[12:00,Toronto] - bat_charge[18:00,Toronto] = 0
+            [18:00,Berlin]: bat_charge[18:00,Berlin] + bat_flow[18:00,Berlin] - bat_charge[00:00,Berlin] = 0
+            [18:00,Toronto]: bat_charge[18:00,Toronto] + bat_flow[18:00,Toronto] - bat_charge[00:00,Toronto] = 0
+        """
+
+        wrapped = self.data.select(dim).unique(maintain_order=True).sort(by=dim)
+        wrapped = wrapped.with_columns(pl.col(dim).shift(-1).alias("__next"))
+        if wrap_around:
+            wrapped = wrapped.with_columns(pl.col("__next").fill_null(pl.first(dim)))
+        else:
+            wrapped = wrapped.drop_nulls(dim)
+
+        expr = self.to_expr()
+        data = expr.data.rename({dim: "__prev"})
+        data = data.join(
+            wrapped, left_on="__prev", right_on="__next", how="inner"
+        ).drop(["__prev", "__next"])
+        return expr._new(data)