pyomo__pyomo-3017

The user is reporting a `KeyError` when using Pyomo AD (`differentiate`) with `Expression` components that have a constant value.

The traceback points to:
- `pyomo/common/collections/component_map.py`, line 71 (and 73) in `__getitem__`
- `pyomo/core/expr/calculus/diff_with_pyomo.py`, line 331 in `_diff_GeneralExpression`: `der_dict[node.expr] += der_dict[node]`
- `pyomo/core/expr/calculus/diff_with_pyomo.py`, line 442 in `_reverse_diff_helper`
- `pyomo/core/expr/calculus/diff_with_pyomo.py`, line 484 in `reverse_sd`
- `pyomo/core/expr/calculus/derivatives.py`, line 96 in `differentiate`

The problematic code in the reproduction script:
```python
import pyomo.environ as pyo
from pyomo.core.expr.calculus.derivatives import Modes, differentiate

m = pyo.ConcreteModel()
m.x = pyo.Var(units=pyo.units.mol, initialize=0)

@m.Expression()
def y(blk):
    return 2

@m.Expression()
def product(blk):
    return blk.x * blk.y

diff_expr = differentiate(
                expr=m.product,
                wrt=m.x,
                mode=Modes.reverse_symbolic
            )
diff_expr.pprint()
```

The `KeyError` occurs in `ComponentMap.__getitem__` when trying to retrieve an object by its ID. The error message is `"Component with id '1907001786672': 2.0"`. This suggests that a float (2.0) is being used as a key or searched for in a `ComponentMap`, which expects Pyomo components.

Let's start by reproducing the issue.

{
  "command": "python3 - <<'PY'\nimport pyomo.environ as pyo\nfrom pyomo.core.expr.calculus.derivatives import Modes, differentiate\n\nm = pyo.ConcreteModel()\n\nm.x = pyo.Var(units=pyo.units.mol, initialize=0)\n\n@m.Expression()\ndef y(blk):\n    return 2\n\n@m.Expression()\ndef product(blk):\n    return blk.x * blk.y\n\ntry:\n    diff_expr = differentiate(\n                    expr=m.product,\n                    wrt=m.x,\n                    mode=Modes.reverse_symbolic\n                )\n    diff_expr.pprint()\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, in <module>\n  File \"/workspace/pyomo/core/base/units_container.py\", line 1532, in __getattribute__\n    return getattr(pint_module, attr)\n  File \"/workspace/pyomo/common/dependencies.py\", line 75, in __getattr__\n    raise DeferredImportError(self._moduleunavailable_message())\npyomo.common.errors.DeferredImportError: The \"pint\" package failed to import. This package is necessary to use Pyomo units. (import raised ModuleNotFoundError: No module named 'pint')\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, in <module>\n  File \"/workspace/pyomo/core/base/units_container.py\", line 1532, in __getattribute__\n    return getattr(pint_module, attr)\n  File \"/workspace/pyomo/common/dependencies.py\", line 75, in __getattr__\n    raise DeferredImportError(self._moduleunavailable_message())\npyomo.common.errors.DeferredImportError: The \"pint\" package failed to import. This package is necessary to use Pyomo units. (import raised ModuleNotFoundError: No module named 'pint')\n",
    "exit_code": 1
  }
}

The reproduction script failed because of `DeferredImportError: The "pint" package failed to import`. This is because I used `units=pyo.units.mol` in `pyo.Var`. I should remove the `units` argument to avoid the dependency on `pint`.

Let's try again.

{
  "command": "python3 - <<'PY'\nimport pyomo.environ as pyo\nfrom pyomo.core.expr.calculus.derivatives import Modes, differentiate\n\nm = pyo.ConcreteModel()\n\nm.x = pyo.Var(initialize=0)\n\n@m.Expression()\ndef y(blk):\n    return 2\n\n@m.Expression()\ndef product(blk):\n    return blk.x * blk.y\n\ntry:\n    diff_expr = differentiate(\n                    expr=m.product,\n                    wrt=m.x,\n                    mode=Modes.reverse_symbolic\n                )\n    diff_expr.pprint()\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"/workspace/pyomo/common/collections/component_map.py\", line 71, in __getitem__\n    return self._dict[id(obj)][1]\nKeyError: 139489287905936\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n  File \"<stdin>\", line 17, in <module>\n  File \"/workspace/pyomo/core/expr/calculus/derivatives.py\", line 96, in differentiate\n    res = reverse_sd(expr=expr)\n  File \"/workspace/pyomo/core/expr/calculus/diff_with_pyomo.py\", line 484, in reverse_sd\n    return _reverse_diff_helper(expr, False)\n  File \"/workspace/pyomo/core/expr/calculus/diff_with_pyomo.py\", line 442, in _reverse_diff_helper\n    _diff_GeneralExpression(e, val_dict, der_dict)\n  File \"/workspace/pyomo/core/expr/calculus/diff_with_pyomo.py\", line 331, in _diff_GeneralExpression\n    der_dict[node.expr] += der_dict[node]\n  File \"/workspace/pyomo/common/collections/component_map.py\", line 73, in __getitem__\n    raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\nKeyError: \"Component with id '139489287905936': 2.0\"\n",
  "exit_code": 0
}

