pepflow 0.1.3a1__py3-none-any.whl → 0.1.4a1__py3-none-any.whl

pepflow/interactive_constraint.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 import json
 from typing import TYPE_CHECKING
 
+import attrs
 import dash
 import dash_bootstrap_components as dbc
 import numpy as np
@@ -29,11 +30,12 @@ import pandas as pd
 import plotly
 import plotly.express as px
 import plotly.graph_objects as go
-from dash import Dash, Input, Output, State, dcc, html
+from dash import ALL, MATCH, Dash, Input, Output, State, dcc, html
 
 from pepflow.constants import PSD_CONSTRAINT
 
 if TYPE_CHECKING:
+    from pepflow.function import Function
     from pepflow.pep import PEPBuilder, PEPResult
     from pepflow.pep_context import PEPContext
 
@@ -42,26 +44,84 @@ plotly.io.renderers.default = "colab+vscode"
 plotly.io.templates.default = "plotly_white"
 
 
+@attrs.frozen
+class PlotData:
+    dataframe: pd.DataFrame
+    figure: go.Figure
+    function: Function
+
+    def dual_matrix_to_tab(self) -> html.Pre:
+        def get_matrix_of_dual_value(df: pd.DataFrame) -> np.ndarray:
+            # Check if we need to update the order.
+            return (
+                pd.pivot_table(
+                    df, values="dual_value", index="row", columns="col", dropna=False
+                )
+                .fillna(0.0)
+                .to_numpy()
+                .T
+            )
+
+        with np.printoptions(precision=3, linewidth=100, suppress=True):
+            dual_value_tab = html.Pre(
+                str(get_matrix_of_dual_value(self.dataframe)),
+                id={"type": "dual-value-display", "index": self.function.tag},
+                style={
+                    "border": "1px solid lightgrey",
+                    "padding": "10px",
+                    "height": "60vh",
+                    "overflowY": "auto",
+                },
+            )
+        return dual_value_tab
+
+    def plot_data_to_tab(self) -> dbc.Tab:
+        tab = dbc.Tab(
+            html.Div(
+                [
+                    html.P("Interactive Heat Map:"),
+                    dcc.Graph(
+                        id={
+                            "type": "interactive-scatter",
+                            "index": self.function.tag,
+                        },
+                        figure=self.figure,
+                    ),
+                    html.P("Dual Value Matrix:"),
+                    self.dual_matrix_to_tab(),
+                ]
+            ),
+            label=f"{self.function.tag}-Interpolation Conditions",
+            tab_id=f"{self.function.tag}-interactive-scatter-tab",
+        )
+        return tab
+
+
 def solve_prob_and_get_figure(
     pep_builder: PEPBuilder, context: PEPContext
-) -> tuple[go.Figure, pd.DataFrame, PEPResult]:
-    assert len(context.triplets) == 1, "Support single function only for now"
+) -> tuple[list[PlotData], PEPResult]:
+    plot_data_list: list[PlotData] = []
 
     result = pep_builder.solve(context=context)
 
     df_dict, order_dict = context.triplets_to_df_and_order()
-    f = pep_builder.functions[0]
 
-    df = df_dict[f]
-    order = order_dict[f]
+    for f in context.triplets.keys():
+        df = df_dict[f]
+        order = order_dict[f]
 
-    df["constraint"] = df.constraint_name.map(
-        lambda x: "inactive" if x in pep_builder.relaxed_constraints else "active"
-    )
-    df["dual_value"] = df.constraint_name.map(
-        lambda x: result.dual_var_manager.dual_value(x)
-    )
-    return processed_df_to_fig(df, order), df, result
+        df["constraint"] = df.constraint_name.map(
+            lambda x: "inactive" if x in pep_builder.relaxed_constraints else "active"
+        )
+        df["dual_value"] = df.constraint_name.map(
+            lambda x: result.dual_var_manager.dual_value(x)
+        )
+
+        plot_data_list.append(
+            PlotData(dataframe=df, figure=processed_df_to_fig(df, order), function=f)
+        )
+
+    return plot_data_list, result
 
 
 def processed_df_to_fig(df: pd.DataFrame, order: list[str]):
@@ -99,19 +159,7 @@ def get_matrix_of_dual_value(df: pd.DataFrame) -> np.ndarray:
 
 def launch(pep_builder: PEPBuilder, context: PEPContext):
     app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