Reproduction successful.
The error is `KeyError: "Component with id '139489287905936': 2.0"`.
This happened at `pyomo/core/expr/calculus/diff_with_pyomo.py`, line 331, in `_diff_GeneralExpression`:
`der_dict[node.expr] += der_dict[node]`

Wait, I should check what `node` is. In this context, `node` is likely a `GeneralExpression` and `node.expr` is its evaluation. If the `Expression` is constant, `node.expr` might be a float.

Let's examine `pyomo/core/expr/calculus/diff_with_pyomo.py` around line 331.

{
  "end_line": 350,
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "start_line": 310
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    if node.getname() in _unary_map:\n        _unary_map[node.getname()](node, val_dict, der_dict)\n    else:\n        raise DifferentiationException(\n            'Unsupported expression type for differentiation: {0}'.format(type(node))\n        )\n\n\ndef _diff_GeneralExpression(node, val_dict, der_dict):\n    \"\"\"\n    Reverse automatic differentiation for named expressions.\n\n    Parameters\n    ----------\n    node: The named expression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der_dict[node.expr] += der_dict[node]\n\n\ndef _diff_ExternalFunctionExpression(node, val_dict, der_dict):\n    \"\"\"\n\n    Parameters\n    ----------\n    node: pyomo.core.expr.numeric_expr.ExternalFunctionExpression\n    val_dict: ComponentMap\n    der_dict: ComponentMap\n    \"\"\"\n    der = der_dict[node]\n    vals = tuple(val_dict[i] for i in node.args)\n    derivs = node._fcn.evaluate_fgh(vals, fgh=1)[1]\n    for ndx, arg in enumerate(node.args):\n        der_dict[arg] += der * derivs[ndx]\n\n\n_diff_map = dict()",
  "start_line": 310,
  "end_line": 350,
  "total_lines": 484,
  "is_truncated": false
}

The line is indeed `der_dict[node.expr] += der_dict[node]`.
`der_dict` is a `ComponentMap`.
According to the traceback and Pyomo's typical usage, `ComponentMap` is used to map Pyomo components to values.
If `node` is a `GeneralExpression`, `node.expr` is the Pyomo expression it represents.
In the reproduction case, `y` is an `Expression` that returns `2`.
When `product` (which is `x * y`) is differentiated, `y` (the `GeneralExpression`) is encountered.
`node` is the `GeneralExpression` for `y`.
`node.expr` is the result of evaluating `y`, which is `2` (a float).
`der_dict` is a `ComponentMap`.
`der_dict[node.expr]` tries to access the value for key `2.0` in the `ComponentMap`.
Since `2.0` is not a Pyomo component, `ComponentMap` raises a `KeyError`.

`ComponentMap` is defined in `pyomo/common/collections/component_map.py`. Let's see how it handles keys.

{
  "filepath": "pyomo/common/collections/component_map.py"
}

{
  "status": "ok",
  "filepath": "pyomo/common/collections/component_map.py",
  "content": "#  ___________________________________________________________________________\n#\n#  Pyomo: Python Optimization Modeling Objects\n#  Copyright (c) 2008-2022\n#  National Technology and Engineering Solutions of Sandia, LLC\n#  Under the terms of Contract DE-NA0003525 with National Technology and\n#  Engineering Solutions of Sandia, LLC, the U.S. Government retains certain\n#  rights in this software.\n#  This software is distributed under the 3-clause BSD License.\n#  ___________________________________________________________________________\n\nfrom collections.abc import MutableMapping as collections_MutableMapping\nfrom collections.abc import Mapping as collections_Mapping\nfrom pyomo.common.autoslots import AutoSlots\n\n\ndef _rebuild_ids(encode, val):\n    if encode:\n        return val\n    else:\n        # object id() may have changed after unpickling,\n        # so we rebuild the dictionary keys\n        return {id(obj): (obj, v) for obj, v in val.values()}\n\n\nclass ComponentMap(AutoSlots.Mixin, collections_MutableMapping):\n    \"\"\"\n    This class is a replacement for dict that allows Pyomo\n    modeling components to be used as entry keys. The\n    underlying mapping is based on the Python id() of the\n    object, which gets around the problem of hashing\n    subclasses of NumericValue. This class is meant for\n    creating mappings from Pyomo components to values. The\n    use of non-Pyomo components as entry keys should be\n    avoided.\n\n    A reference to the object is kept around as long as it\n    has a corresponding entry in the container, so there is\n    no need to worry about id() clashes.\n\n    We also override __setstate__ so that we can rebuild the\n    container based on possibly updated object ids after\n    a deepcopy or pickle.\n\n    *** An instance of this class should never be\n    deepcopied/pickled unless it is done so along with the\n    components for which it contains map entries (e.g., as\n    part of a block). ***\n    \"\"\"\n\n    __slots__ = (\"_dict\",)\n    __autoslot_mappers__ = {'_dict': _rebuild_ids}\n\n    def __init__(self, *args, **kwds):\n        # maps id(obj) -> (obj,val)\n        self._dict = {}\n        # handle the dict-style initialization scenarios\n        self.update(*args, **kwds)\n\n    def __str__(self):\n        \"\"\"String representation of the mapping.\"\"\"\n        tmp = {str(c) + \" (id=\" + str(id(c)) + \")\": v for c, v in self.items()}\n        return \"ComponentMap(\" + str(tmp) + \")\"\n\n    #\n    # Implement MutableMapping abstract methods\n    #\n\n    def __getitem__(self, obj):\n        try:\n            return self._dict[id(obj)][1]\n        except KeyError:\n            raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\n\n    def __setitem__(self, obj, val):\n        self._dict[id(obj)] = (obj, val)\n\n    def __delitem__(self, obj):\n        try:\n            del self._dict[id(obj)]\n        except KeyError:\n            raise KeyError(\"Component with id '%s': %s\" % (id(obj), str(obj)))\n\n    def __iter__(self):\n        return (obj for obj, val in self._dict.values())\n\n    def __len__(self):\n        return self._dict.__len__()\n\n    #\n    # Overload MutableMapping default implementations\n    #\n\n    # We want to avoid generating Pyomo expressions due to\n    # comparison of values, so we convert both objects to a\n    # plain dictionary mapping key->(type(val), id(val)) and\n    # compare that instead.\n    def __eq__(self, other):\n        if not isinstance(other, collections_Mapping):\n            return False\n        return {(type(key), id(key)): val for key, val in self.items()} == {\n            (type(key), id(key)): val for key, val in other.items()\n        }\n\n    def __ne__(self, other):\n        return not (self == other)\n\n    #\n    # The remaining methods have slow default\n    # implementations for MutableMapping. In particular,\n    # they rely KeyError catching, which is slow for this\n    # class because KeyError messages use fully qualified\n    # names.\n    #\n\n    def __contains__(self, obj):\n        return id(obj) in self._dict\n\n    def clear(self):\n        'D.clear() -> None.  Remove all items from D.'\n        self._dict.clear()\n\n    def get(self, key, default=None):\n        'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'\n        if key in self:\n            return self[key]\n        return default\n\n    def setdefault(self, key, default=None):\n        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'\n        if key in self:\n            return self[key]\n        else:\n            self[key] = default\n        return default",
  "start_line": 1,
  "end_line": 135,
  "total_lines": 135,
  "is_truncated": false
}

`ComponentMap` is specifically designed to use `id(obj)` as the key.
```python
    def __getitem__(self, obj):
        try:
            return self._dict[id(obj)][1]
        except KeyError:
            raise KeyError("Component with id '%s': %s" % (id(obj), str(obj)))
```
This is to avoid hashing problems with `NumericValue` objects.

In `_diff_GeneralExpression`:
```python
def _diff_GeneralExpression(node, val_dict, der_dict):
    """
    Reverse automatic differentiation for named expressions.

    Parameters
    ----------
    node: The named expression
    val_dict: ComponentMap
    der_dict: ComponentMap
    """
    der_dict[node.expr] += der_dict[node]
```
If `node.expr` is a constant (like `2.0`), `der_dict[node.expr]` fails because `node.expr` is not in `der_dict` and it's not a Pyomo component (although `ComponentMap` doesn't explicitly check if it's a component, it just uses `id()`).

Wait, why is `der_dict[node.expr]` accessed?
In reverse mode AD, `der_dict[node]` is the derivative of the objective with respect to `node`.
If `node` is `y`, and `product` is `x * y`, then the derivative of `product` w.r.t `x` involves `y`.
`node.expr` is the actual value/expression of the `GeneralExpression`.