-    fig, df, result = solve_prob_and_get_figure(pep_builder, context)
-
-    with np.printoptions(precision=3, linewidth=100, suppress=True):
-        dual_value_tab = html.Pre(
-            str(get_matrix_of_dual_value(df)),
-            id="dual-value-display",
-            style={
-                "border": "1px solid lightgrey",
-                "padding": "10px",
-                "height": "60vh",
-                "overflowY": "auto",
-            },
-        )
+    plot_data_list, result = solve_prob_and_get_figure(pep_builder, context)
     # Think how can we manipulate the pep_builder here.
     display_row = dbc.Row(
         [
@@ -129,21 +177,8 @@ def launch(pep_builder: PEPBuilder, context: PEPContext):
                         color="success",
                     ),
                     dbc.Tabs(
-                        [
-                            dbc.Tab(
-                                html.Div(
-                                    dcc.Graph(id="interactive-scatter", figure=fig),
-                                ),
-                                label="Interactive Heatmap",
-                                tab_id="interactive-scatter-tab",
-                            ),
-                            dbc.Tab(
-                                dual_value_tab,
-                                label="Dual Value Matrix",
-                                tab_id="dual_value_tab",
-                            ),
-                        ],
-                        active_tab="interactive-scatter-tab",
+                        [plot_data.plot_data_to_tab() for plot_data in plot_data_list],
+                        active_tab=f"{plot_data_list[0].function.tag}-interactive-scatter-tab",
                     ),
                 ],
                 width=5,
@@ -175,25 +210,37 @@ def launch(pep_builder: PEPBuilder, context: PEPContext):
         [
             html.H2("PEPFlow"),
             display_row,
-            # Store the entire DataFrame as a dictionary in dcc.Store
-            dcc.Store(id="dataframe-store", data=df.to_dict("records")),
+            # For each function, store the corresponding DataFrame as a dictionary in dcc.Store
+            *[
+                dcc.Store(
+                    id={
+                        "type": "dataframe-store",
+                        "index": plot_data.function.tag,
+                    },
+                    data=(
+                        plot_data.function.tag,
+                        plot_data.dataframe.to_dict("records"),
+                    ),
+                )
+                for plot_data in plot_data_list
+            ],
         ]
     )
 
     @dash.callback(
         Output("result-card", "children"),
-        Output("dual-value-display", "children"),
-        Output("interactive-scatter", "figure"),
-        Output("dataframe-store", "data"),
+        Output({"type": "dual-value-display", "index": ALL}, "children"),
+        Output({"type": "interactive-scatter", "index": ALL}, "figure"),
+        Output({"type": "dataframe-store", "index": ALL}, "data"),
         Input("solve-button", "n_clicks"),
     )
     def solve(_):
-        fig, df, result = solve_prob_and_get_figure(pep_builder, context)
+        plot_data_list, result = solve_prob_and_get_figure(pep_builder, context)
         with np.printoptions(precision=3, linewidth=100, suppress=True):
             psd_dual_value = np.array(
                 result.dual_var_manager.dual_value(PSD_CONSTRAINT)
             )