If `node.expr` is a constant, its derivative is 0, and it doesn't depend on any variables. So we shouldn't be adding its derivative to anything.
Wait, `der_dict[node.expr]` is the "incoming" derivative for the expression that `node` represents.

If `node.expr` is a constant, it's not a `Pyomo` component that can be a node in the AD graph (except as a leaf).

Actually, if `node.expr` is a constant, `der_dict[node.expr]` should probably be treated as 0 if it's not in the map, or we should just skip it if it's a constant.

However, `der_dict[node.expr] += der_dict[node]` is doing an addition.
If `der_dict[node.expr]` doesn't exist, it should probably be initialized to 0.
But the problem is that `der_dict` is a `ComponentMap`, and `component_map.py`'s `__getitem__` raises `KeyError` if the key is not found. It does NOT return a default value.

Normally, a `defaultdict` would be used here. But `ComponentMap` is not a `defaultdict`.

If `node.expr` is a constant, it's not something we care about in the `der_dict` (which tracks derivatives w.r.t variables/expressions).

Let's see if we can change `_diff_GeneralExpression` to handle the case where `node.expr` is not in `der_dict` or is a constant.

If `node.expr` is a constant, `der_dict[node.expr]` will always fail because constants aren't tracked in `der_dict`.

Wait, if `node.expr` is a Pyomo expression (not a constant), it should be in `der_dict` if it's part of the graph.

Looking at `_diff_GeneralExpression`:
```python
def _diff_GeneralExpression(node, val_dict, der_dict):
    der_dict[node.expr] += der_dict[node]
```
`node` is the `GeneralExpression` object. `node.expr` is the expression it evaluates to.
If `node` is `y` and `y` is `2`, then `node.expr` is `2`.
`der_dict[node]` is the derivative of the result with respect to `y`.
Since `y` is a constant, the derivative of the result w.r.t `y` is not useful for the final result (which is w.r.t `x`), but in reverse mode, we propagate it.

However, if `node.expr` is a constant, then adding `der_dict[node]` to `der_dict[node.expr]` is meaningless because a constant doesn't have a derivative.

If `node.expr` is NOT a constant, it's a Pyomo expression. It might be a variable or another complex expression.

The issue is that `der_dict` is a `ComponentMap`. If `node.expr` is a constant, we are trying to use a float as a key in `ComponentMap`.

If we check if `node.expr` is a constant, we can avoid the `KeyError`.

How to check if something is a constant in Pyomo expressions?
Typically, constants are `float`, `int`, or Pyomo `Constant` objects.

Actually, if `node.expr` is not in `der_dict`, should we just ignore it?
In reverse mode AD, if we reach a leaf that is a constant, we just stop.

Let's see other `_diff_*` functions in `diff_with_pyomo.py` to see how they handle `der_dict`.

{
  "end_line": 484,
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "start_line": 350
}

{
  "status": "ok",
  "filepath": "pyomo/core/expr/calculus/diff_with_pyomo.py",
  "content": "_diff_map = dict()\n_diff_map[_expr.ProductExpression] = _diff_ProductExpression\n_diff_map[_expr.DivisionExpression] = _diff_DivisionExpression\n_diff_map[_expr.PowExpression] = _diff_PowExpression\n_diff_map[_expr.SumExpression] = _diff_SumExpression\n_diff_map[_expr.MonomialTermExpression] = _diff_ProductExpression\n_diff_map[_expr.NegationExpression] = _diff_NegationExpression\n_diff_map[_expr.UnaryFunctionExpression] = _diff_UnaryFunctionExpression\n_diff_map[_expr.ExternalFunctionExpression] = _diff_ExternalFunctionExpression\n_diff_map[_expr.LinearExpression] = _diff_SumExpression\n_diff_map[_expr.AbsExpression] = _diff_abs\n\n_diff_map[_expr.NPV_ProductExpression] = _diff_ProductExpression\n_diff_map[_expr.NPV_DivisionExpression] = _diff_DivisionExpression\n_diff_map[_expr.NPV_PowExpression] = _diff_PowExpression\n_diff_map[_expr.NPV_SumExpression] = _diff_SumExpression\n_diff_map[_expr.NPV_NegationExpression] = _diff_NegationExpression\n_diff_map[_expr.NPV_UnaryFunctionExpression] = _diff_UnaryFunctionExpression\n_diff_map[_expr.NPV_ExternalFunctionExpression] = _diff_ExternalFunctionExpression\n_diff_map[_expr.NPV_AbsExpression] = _diff_abs\n\n\ndef _symbolic_value(x):\n    return x\n\n\ndef _numeric_apply_operation(node, values):\n    return node._apply_operation(values)\n\n\ndef _symbolic_apply_operation(node, values):\n    return node\n\n\nclass _LeafToRootVisitor(ExpressionValueVisitor):\n    def __init__(self, val_dict, der_dict, expr_list, numeric=True):\n        \"\"\"\n        Parameters\n        ----------\n        val_dict: ComponentMap\n        der_dict: ComponentMap\n        \"\"\"\n        self.val_dict = val_dict\n        self.der_dict = der_dict\n        self.expr_list = expr_list\n        assert len(self.expr_list) == 0\n        assert len(self.val_dict) == 0\n        assert len(self.der_dict) == 0\n        if numeric:\n            self.value_func = value\n            self.operation_func = _numeric_apply_operation\n        else:\n            self.value_func = _symbolic_value\n            self.operation_func = _symbolic_apply_operation\n\n    def visit(self, node, values):\n        self.val_dict[node] = self.operation_func(node, values)\n        self.der_dict[node] = 0\n        self.expr_list.append(node)\n        return self.val_dict[node]\n\n    def visiting_potential_leaf(self, node):\n        if node in self.val_dict:\n            return True, self.val_dict[node]\n\n        if node.__class__ in nonpyomo_leaf_types:\n            self.val_dict[node] = node\n            self.der_dict[node] = 0\n            return True, node\n\n        if not node.is_expression_type():\n            val = self.value_func(node)\n            self.val_dict[node] = val\n            self.der_dict[node] = 0\n            return True, val\n\n        return False, None\n\n\ndef _reverse_diff_helper(expr, numeric=True):\n    val_dict = ComponentMap()\n    der_dict = ComponentMap()\n    expr_list = list()\n\n    visitorA = _LeafToRootVisitor(val_dict, der_dict, expr_list, numeric=numeric)\n    visitorA.dfs_postorder_stack(expr)\n\n    der_dict[expr] = 1\n    for e in reversed(expr_list):\n        if e.__class__ in _diff_map:\n            _diff_map[e.__class__](e, val_dict, der_dict)\n        elif e.is_named_expression_type():\n            _diff_GeneralExpression(e, val_dict, der_dict)\n        else:\n            raise DifferentiationException(\n                'Unsupported expression type for differentiation: {0}'.format(type(e))\n            )\n\n    return der_dict\n\n\ndef reverse_ad(expr):\n    \"\"\"\n    First order reverse automatic differentiation\n\n    Parameters\n    ----------\n    expr: pyomo.core.expr.numeric_expr.NumericExpression\n        expression to differentiate\n\n    Returns\n    -------\n    ComponentMap\n        component_map mapping variables to derivatives with respect\n        to the corresponding variable\n    \"\"\"\n    return _reverse_diff_helper(expr, True)\n\n\ndef reverse_sd(expr):\n    \"\"\"\n    First order reverse symbolic differentiation\n\n    Parameters\n    ----------\n    expr: pyomo.core.expr.numeric_expr.NumericExpression\n        expression to differentiate\n\n    Returns\n    -------\n    ComponentMap\n        component_map mapping variables to derivatives with respect\n        to the corresponding variable\n    \"\"\"\n    return _reverse_diff_helper(expr, False)",
  "start_line": 350,
  "end_line": 484,
  "total_lines": 484,
  "is_truncated": false
}

Wait, I see how `der_dict` is initialized.
In `_LeafToRootVisitor.visit`:
```python
    def visit(self, node, values):
        self.val_dict[node] = self.operation_func(node, values)
        self.der_dict[node] = 0
        self.expr_list.append(node)
        return self.val_dict[node]
```
In `_LeafToRootVisitor.visiting_potential_leaf`:
```python
    def visiting_potential_leaf(self, node):
        if node in self.val_dict:
            return True, self.val_dict[node]

        if node.__class__ in nonpyomo_leaf_types:
            self.val_dict[node] = node
            self.der_dict[node] = 0
            return True, node

        if not node.is_expression_type():
            val = self.value_func(node)
            self.val_dict[node] = val
            self.der_dict[node] = 0
            return True, val

        return False, None
```
So all nodes visited by `visitorA` are put into `der_dict` with initial value 0.

`_reverse_diff_helper` then goes through `expr_list` in reverse.
```python
    for e in reversed(expr_list):
        if e.__class__ in _diff_map:
            _diff_map[e.__class__](e, val_dict, der_dict)
        elif e.is_named_expression_type():
            _diff_GeneralExpression(e, val_dict, der_dict)
```