-            reslt_card = dbc.CardBody(
+            result_card = dbc.CardBody(
                 [
                     html.H2(f"Optimal Value {result.primal_opt_value:.4g}"),
                     html.H3(f"Solver Status: {result.solver_status}"),
@@ -203,50 +250,89 @@ def launch(pep_builder: PEPBuilder, context: PEPContext):
                     html.Pre(json.dumps(pep_builder.relaxed_constraints, indent=2)),
                 ]
             )
-            dual_value_display = str(get_matrix_of_dual_value(df))
-        return reslt_card, dual_value_display, fig, df.to_dict("records")
+            dual_value_displays = [
+                str(get_matrix_of_dual_value(plot_data.dataframe))
+                for plot_data in plot_data_list
+            ]
+        figs = [plot_data.figure for plot_data in plot_data_list]
+
+        df_data = [
+            (plot_data.function.tag, plot_data.dataframe.to_dict("records"))
+            for plot_data in plot_data_list
+        ]
+
+        return result_card, dual_value_displays, figs, df_data
 
     @dash.callback(
-        Output("interactive-scatter", "figure", allow_duplicate=True),
-        Output("dataframe-store", "data", allow_duplicate=True),
+        Output(
+            {"type": "interactive-scatter", "index": ALL},
+            "figure",
+            allow_duplicate=True,
+        ),
+        Output({"type": "dataframe-store", "index": ALL}, "data", allow_duplicate=True),
         Input("restore-all-constraints-button", "n_clicks"),
-        State("dataframe-store", "data"),
+        State({"type": "dataframe-store", "index": ALL}, "data"),
         prevent_initial_call=True,
     )
-    def restore_all_constraints(_, previous_df):
+    def restore_all_constraints(_, list_previous_df_tuples):
         nonlocal pep_builder
-        df_updated = pd.DataFrame(previous_df)
         pep_builder.relaxed_constraints = []
-        df_updated["constraint"] = "active"
-        order = context.order_of_point(pep_builder.functions[0])
-        return processed_df_to_fig(df_updated, order), df_updated.to_dict("records")
+        updated_figs = []
+        df_data = []
+        for previous_df_tuple in list_previous_df_tuples:
+            tag, previous_df = previous_df_tuple
+            df_updated = pd.DataFrame(previous_df)
+            df_updated["constraint"] = "active"
+            order = context.order_of_point(pep_builder.get_func_by_tag(tag))
+            updated_figs.append(processed_df_to_fig(df_updated, order))
+            df_data.append((tag, df_updated.to_dict("records")))
+        return updated_figs, df_data
 
     @dash.callback(
-        Output("interactive-scatter", "figure", allow_duplicate=True),
-        Output("dataframe-store", "data", allow_duplicate=True),
+        Output(
+            {"type": "interactive-scatter", "index": ALL},
+            "figure",
+            allow_duplicate=True,
+        ),
+        Output({"type": "dataframe-store", "index": ALL}, "data", allow_duplicate=True),
         Input("relax-all-constraints-button", "n_clicks"),
-        State("dataframe-store", "data"),
+        State({"type": "dataframe-store", "index": ALL}, "data"),
         prevent_initial_call=True,
     )
-    def relax_all_constraints(_, previous_df):
+    def relax_all_constraints(_, list_previous_df_tuples):
         nonlocal pep_builder
-        df_updated = pd.DataFrame(previous_df)
-        pep_builder.relaxed_constraints = df_updated["constraint_name"].to_list()
-        df_updated["constraint"] = "inactive"
-        order = context.order_of_point(pep_builder.functions[0])
-        return processed_df_to_fig(df_updated, order), df_updated.to_dict("records")
+        pep_builder.relaxed_constraints = []
+        updated_figs = []
+        df_data = []
+        for previous_df_tuple in list_previous_df_tuples:
+            tag, previous_df = previous_df_tuple
+            df_updated = pd.DataFrame(previous_df)
+            pep_builder.relaxed_constraints.extend(
+                df_updated["constraint_name"].to_list()
+            )
+            df_updated["constraint"] = "inactive"
+            order = context.order_of_point(pep_builder.get_func_by_tag(tag))
+            updated_figs.append(processed_df_to_fig(df_updated, order))
+            df_data.append((tag, df_updated.to_dict("records")))
+        return updated_figs, df_data
 
     @dash.callback(
-        Output("interactive-scatter", "figure", allow_duplicate=True),
-        Output("dataframe-store", "data", allow_duplicate=True),
-        Input("interactive-scatter", "clickData"),
-        State("dataframe-store", "data"),
+        Output(
+            {"type": "interactive-scatter", "index": MATCH},
+            "figure",
+            allow_duplicate=True,
+        ),
+        Output(
+            {"type": "dataframe-store", "index": MATCH}, "data", allow_duplicate=True
+        ),
+        Input({"type": "interactive-scatter", "index": MATCH}, "clickData"),
+        State({"type": "dataframe-store", "index": MATCH}, "data"),
         prevent_initial_call=True,
     )
-    def update_df_and_redraw(clickData, previous_df):
+    def update_df_and_redraw(clickData, previous_df_tuple):
         nonlocal pep_builder
         if not clickData["points"][0]["customdata"]:
-            return dash.no_update, dash.no_update, dash.no_update
+            return dash.no_update, dash.no_update
 
         clicked_name = clickData["points"][0]["customdata"][0]
         if clicked_name not in pep_builder.relaxed_constraints:
@@ -254,11 +340,15 @@ def launch(pep_builder: PEPBuilder, context: PEPContext):
         else:
             pep_builder.relaxed_constraints.remove(clicked_name)
 
+        tag, previous_df = previous_df_tuple
         df_updated = pd.DataFrame(previous_df)
         df_updated["constraint"] = df_updated.constraint_name.map(
             lambda x: "inactive" if x in pep_builder.relaxed_constraints else "active"
         )
-        order = context.order_of_point(pep_builder.functions[0])
-        return processed_df_to_fig(df_updated, order), df_updated.to_dict("records")
+        order = context.order_of_point(pep_builder.get_func_by_tag(tag))
+        return processed_df_to_fig(df_updated, order), (
+            tag,
+            df_updated.to_dict("records"),
+        )
 
     app.run(debug=True)

pepflow/pep.py

@@ -87,6 +87,13 @@ class PEPBuilder:
         # We should think about a better choice like manager.
         self.relaxed_constraints = []
 
+    def clear_setup(self):
+        self.init_conditions.clear()
+        self.functions.clear()
+        self.interpolation_constraints.clear()
+        self.performance_metric = None
+        self.relaxed_constraints.clear()
+
     @contextlib.contextmanager
     def make_context(
         self, name: str, override: bool = False
@@ -94,7 +101,8 @@ class PEPBuilder:
         if not override and name in self.pep_context_dict:
             raise KeyError(f"There is already a context {name} in the builder")
         try:
-            ctx = pc.PEPContext()
+            self.clear_setup()
+            ctx = pc.PEPContext(name)
             self.pep_context_dict[name] = ctx
             pc.set_current_context(ctx)
             yield ctx
@@ -130,11 +138,19 @@ class PEPBuilder:
     def set_relaxed_constraints(self, relaxed_constraints: list[str]):
         self.relaxed_constraints.extend(relaxed_constraints)
 
-    def declare_func(self, function_class, **kwargs):
+    def declare_func(self, function_class: type[Function], tag: str, **kwargs):
         func = function_class(is_basis=True, composition=None, **kwargs)
+        func.add_tag(tag)
         self.functions.append(func)
         return func
 
+    def get_func_by_tag(self, tag: str):
+        # TODO: Add support to return composite functions as well. Right now we can only return base functions
+        for f in self.functions:
+            if tag in f.tags:
+                return f
+        raise ValueError("Cannot find the function of given tag.")
+
     def solve(self, context: pc.PEPContext | None = None, **kwargs):
         if context is None:
             context = pc.get_current_context()
@@ -144,7 +160,6 @@ class PEPBuilder:
         all_constraints: list[Constraint] = [*self.init_conditions]
         for f in self.functions:
             all_constraints.extend(f.get_interpolation_constraints())
-            all_constraints.extend(context.opt_conditions[f])
 
         # for now, we heavily rely on the CVX. We can make a wrapper class to avoid
         # direct dependency in the future.

pepflow/pep_context.py

@@ -26,13 +26,14 @@ import natsort
 import pandas as pd
 
 if TYPE_CHECKING:
-    from pepflow.constraint import Constraint
     from pepflow.function import Function, Triplet
     from pepflow.point import Point
     from pepflow.scalar import Scalar
 
 # A global variable for storing the current context that is used for points or scalars.
 CURRENT_CONTEXT: PEPContext | None = None
+# Keep the track of all previous created context
+GLOBAL_CONTEXT_DICT: dict[str, PEPContext] = {}
 
 
 def get_current_context() -> PEPContext | None:
@@ -46,11 +47,15 @@ def set_current_context(ctx: PEPContext | None):
 
 
 class PEPContext:
-    def __init__(self):
+    def __init__(self, name: str):
+        self.name = name
         self.points: list[Point] = []
         self.scalars: list[Scalar] = []
         self.triplets: dict[Function, list[Triplet]] = defaultdict(list)
-        self.opt_conditions: dict[Function, list[Constraint]] = defaultdict(list)
+        # self.triplets will contain all stationary_triplets. They are not mutually exclusive.
+        self.stationary_triplets: dict[Function, list[Triplet]] = defaultdict(list)
+
+        GLOBAL_CONTEXT_DICT[name] = self
 
     def set_as_current(self) -> PEPContext:
         set_current_context(self)
@@ -65,8 +70,8 @@ class PEPContext:
     def add_triplet(self, function: Function, triplet: Triplet):
         self.triplets[function].append(triplet)
 
-    def add_opt_condition(self, function: Function, opt_condition: Constraint):
-        self.opt_conditions[function].append(opt_condition)
+    def add_stationary_triplet(self, function: Function, stationary_triplet: Triplet):
+        self.stationary_triplets[function].append(stationary_triplet)
 
     def get_by_tag(self, tag: str) -> Point | Scalar:
         for p in self.points:
@@ -75,13 +80,13 @@ class PEPContext:
         for s in self.scalars:
             if tag in s.tags:
                 return s
-        raise ValueError("Cannot find the point or scalar of given tag")
+        raise ValueError("Cannot find the point, scalar, or function of given tag.")
 
     def clear(self):
         self.points.clear()
         self.scalars.clear()
         self.triplets.clear()
-        self.opt_conditions.clear()
+        self.stationary_triplets.clear()
 
     def tracked_point(self, func: Function) -> list[Point]:
         return natsort.natsorted(

pepflow/pep_context_test.py

@@ -17,17 +17,25 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from typing import Iterator
+
 import pandas as pd
+import pytest
 
 from pepflow import pep_context as pc
 from pepflow.function import SmoothConvexFunction
 from pepflow.point import Point
 
 
-def test_tracked_points():
-    ctx = pc.PEPContext()
-    pc.set_current_context(ctx)
+@pytest.fixture
+def pep_context() -> Iterator[pc.PEPContext]:
+    """Prepare the pep context and reset the context to None at the end."""
+    ctx = pc.PEPContext("test").set_as_current()
+    yield ctx
+    pc.set_current_context(None)
+
 
+def test_tracked_points(pep_context: pc.PEPContext):
     f = SmoothConvexFunction(L=1, is_basis=True)
     f.add_tag("f")
 
@@ -41,16 +49,11 @@ def test_tracked_points():
     _ = f.generate_triplet(p3)
     _ = f.generate_triplet(p_star)
 
-    assert ctx.order_of_point(f) == ["x_1", "x_2", "x_3", "x_*"]
-    assert ctx.tracked_point(f) == [p1, p3, p2, p_star]
-
-    pc.set_current_context(None)
-
+    assert pep_context.order_of_point(f) == ["x_1", "x_2", "x_3", "x_*"]
+    assert pep_context.tracked_point(f) == [p1, p3, p2, p_star]
 
-def test_triplets_to_dataframe():
-    ctx = pc.PEPContext()
-    pc.set_current_context(ctx)
 
+def test_triplets_to_dataframe(pep_context: pc.PEPContext):
     f = SmoothConvexFunction(L=1, is_basis=True)
     f.add_tag("f")
 
@@ -62,7 +65,7 @@ def test_triplets_to_dataframe():
     _ = f.generate_triplet(p2)
     _ = f.generate_triplet(p3)
 
-    func_to_df, func_to_order = ctx.triplets_to_df_and_order()
+    func_to_df, func_to_order = pep_context.triplets_to_df_and_order()
     expected_df = pd.DataFrame(
         {
             "constraint_name": [
@@ -83,20 +86,19 @@ def test_triplets_to_dataframe():
     pd.testing.assert_frame_equal(func_to_df[f], expected_df)
     assert func_to_order[f] == ["x1", "x2", "x3"]
 
-    pc.set_current_context(None)
-
-
-def test_get_by_tag():
-    ctx = pc.PEPContext()
-    pc.set_current_context(ctx)
 
+def test_get_by_tag(pep_context: pc.PEPContext):
     f = SmoothConvexFunction(L=1, is_basis=True)
     f.add_tag("f")
     p1 = Point(is_basis=True, tags=["x1"])
+    p2 = Point(is_basis=True, tags=["x2"])
+    p3 = p1 + p2
 
     triplet = f.generate_triplet(p1)
+    _ = f.generate_triplet(p2)
 
-    assert ctx.get_by_tag("x1") == p1
-    assert ctx.get_by_tag("f(x1)") == triplet.function_value
-    assert ctx.get_by_tag("gradient_f(x1)") == triplet.gradient
+    assert pep_context.get_by_tag("x1") == p1
+    assert pep_context.get_by_tag("f(x1)") == triplet.function_value
+    assert pep_context.get_by_tag("gradient_f(x1)") == triplet.gradient
+    assert pep_context.get_by_tag("x1+x2") == p3
     pc.set_current_context(None)

pepflow/pep_test.py

@@ -19,6 +19,7 @@
 
 import pytest
 
+from pepflow import function as fc
 from pepflow import pep
 from pepflow import pep_context as pc
 
@@ -75,3 +76,10 @@ class TestPEPBuilder:
 
         with builder.make_context("test", override=True):
             pass
+
+    def test_get_func_by_tag(self) -> None:
+        builder = pep.PEPBuilder()
+        with builder.make_context("test"):
+            f = builder.declare_func(fc.SmoothConvexFunction, "f", L=1)
+
+            assert builder.get_func_by_tag("f") == f

pepflow/point.py

@@ -134,75 +134,110 @@ class Point:
             return self.tag
         return super().__repr__()
 
+    def _repr_latex_(self):
+        s = repr(self)
+        s = s.replace("star", r"\star")
+        s = s.replace("gradient_", r"\nabla ")
+        s = s.replace("|", r"\|")
+        return rf"$\\displaystyle {s}$"
+
     # TODO: add a validator that `is_basis` and `eval_expression` are properly setup.
     def __add__(self, other):
-        assert is_numerical_or_point(other)
+        assert isinstance(other, Point)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.ADD, self, other),
+            tags=[f"{self.tag}+{other.tag}"],
         )
 
     def __radd__(self, other):
-        assert is_numerical_or_point(other)
+        # TODO: come up with better way to handle this
+        if other == 0:
+            return self
+        assert isinstance(other, Point)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.ADD, other, self),
+            tags=[f"{other.tag}+{self.tag}"],
         )
 
     def __sub__(self, other):
-        assert is_numerical_or_point(other)
+        assert isinstance(other, Point)
+        tag_other = utils.parenthesize_tag(other)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.SUB, self, other),
+            tags=[f"{self.tag}-{tag_other}"],
         )
 
     def __rsub__(self, other):