If `e` is a `GeneralExpression`, `_diff_GeneralExpression(e, val_dict, der_dict)` is called.
```python
def _diff_GeneralExpression(node, val_dict, der_dict):
    der_dict[node.expr] += der_dict[node]
```
`node` is the `GeneralExpression` object, which was visited by `visitorA`, so `node` is in `der_dict`.
`node.expr` is the value/expression it evaluates to.
If `node.expr` is a constant, it may or may not be in `der_dict`.
If `node.expr` is a constant, `visitorA` might have encountered it as a leaf.

Wait, if `node.expr` was encountered as a leaf, it would be added to `val_dict` and `der_dict`.
Let's see `_LeafToRootVisitor.visit` again.
The `visit` method is called for nodes.

In the case of `y(blk): return 2`.
`y` is a `GeneralExpression`. Its `expr` attribute is `2`.
When `visitorA` visits the `product` (`x * y`), it sees `x` and `y`.
`y` is a `GeneralExpression`. `visitorA.visit(y, ...)` is called.
`self.val_dict[y] = self.operation_func(y, values)`.
`self.operation_func` is `_symbolic_apply_operation` (since `numeric=False` for `reverse_sd`).
`_symbolic_apply_operation(node, values)` returns `node`.
Wait, if `numeric=False`, then `self.operation_func` returns the node itself.

Let's re-read `_symbolic_apply_operation`:
```python
def _symbolic_apply_operation(node, values):
    return node
```
Wait, no. `_diff_GeneralExpression` uses `node.expr`.
Where does `node.expr` come from?
`node` is a `GeneralExpression`. A `GeneralExpression` in Pyomo typically has an `expr` attribute which is the actual expression it evaluates to.

If `node` is a `GeneralExpression`, then `node.expr` is the inner expression.
If `y` is an `Expression` that returns `2`, then `y.expr` should be `2`.

When `visitorA` visits `product (x * y)`, it's a `ProductExpression`.
Its arguments are `x` and `y`.
`visitorA` visits `x` and `y`.
If `y` is a `GeneralExpression`, `visitorA` treats it as a node.
But does `visitorA` visit the internal `node.expr` of `GeneralExpression`?
`GeneralExpression` probably doesn't have a visitor-compatible structure that allows visiting its `expr` attribute automatically, or `visitorA` doesn't.

Wait, `_LeafToRootVisitor` is an `ExpressionValueVisitor`.
Let's see `ExpressionValueVisitor`... wait, I don't have the source for that. It's probably in `pyomo/core/expr/`.

The key is that `node.expr` is used in `_diff_GeneralExpression`.
If `node.expr` is a constant, it might not have been visited by `visitorA` as a separate node, or it was visited but not as a Pyomo component.

If `node.expr` is `2` (a float), `visitorA.visiting_potential_leaf(2)` would be called if the visitor encountered the float `2`.
```python
    def visiting_potential_leaf(self, node):
        if node in self.val_dict:
            return True, self.val_dict[node]

        if node.__class__ in nonpyomo_leaf_types:
            self.val_dict[node] = node
            self.der_dict[node] = 0
            return True, node
        ...
```
If `nonpyomo_leaf_types` includes `float`, then `2` is added to `der_dict`.
But `ComponentMap` doesn't like floats as keys!
Wait, if `node.__class__ in nonpyomo_leaf_types`, then `self.der_dict[node] = 0` is called.
`self.der_dict` is a `ComponentMap`.
If `node` is `2.0`, then `self.der_dict[2.0] = 0` is called.
`ComponentMap.__setitem__` does: `self._dict[id(obj)] = (obj, val)`.
This works for any object, including floats.

So why does `der_dict[node.expr] += der_dict[node]` fail?
It fails if `node.expr` is not in `der_dict`.
If `node.expr` is `2.0`, and it was not encountered as a leaf during `visitorA`'s traversal, it won't be in `der_dict`.

In the reproduction case:
`product = x * y`.
`visitorA` visits `product`, then `x`, then `y`.
`y` is a `GeneralExpression`.
Does `visitorA` visit `y.expr`?
If `GeneralExpression` is just treated as a leaf by `visitorA`, then `y.expr` is never visited.
Then `der_dict` contains `product`, `x`, and `y`. It does NOT contain `2.0`.
Then `_diff_GeneralExpression(y, ...)` is called.
It tries `der_dict[y.expr] += der_dict[y]`.
`y.expr` is `2.0`. `2.0` is not in `der_dict`.
`ComponentMap.__getitem__(2.0)` is called, and it raises `KeyError`.

So the fix should be to handle the case where `node.expr` is not in `der_dict`.
Since it's reverse AD, if `node.expr` is a constant (and thus not in `der_dict`), we can't propagate the derivative further back to any variables (because constants don't depend on variables). So we can just ignore it.

However, we should also consider if `node.expr` is an expression that should be in `der_dict`.
If `node.expr` is a Pyomo expression, it should have been visited by `visitorA`.
But `GeneralExpression` seems to hide its inner expression from `visitorA`.

Wait, if `node.expr` is a `Pyomo` expression, it should also be handled.
The issue is specifically with constant expressions.

If `node.expr` is not in `der_dict`, and it's a constant, we are fine ignoring it.
If `node.expr` is a complex expression, should it be in `der_dict`?
If `visitorA` didn't visit it, then it's because it's encapsulated inside `GeneralExpression`.

Let's see if we can just use `der_dict.get(node.expr, 0)` or check if it's in `der_dict`.
But wait, `der_dict[node.expr] += der_dict[node]` is an assignment.
If `node.expr` is not in `der_dict`, should we add it?
If `node.expr` is a variable, yes.
If `node.expr` is another expression, yes.
If `node.expr` is a constant, no.

Actually, in reverse AD, we only care about the derivatives w.r.t. the variables.
If `node.expr` is a constant, it doesn't contribute to the gradient w.r.t. variables.

So, we can check if `node.expr` is in `der_dict` before adding.
Or, even better, check if `node.expr` is a constant.

Wait, Pyomo's `ComponentMap` is used specifically to avoid issues with `NumericValue` objects.
If `node.expr` is not in `der_dict`, it means it's either a constant or something that `visitorA` didn't visit.

If we change:
`der_dict[node.expr] += der_dict[node]`
to:
```python
    if node.expr in der_dict:
        der_dict[node.expr] += der_dict[node]
```
Would that be correct?
If `node.expr` is a variable, `visitorA` would have visited it, so it would be in `der_dict`.
If `node.expr` is a constant, it might not be in `der_dict`, and we don't want to add it (as it won't lead to any variable).

Let's test this hypothesis.

Wait, I should also check if `node.expr` can be another `GeneralExpression`.
If `node.expr` is another `GeneralExpression`, it should be in `der_dict`.

Let's try to reproduce it again and see if just adding a check `if node.expr in der_dict` fixes it.

Wait, if `node.expr` is a constant, and we just ignore it, we avoid the `KeyError`. Since constants don't depend on variables, this shouldn't affect the final derivatives w.r.t variables.

Let's verify this with a simple test.

But before that, let's see what `node.expr` can be.
`GeneralExpression` is used for `Expression` components.
The user's example:
```python
@m.Expression()
def y(blk):
    return 2
```
Here `m.y` is a `GeneralExpression`. `m.y.expr` is `2`.

Another case:
```python
@m.Expression()
def y(blk):
    return blk.x + 1
```
Here `m.y.expr` is `x + 1` (a `SumExpression`).
When `visitorA` visits `product = x * y`, it visits `x` and `y`.
It doesn't visit `x + 1` because it's inside `y`.
But then `_diff_GeneralExpression` is called for `y`.
It does `der_dict[y.expr] += der_dict[y]`.
`y.expr` is `x + 1`.
Is `x + 1` in `der_dict`?
No, because `visitorA` only visited `product`, `x`, and `y`.
So if we only do `if node.expr in der_dict`, we will miss the derivative propagation into `y.expr`!

This means we might need to recursively differentiate `node.expr` or make sure `node.expr` is also visited.

Wait, if `node` is a `GeneralExpression`, the AD should probably treat it as a transparent wrapper if we want to differentiate through it.

However, `GeneralExpression` is a component.

Let's look at how other AD systems handle this.
Actually, the issue reported is that it *fails* with constant Expressions.
If it's a constant expression, `node.expr` is just a value.
If it's a non-constant expression, `node.expr` is a Pyomo expression.

If `node.expr` is a Pyomo expression, it should be in `der_dict`.
But it's not, because `visitorA` doesn't visit inside `GeneralExpression`.

Wait, if `visitorA` doesn't visit inside `GeneralExpression`, how does AD work for `GeneralExpression` at all?
Maybe `GeneralExpression` is supposed to be treated as a leaf?
But then you can't differentiate through it.

But the user is using `mode=Modes.reverse_symbolic`.

Let's see if `GeneralExpression` is handled elsewhere.
In `_reverse_diff_helper`:
```python
    for e in reversed(expr_list):
        if e.__class__ in _diff_map:
            _diff_map[e.__class__](e, val_dict, der_dict)
        elif e.is_named_expression_type():
            _diff_GeneralExpression(e, val_dict, der_dict)
```
`_diff_GeneralExpression` is only called if `e.is_named_expression_type()` is true.
And `_diff_GeneralExpression` just does `der_dict[node.expr] += der_dict[node]`.