-        assert is_numerical_or_point(other)
+        assert isinstance(other, Point)
+        tag_self = utils.parenthesize_tag(self)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.SUB, other, self),
+            tags=[f"{other.tag}-{tag_self}"],
         )
 
     def __mul__(self, other):
         # TODO allow the other to be point so that we return a scalar.
         assert is_numerical_or_point(other)
+        tag_self = utils.parenthesize_tag(self)
         if utils.is_numerical(other):
             return Point(
                 is_basis=False,
                 eval_expression=EvalExpressionPoint(utils.Op.MUL, self, other),
+                tags=[f"{tag_self}*{other:.4g}"],
             )
         else:
+            tag_other = utils.parenthesize_tag(other)
             return Scalar(
                 is_basis=False,
-                eval_expression=EvalExpressionScalar(utils.Op.MUL, self, other),  # TODO
+                eval_expression=EvalExpressionScalar(utils.Op.MUL, self, other),
+                tags=[f"{tag_self}*{tag_other}"],
             )
 
     def __rmul__(self, other):
         # TODO allow the other to be point so that we return a scalar.
         assert is_numerical_or_point(other)
+        tag_self = utils.parenthesize_tag(self)
         if utils.is_numerical(other):
             return Point(
                 is_basis=False,
                 eval_expression=EvalExpressionPoint(utils.Op.MUL, other, self),
+                tags=[f"{other:.4g}*{tag_self}"],
             )
         else:
+            tag_other = utils.parenthesize_tag(other)
             return Scalar(
                 is_basis=False,
-                eval_expression=EvalExpressionScalar(utils.Op.MUL, other, self),  # TODO
+                eval_expression=EvalExpressionScalar(utils.Op.MUL, other, self),
+                tags=[f"{tag_other}*{tag_self}"],
             )
 
     def __pow__(self, power):
         assert power == 2
-        return self.__rmul__(self)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.MUL, self, self),
+            tags=[rf"|{self.tag}|^{power}"],
+        )
 
     def __neg__(self):
-        return self.__rmul__(other=-1)
+        tag_self = utils.parenthesize_tag(self)
+        return Point(
+            is_basis=False,
+            eval_expression=EvalExpressionPoint(utils.Op.MUL, -1, self),
+            tags=[f"-{tag_self}"],
+        )
 
     def __truediv__(self, other):
         assert utils.is_numerical(other)
+        tag_self = utils.parenthesize_tag(self)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.DIV, self, other),
+            tags=[f"1/{other:.4g}*{tag_self}"],
         )
 
     def __hash__(self):