This suggests that `node.expr` MUST be in `der_dict` for this to work.
But how can `node.expr` be in `der_dict` if it's not visited by `visitorA`?

Maybe `visitorA` should visit `node.expr` if `node` is a `GeneralExpression`?

Let's look at `_LeafToRootVisitor` again.
```python
    def visit(self, node, values):
        self.val_dict[node] = self.operation_func(node, values)
        self.der_dict[node] = 0
        self.expr_list.append(node)
        return self.val_dict[node]
```
If `node` is a `GeneralExpression`, `self.operation_func(node, values)` is called.
Since `numeric=False` (for `reverse_sd`), `_symbolic_apply_operation(node, values)` is called, which returns `node`.
So `val_dict[node]` is `node`.

Wait, if `numeric=True` (for `reverse_ad`), `_numeric_apply_operation(node, values)` is called.
`_numeric_apply_operation` calls `node._apply_operation(values)`.
For a `GeneralExpression`, `_apply_operation` probably evaluates the inner expression.

Let's check `GeneralExpression` implementation. It should be in `pyomo/core/expr/`.
Wait, I don't see `pyomo/core/expr/` in the layout, but it's a directory.
Let's find where `GeneralExpression` is defined.

{
  "command": "grep -rn \"class GeneralExpression\" pyomo/core/expr/"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

Ah, `grep` failed. Maybe it's in a different file.
Let's search for `GeneralExpression` in `pyomo/core/`.

{
  "command": "grep -rn \"GeneralExpression\" pyomo/core/"
}

{
  "status": "ok",
  "stdout": "pyomo/core/expr/calculus/diff_with_pyomo.py:321:def _diff_GeneralExpression(node, val_dict, der_dict):\npyomo/core/expr/calculus/diff_with_pyomo.py:442:            _diff_GeneralExpression(e, val_dict, der_dict)\npyomo/core/base/component.py:783:    # _GeneralExpressionData, _LogicalConstraintData,\npyomo/core/base/objective.py:41:from pyomo.core.base.expression import _ExpressionData, _GeneralExpressionDataImpl\npyomo/core/base/objective.py:133:    _GeneralExpressionDataImpl, _ObjectiveData, ActiveComponentData\npyomo/core/base/objective.py:160:        _GeneralExpressionDataImpl.__init__(self, expr)\npyomo/core/base/expression.py:149:class _GeneralExpressionDataImpl(_ExpressionData):\npyomo/core/base/expression.py:241:class _GeneralExpressionData(_GeneralExpressionDataImpl, ComponentData):\npyomo/core/base/expression.py:259:        _GeneralExpressionDataImpl.__init__(self, expr)\npyomo/core/base/expression.py:281:    _ComponentDataClass = _GeneralExpressionData\npyomo/core/base/expression.py:405:class ScalarExpression(_GeneralExpressionData, Expression):\npyomo/core/base/expression.py:407:        _GeneralExpressionData.__init__(self, expr=None, component=self)\npyomo/core/base/expression.py:430:            return _GeneralExpressionData.expr.fget(self)\npyomo/core/base/expression.py:448:            return _GeneralExpressionData.set_value(self, expr)\npyomo/core/base/expression.py:458:            return _GeneralExpressionData.is_constant(self)\npyomo/core/base/expression.py:468:            return _GeneralExpressionData.is_fixed(self)\npyomo/core/base/expression.py:512:        cdata = _GeneralExpressionData(expr, component=self)\npyomo/core/tests/unit/test_numeric_expr.py:2815:class TestGeneralExpressionGeneration(unittest.TestCase):\npyomo/core/tests/unit/test_dict_objects.py:23:from pyomo.core.base.expression import _GeneralExpressionData\npyomo/core/tests/unit/test_dict_objects.py:363:    _cdatatype = _GeneralExpressionData\npyomo/core/tests/unit/test_expression.py:32:from pyomo.core.base.expression import _GeneralExpressionData\npyomo/core/tests/unit/test_expression.py:518:        self.assertIs(type(expr), _GeneralExpressionData)\npyomo/core/tests/unit/test_expression.py:521:        self.assertIs(type(expr), _GeneralExpressionData)\npyomo/core/tests/unit/test_expression.py:540:        self.assertIs(type(expr), _GeneralExpressionData)\npyomo/core/tests/unit/test_list_objects.py:23:from pyomo.core.base.expression import _GeneralExpressionData\npyomo/core/tests/unit/test_list_objects.py:380:    _cdatatype = _GeneralExpressionData\n",
  "stderr": "",
  "exit_code": 0
}