jijmodeling 1.12.3__cp38-abi3-win_amd64.whl → 2.0.0b4__cp38-abi3-win_amd64.whl

jijmodeling/_jijmodeling.pyi

@@ -0,0 +1,4150 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import enum
+import numpy
+import numpy.typing
+import ommx.v1
+import typing
+
+__version__: builtins.str
+@typing.final
+class CategoryLabel:
+    r"""
+    A category label corresponds to a set of labels representing some specific category (e.g. the name of percels, or the ids of factors, etc).
+    A value of category label is treated opaque in JijModeling, and can only be tested for equality / non-equality and used as keys in dictionary-like structures.
+    
+    :class:`CategoryLabel` objects can be created via :meth:`Problem.CategoryLabel`.
+    The concrete values should be given in `instance_data` dictionary together with placeholder values when creating a :class:`Compiler` object or in `Problem.eval`.
+    In `instance_data`, category label should be given a list of either strings or integers.
+    """
+    def __eq__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __ne__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __lt__(self, other: typing.Any) -> Expression: ...
+    def __le__(self, other: typing.Any) -> Expression: ...
+    def __gt__(self, other: typing.Any) -> Expression: ...
+    def __ge__(self, other: typing.Any) -> Expression: ...
+    def bnot(self) -> Expression: ...
+    def __and__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rand__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __or__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __ror__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __xor__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rxor__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def diff(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def name(self) -> builtins.str: ...
+    def description(self) -> typing.Optional[builtins.str]: ...
+    def custom_latex(self) -> typing.Optional[builtins.str]: ...
+    def __next__(self) -> Expression:
+        r"""
+        A dummy implementation to make CategoryLabel usable in comprehension syntax with Decorator API.
+        Do not call this directly.
+        """
+    def __iter__(self) -> CategoryLabel:
+        r"""
+        A dummy implementation to make CategoryLabel usable in comprehension syntax with Decorator API.
+        Do not call this directly.
+        """
+
+class CompileError(builtins.Exception):
+    ...
+
+@typing.final
+class Compiler:
+    r"""
+    A compiler that converts problems/expressions into OMMX instance/functions.
+    
+    :class:`Compiler` objects can be created via constructor of `Compiler.from_problem` class method.
+    In this section we explain the usage of :class:`Compiler` constructor.
+    
+    Args
+    ----
+    - `namespace` (:class:`Namespace`): The namespace containing decision variables and other symbols used in the problem. (Typically obtained via `Problem.namespace`.)
+    - `instance_data` (dict[str, typing.Any]): A dictionary mapping names of placeholders and category labels to their concrete values for instance generation.
+    
+    Instance Data
+    --------------
+    For placeholders, you can pass any of the following:
+    
+    1. a scalar (integer or floating number point) value,
+    2. a tuple of scalars,
+    3. a (nested) list of (1) or (2).
+    4. a `ndarray.array` object from `numpy` package with `dtype` float or int.
+    
+    For category labels, you can pass a list of strings or integers representing the concrete labels.
+    
+    Returns
+    -------
+    A :class:`Compiler` object.
+    
+    Raises
+    ------
+    Raises `ModelingError` when there is missing or redundant placeholder(s) or category label(s) in `instance_data`.
+    """
+    def __new__(cls, namespace: Namespace, instance_data: typing.Mapping[builtins.str, builtins.int | builtins.float | numpy.typing.NDArray[numpy.float64] | numpy.typing.NDArray[numpy.int64] | list | dict | builtins.str]) -> Compiler: ...
+    @staticmethod
+    def from_problem(problem: Problem, instance_data: typing.Mapping[builtins.str, builtins.int | builtins.float | numpy.typing.NDArray[numpy.float64] | numpy.typing.NDArray[numpy.int64] | list | dict | builtins.str]) -> Compiler:
+        r"""
+        Creates a :class:`Compiler` object from a :class:`Problem` object and instance data.
+        
+        See :class:`Compiler` constructor for details about `instance_data`.
+        """
+    def eval_constraints(self, constraint: Constraint) -> builtins.list[ommx.v1.Constraint]: ...
+    def eval_problem(self, constraint: Problem) -> ommx.v1.Instance: ...
+    def eval_function(self, expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> ommx.v1.Function: ...
+    def get_decision_variable_by_name(self, name: str, subscript: typing.Optional[typing.Sequence[builtins.int | builtins.str | CategoryLabel]] = None) -> ommx.v1.DecisionVariable:
+        r"""
+        Retrieves an OMMX decision variable by its name and optional subscript.
+        """
+    def get_constraint_id_by_name(self, name: builtins.str) -> dict:
+        r"""
+        Obtains a dictionary from subscript to constraint Id.
+        """
+
+@typing.final
+class Constraint:
+    r"""
+    A constraint in the mathematical optimization model.
+    
+    Constraints represent restrictions on the valid values for decision
+    variables in the mathematical model. Constraints wrap around a valid
+    comparison expression (using `==`, `<=` or `>=`), often featuring decision
+    variables on one side.
+    
+    In JijModeling, `Constraints` exist within a :class:`Problem`'s namespace,
+    and cannot be defined outside of a problem. So to define a constraint, you
+    must use :meth:`Problem.Constraint` on a :class:`Problem` instance.
+    
+    
+    Created `Constraints` must then be explicitly added to a problem using the
+    `+=` operator, for example:
+    ```python
+    >>> problem = jm.Problem("problem")
+    >>> x = problem.BinaryVar("x", shape=(10,))
+    >>> problem += problem.Constraint("constr", x.sum() == 1)
+    ```
+    """
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def sense(self) -> ConstraintSense:
+        r"""
+        An enum representing the comparison involved in this constraint: whether it's
+        equality (==), greater-than (>=), or lesser-than (<=).
+        
+        Constraints can be
+        - `lhs == rhs` Equalities: `ConstraintSense.EQUAL`
+        - `lhs <= rhs` Inequalities: `ConstraintSense.LESS_THAN_EQUAL
+        - `lhs >= rhs` Inequalities: `ConstraintSense.GREATER_THAN_EQUAL`
+        """
+    @property
+    def left(self) -> Expression:
+        r"""
+        The left-hand side expression of the equality/inequality this constraint represents.
+        """
+    @property
+    def right(self) -> Expression:
+        r"""
+        The right-hand side expression of the equality/inequality this constraint represents.
+        """
+    @property
+    def expression(self) -> Expression:
+        r"""
+        The full expression of the equality/inequality this constraint represents.
+        """
+    @property
+    def is_equality(self) -> builtins.bool:
+        r"""
+        Returns true if the constraint is an equality constraint.
+        
+        Returns
+        --------
+        `bool`: True if the constraint is an equality constraint. Otherwise, False.
+        
+        Examples
+        ---------
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> N = jm.Placeholder("N")
+        >>> i = jm.Element("i", belong_to=N)
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> constraint = jm.Constraint("constraint", jm.sum(i, x[i]) == 1)
+        >>> assert constraint.is_equality()
+        ```
+        """
+    @property
+    def is_inequality(self) -> builtins.bool:
+        r"""
+        Returns true if the constraint is an inequality constraint.
+        
+        Returns
+        --------
+        `bool`: True if the constraint is an inequality constraint. Otherwise, False.
+        
+        Examples
+        ---------
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> N = jm.Placeholder("N")
+        >>> i = jm.Element("i", belong_to=N)
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> constraint = jm.Constraint("constraint", jm.sum(i, x[i]) <= 1)
+        >>> assert constraint.is_inequality()
+        ```
+        """
+    def __repr__(self) -> builtins.str: ...
+    def _repr_latex_(self) -> builtins.str: ...
+
+@typing.final
+class ConstraintDetectionConfig:
+    @property
+    def constraint_hints(self) -> builtins.list[ConstraintHintName]: ...
+    @property
+    def max_iter(self) -> typing.Optional[builtins.int]: ...
+    @property
+    def max_hints(self) -> typing.Optional[builtins.int]: ...
+    @property
+    def ban_length(self) -> typing.Optional[builtins.int]: ...
+    @property
+    def num_simplification(self) -> typing.Optional[builtins.int]: ...
+    @property
+    def match_limit(self) -> typing.Optional[builtins.int]: ...
+    def __new__(cls, *, max_iter: typing.Optional[builtins.int] = None, max_hints: typing.Optional[builtins.int] = None, constraint_hints: typing.Optional[typing.Sequence[ConstraintHintName]] = None, num_simplification: typing.Optional[builtins.int] = None, match_limit: typing.Optional[builtins.int] = None, ban_length: typing.Optional[builtins.int] = None) -> ConstraintDetectionConfig: ...
+    @staticmethod
+    def default_hints() -> builtins.list[ConstraintHintName]: ...
+
+@typing.final
+class DecisionVar:
+    r"""
+    A decision variable in a mathematical model.
+    
+    Decision variables are fundamental parts of mathematical optimization,
+    representing the values the solver can change to attempt to optimize the
+    objective function. As such, they will likely show up in
+    :class:`Expression`s throughout your model. `DecisionVar` should generally
+    work where `Expression` is expected and operations will automatically
+    convert as needed.
+    
+    Decision variables must belong to some namespace, ie. a :class:`Problem`, so
+    you CANNOT construct one directly. Use :meth:`Problem.DecisionVar` or
+    shorthand methods (eg. :meth:`Problem.BinaryVar`,
+    :meth:`Problem.IntegerVar`, etc.) to define decision variables.
+    
+    Decision variables can be defined and used as scalars (unit variables),
+    n-dimensional arrays, or as dictionaries. In the latter two cases, a single
+    `DecisionVariable` object represents multiple variables in the model, and
+    requires subscripting to access individual variables. This is similar to how
+    in a mathematical formula you may call a whole set of variables $x$ made up
+    of $x_0, x_1, ...$. More details on these is provided in later sections.
+    
+    ## Upper and lower bounds.
+    
+    Decision variables must have well-defined upper and lower bounds. These can
+    be specified through any valid expression but **CANNOT** contain decision
+    variables. What counts as a valid expression depends the decision variable
+    but should be intuitive.
+    
+    For all types of decision variable, a number literal, scalar
+    :class:`Placeholder`s, or expressions that evaluate to scalars can be used
+    as bounds. When this is used with array or dictionary variables, this sets
+    the same bounds for _all_ variables the object represents.
+    
+    For array variables, you can set the bounds separately for each individual
+    variable by passing in a matching array expression (eg. an array of numbers
+    or an array placeholder). The shape of the decision variable and the bound
+    expression must match (eg. a 2x2 decision variable likewise requires a 2x2
+    matrix of bounds) and otherwise will cause errors. Due to how placeholders
+    may have vaguely-defined shapes, some errors may only happen when evaluating
+    the model with actual data.
+    
+    For dictionary variables, you can set the bounds separately by passing in
+    a matching dictionary placeholder. The keys of the placeholder must matcha
+    the decision variable, and so partial dictionaries cannot be used.
+    
+    For both array and dictionary variables, you can also set each bound
+    separately by passing a function (usually a lambda). When evaluating your
+    problem, each valid index for that variable (be it a natural number or a key
+    from the appropriate category label) will be passed to the function, and the
+    returned value must be a scalar that will be used as that variable's bound.
+    
+    Using functions to set bounds is considered a more niche operation you will
+    often not need, but it can be useful when there is some operation on the
+    instance data you want to use to define the bounds (eg. the upper bound is
+    lower bound + 10); or when you want to do some index manipulation (eg.
+    setting the bound to an inverse matrix by doing `lambda i,j: V[j,i]`).
+    
+    Binary decision variables should have upper and lower bounds defined as
+    `1` and `0` and using other bounds will lead to an error when evaluating
+    your model into an OMMX instance. The :meth:`Problem.BinaryVar` method sets
+    the correct bounds automatically.
+    
+    ## Array decision variables and `shape`
+    
+    You can define `DecisionVar`s as n-dimensional arrays (aka. matrix, tensors,
+    etc.) of decision variables. While some operations can work on arrays
+    directly, in general this means you'll have to use subscripts (ie. indexing
+    with `[]`) to get individual decision variables when writing expressions.
+    
+    Array variables are defined by specifying a `shape` in the constructor method. Shapes are tuples
+    or lists of expressions, where each entry specifies the number of decision variables in a given dimension. For example:
+    - a `10` shape represents a 1-dimensional array with 10 variables. (Defining the shape as `(10,)` would be equivalent)
+    - a `(2, 2)` shape represents a 2-dimensional array with 2 variables in each dimension (a 2x2 matrix)
+    
+    Scalar variables have a shape of `()` (an empty tuple), which is also the
+    default value of `shape` when none is specified.
+    
+    Unlike :class:`Placeholder`, decision variables _must_ have a defined shape.
+    You cannot simply specify "2-dimensional", for example. As an alternative
+    you _can_ define the shape using scalar placeholders or the length of
+    placeholders, allowing you to still define decision variable arrays with
+    size parametrized on the instance data.
+    
+    ## Dictionary decision variables
+    
+    As an alternative to the array-like interface, decision variables can also
+    be used in a style closer to python dictionaries: an unordered collection
+    indexed by a set of labels. This is recommended mostly when you're focused
+    on string-based labels or want non-contiguous indices.
+    
+    To use variables this way, you must first define a set of labels through
+    :meth:`Problem.CategoryLabel`s. This is a special kind of placeholder which
+    will represent the keys to dictionaries, and can be reused throughout your
+    model (eg. to define matching dictionary-like `Placeholder`s).
+    
+    This `CategoryLabel` instance is then passed to the `dict_keys` parameter in
+    the appropriate constructor (:meth:`Problem.DecisionVar`, etc.). Tuples of
+    category labels can be passed to define dictionaries which use multiple
+    keys.
+    
+    The array and dictionary representations are mutually exclusive, and you
+    **cannot** set both `shape` and `dict_keys` together. Doing so will lead to
+    an exception.
+    
+    Unlike :class:`Placeholder`s, decision variables can only be used as total
+    dictionaries over the entire category domain. You cannot define them as
+    partial dictionaries, and there is no `partial_dict` parameter.
+    
+    Attributes
+    -----------
+    - `name` (`str`): A name of the continuous variable.
+    - `kind` (`DecisionVarKind`): The kind of the decision variable, which can be one of the following:
+      - `BINARY`: A binary variable.
+      - `INTEGER`: An integer variable.
+      - `CONTINUOUS`: A continuous variable.
+      - `SEMI_INTEGER`: A semi-integer variable.
+      - `SEMI_CONTINUOUS`: A semi-continuous variable.
+    - `shape` (`tuple`): A tuple with the size of each dimension of the integer variable. Empty if the variable is not multi-dimensional.
+    - `lower_bound`: The lower bound of the variable.
+    - `upper_bound`: The upper bound of the variable.
+    - `description` (`str`): A description of the continuous variable.
+    
+    Examples
+    ---------
+    Create a scalar continuous variable whose name is "z" and is bounded to `[-1, 1]`.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> z = problem.DecisionVar(
+    >>>     "z",
+    >>>     kind=jm.DecisionVarKind.CONTINUOUS,
+    >>>     lower_bound=-1, upper_bound=1
+    >>> )
+    ```
+    
+    or equivalently:
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> z = problem.ContinuousVar("z", lower_bound=-1, upper_bound=1)
+    ```
+    
+    Create a 2-dimensional integer variable...
+    - whose name is "x".
+    - whose domain is [0, 2].
+    - where each dimension has length 2 (making this a 2x2 matrix).
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> x = problem.IntegerVar("x", shape=[2, 2], lower_bound=0, upper_bound=2)
+    ```
+    
+    Create a 1-dimensional continuous variable, and construct an expression
+    accessing the 123rd component of it..
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> x = problem.ContinuousVar("x", shape=[124], lower_bound=0, upper_bound=2)
+    >>> x[123]
+    x[123]
+    ```
+    """
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def kind(self) -> DecisionVarKind: ...
+    @property
+    def description(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def ndim(self) -> typing.Optional[builtins.int]:
+        r"""
+        The number of dimensions this decision variable represents.
+        
+        This is 0 for scalar variables, and None for dictionary variables.
+        """
+    @property
+    def shape(self) -> typing.Optional[tuple]:
+        r"""
+        The shape tuple of the decision variable, consisting of `Expression`s
+        that define the size of each dimension.
+        
+        This is an empty tuple if the variable is a scalar, and None if it's a
+        dictionary variable.
+        """
+    @property
+    def lower_bound(self) -> Expression | builtins.list[Expression] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]: ...
+    @property
+    def upper_bound(self) -> Expression | builtins.list[Expression] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]: ...
+    @property
+    def custom_latex(self) -> typing.Optional[builtins.str]:
+        r"""
+        The custom latex representation of this decision variable, if defined.
+        
+        When no custom latex is defined, the default representation is to use the variable name.
+        """
+    @typing.overload
+    def min(self) -> Expression:
+        r"""
+        Creates an expression which refers to the smallest value in `self`.
+        
+        This method works only on valid sequence expressions, where the resulting
+        expression is a scalar representing the smallest among all values in the sequence.
+        """
+    @typing.overload
+    def min(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, /) -> Expression:
+        r"""
+        Creates an expression representing the smaller value between `self` and `rhs`.
+        
+        This is a method-based alternative to :func:`jijmodeling.min`.
+        """
+    @typing.overload
+    def max(self) -> Expression:
+        r"""
+        Creates an expression which refers to the largest value in `self`.
+        
+        This method works only on valid sequence expressions, where the resulting
+        expression is a scalar representing the largest among all values in the sequence.
+        """
+    @typing.overload
+    def max(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, /) -> Expression:
+        r"""
+        Creates an expression representing the larger value between `self` and `rhs`.
+        
+        This is a method-based alternative to :func:`jijmodeling.max`.
+        """
+    def __eq__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __ne__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __lt__(self, other: typing.Any) -> Expression: ...
+    def __le__(self, other: typing.Any) -> Expression: ...
+    def __gt__(self, other: typing.Any) -> Expression: ...
+    def __ge__(self, other: typing.Any) -> Expression: ...
+    def sum(self, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[builtins.int]] = None) -> Expression:
+        r"""
+        Creates an expression representing the summation of `self`.
+        
+        This is an alternative to using :func:`jijmodeling.sum`, where
+        a method call on an expression may be more convenient/readable.
+        
+        If `self` isn't a valid sequence which can be summed, you will get an
+        error when the resulting expression is added to a :class:`Problem` and is
+        type-checked.
+        
+        The optional `axis` parameter allows you to specify one axis of a
+        multi-dimensional expression across which to perform the operation.
+        
+        Examples
+        ------
+        
+        Simple sum of decision variables.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N)
+        >>> problem += x.sum()
+        ```
+        
+        Performing a weighted sum. Note that this sort of usage may lead to errors
+        when the shapes don't match. In this case we guarantee that `x` has the
+        same shape as `W` through its definition.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> W = problem.Float("W", ndim=1)
+        >>> N = a.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=N)
+        >>> problem += (W * x).sum()
+        ```
+        """
+    def prod(self, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[builtins.int]] = None) -> Expression:
+        r"""
+        Creates an expression representing the multiplication of `self`.
+        
+        This is an alternative to using :func:`jijmodeling.prod`, where
+        a method call on an expression may be more convenient/readable.
+        
+        If `self` isn't a valid sequence which can be multiplied, you will get an
+        error when the resulting expression is added to a :class:`Problem` and is
+        type-checked.
+        
+        The optional `axis` parameter allows you to specify one axis of a
+        multi-dimensional expression across which to perform the operation.
+        
+        Examples
+        ------
+        
+        Simple product of decision variables
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N)
+        >>> problem += x.prod()
+        ```
+        """
+    def __getitem__(self, subscripts: typing.Any) -> Expression: ...
+    def map(self, func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression that maps the values in `self` to `func`.
+        
+        This is an alternative to :func:`jijmodeling.map` which allows you
+        to place the indexing expression first.
+        
+        When called on valid scalar scalars, each number from 0 to this `self`
+        will be passed to `func`. When called on a sequence expression (eg. a
+        1-dimensional placeholder, or the result of functions like
+        :func:`jijmodeling.product` or :func:`jijmodeling.items`), each element
+        in the sequence is passed to `func`.
+        
+        This is mostly used alongside lambdas as a way to access individual values
+        within array-like or dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. The resulting expression is then usually passed to a
+        reducer, like :func:`jijmodeling.sum` (or :meth:`Expression.sum` is called
+        on it), to form part of a constraint or the objective function.
+        
+        Examples
+        ------
+        
+        Indexing by values from 0 to N. In this example we define N as the length of
+        another placeholder, but a scalar Natural placeholder would work as well.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> W = problem.Float("W", ndim=1)
+        >>> N = W.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=N)
+        >>> problem += N.map(lambda i: W[i] * x[i]).sum()
+        ```
+        
+        Indexing by specific values from instance data. In this example only the
+        indices present in `C` in the instance data will be used in this constraint.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N, lower_bound=0, upper_bound=10)
+        >>> C = problem.Natural("C", ndim=1)
+        >>> problem += problem.Constraint("constr", C.map(lambda i: x[i]).sum() <= 100)
+        ```
+        """
+    def roll(self, shift: typing.Any, *, axis: typing.Optional[builtins.int] = None) -> Expression: ...
+    def filter(self, predicate: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression that filters the values of this sequence.
+        
+        `predicate` will be called on each element in `self`. The resulting
+        expression represents only the values for which `predicate` is true.
+        
+        This is an alternative to :func:`jijmodeling.filter` which allows
+        you to place the indexing expression first.
+        
+        This is often useful when trying to create summations which only include
+        a subset of potential indices.The resulting expression is usually used as the
+        basis for :func:`jijmodeling.map`, :func:`jijmodeling.sum`, etc., or a
+        method equivalent.
+        
+        Examples
+        ------
+        
+        Using only variables with even indices as part of a constraint.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> even_xs = N.filter(lambda i: i % 2 == 0).map(lambda i: x[i])
+        >>> problem += problem.Constraint("constr", even_xs.sum() <= 10)
+        ```
+        
+        Using only non-diagonal indices of an NxN matrix as part of a constraint, using the method version of `filter`.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> W = problem.Float("W", shape=(N, N))
+        >>> non_diagonals = jm.product(N, N).filter(lambda i, j: i != j)
+        >>> problem += problem.Constraint("constr", lambda i, j: W[i, j] * x[i, j], domain=non_diagonals)
+        ```
+        """
+    def flat_map(self, func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression which works like :meth:`map`, but flattens nested structure.
+        
+        This is an alternative to :func:`jijmodeling.flat_map` which allows you to
+        place the indexing expression first.
+        
+        `map` is useful when `func` returns scalar values, but in some
+        situations one wants to write a `func` that returns other
+        mappings/sequences instead. That is where `flat_map` should be used,
+        "flattening" all sequences/iterators into a single linear sequence
+        (which can then be reduced with :meth:`sum`, etc.)
+        
+        You can also compare `flat_map` to a nested for-loop, or a generator
+        expression that uses two `for` clauses. Indeed when using the decorated API
+        (see tutorials or :meth:`Problem.update`), you can use a generator
+        expression-like syntax instead.
+        
+        Examples
+        ------
+        
+        Using only non-diagonal indices of an NxN matrix.
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> W = problem.Float("W", shape=(N, N))
+        >>> objective = N.flat_map(
+        ...    lambda i: N.filter(lambda j: i != j).map(lambda j: W[i, j] * x[i, j])
+        ... ).sum()
+        >>> problem += objective
+        ```
+        """
+    def rows(self) -> Expression:
+        r"""
+        Creates a sequence over the rows of this multi-dimensional array expression.
+        
+        That is, each element will be a whole row (itself containing multiple
+        values), which can then be operated on like other sequences (eg. using
+        :func:`jijmodelng.sum` or :func:`jijmodeling.map`).
+        
+        If the array is 3-dimensional or higher, rows will iterate over the first
+        dimension/axis. For example, in a 3D matrix, the first element would be a
+        2D matrix representing all values `x[0, _, _]`
+        
+        Examples
+        ------
+        
+        Create an objective function that multiplies each variable in a row, and
+        then sums each row. In this case we have a 2x3 matrix, so the final expression is
+        `x[0, 0] * x[0, 1] * x[0, 2] + x[1, 0] * x[1, 1] * x[1, 2]`. Using
+        placeholders instead of literals in `shape` would allow this to be written
+        for matrices of arbitrary size.
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> d = problem.BinaryVar("d", shape=(2, 3))
+        >>> problem += d.rows().map(lambda xs: xs.prod()).sum()
+        ```
+        
+        If the number of elements in the row can be guaranteed, the elements can be
+        destructured as separate arguments in a lambda expression:
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> V = problem.Natural("V")
+        >>> E = problem.Natural("E", shape=(N, 2))
+        >>> x = problem.BinaryVar("x", shape=V)
+        >>> problem += jm.map(lambda i, j: x[i] * x[j], E.rows()).sum()
+        ```
+        """
+    def indices(self) -> Expression:
+        r"""
+        Get the set of indices of given array or jagged array.
+        
+        Will throw type error when called on non-array type.
+        """
+    def keys(self) -> Expression:
+        r"""
+        Returns an expression representing this dictionary-like object's keys.
+        
+        In other words, this is the JijModeling equivalent of the `keys()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.values` and :meth:`Expression.items`.
+        
+        Examples
+        ------
+        Refer to a dictionary-like placeholder's keys when
+        creating other objects or writing summations:
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> W = problem.Float("W", dict_keys=I)
+        >>> x = problem.BinaryVar("x", dict_keys=W.keys())
+        >>> problem += jm.sum(W.keys(), lambda i: W[i] * x[i])
+        ```
+        """
+    def values(self) -> Expression:
+        r"""
+        Returns an expression representing this dictionary-like object's values.
+        
+        In other words, this is the JijModeling equivalent of the `values()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.keys` and :meth:`Expression.items`.
+        
+        Examples
+        ------
+        Defining a simple objective function which just sums a dictionary-based decision variable.
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> x = problem.IntegerVar("x", dict_keys=I, lower_bound=0, upper_bound=100)
+        >>> problem += x.values().sum()
+        ```
+        """
+    def items(self) -> Expression:
+        r"""
+        Returns an expression representing this object's `(key,value)` pairs.
+        
+        In other words, this is the JijModeling equivalent of the `items()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.keys` and :meth:`Expression.values`.
+        
+        Examples
+        ------
+        Simple matching of weights to their respective variables, as an alternative to just using `keys()` or the `CategoryLabel`:
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> weights = problem.Float("W", dict_keys=I)
+        >>> x = problem.BinaryVar("x", dict_keys=I)
+        >>> problem += jm.sum(weights.items(), lambda i, w: w * x[i])
+        ```
+        
+        Same as above, but using the decorated API:
+        ```python
+        >>> @problem.update
+        ... def _(problem):
+        ...   I = problem.CategoryLabel()
+        ...   W = problem.Float(dict_keys=I)
+        ...   x = problem.BinaryVar(dict_keys=I)
+        ...   problem += jm.sum(w * x[i] for i, w in W.items())
+        ```
+        """
+    def __neg__(self) -> Expression: ...
+    def abs(self) -> Expression:
+        r"""
+        Returns an expression representing the absolute value of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sqrt(self) -> Expression:
+        r"""
+        Returns an expression representing the square root of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sin(self) -> Expression:
+        r"""
+        Returns an expression representing the sine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def cos(self) -> Expression:
+        r"""
+        Returns an expression representing the cosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def tan(self) -> Expression:
+        r"""
+        Returns an expression representing the tangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def asin(self) -> Expression:
+        r"""
+        Returns an expression representing the arcsine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def acos(self) -> Expression:
+        r"""
+        Returns an expression representing the arccosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def atan(self) -> Expression:
+        r"""
+        Returns an expression representing the arctangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sinh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic sine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def cosh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic cosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def tanh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic tangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def asinh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arcsine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def acosh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arccosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def atanh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arctangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def exp(self) -> Expression:
+        r"""
+        Returns an expression representing the application of the exponential function on the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def ln(self) -> Expression:
+        r"""
+        Returns an expression representing the natural logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def log10(self) -> Expression:
+        r"""
+        Returns an expression representing the decimal logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def log2(self) -> Expression:
+        r"""
+        Returns an expression representing the binary logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def ceil(self) -> Expression:
+        r"""
+        Returns an expression which rounds down to the nearest whole number.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def floor(self) -> Expression: ...
+    def __add__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __radd__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __sub__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rsub__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __mul__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rmul__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __truediv__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rtruediv__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __mod__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rmod__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __pow__(self, exponent: typing.Any, modulo: typing.Optional[typing.Any] = None) -> Expression: ...
+    def __rpow__(self, base: typing.Any, modulo: typing.Optional[typing.Any] = None) -> Expression: ...
+    def __repr__(self) -> builtins.str: ...
+    def _repr_latex_(self) -> builtins.str: ...
+
+@typing.final
+class DecoratedProblem(typing.Protocol):
+    r"""
+    A variant of `Problem` that is only available in Decorator API provided by `Problem.update`.
+    See `Problem` for more details.
+    """
+    @property
+    def objective(self) -> Expression: ...
+    @property
+    def description(self) -> builtins.str:
+        r"""
+        The problem description.
+        
+        An empty string if no description was defined.
+        """
+    @property
+    def constraints(self) -> builtins.dict[builtins.str, builtins.list[Constraint]]:
+        r"""
+        Returns a dictionary of the constraints in the problem.
+        
+        Returns
+        --------
+        `dict[str, [Constraint]]`: Dictionary mapping constraint names to Constraint objects.
+        """
+    @typing.overload
+    def Constraint(self, name: builtins.str, expression: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, description: typing.Optional[builtins.str] = None) -> Constraint:
+        r"""
+        Constructs `Constraint` object from comparison expression, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    @typing.overload
+    def Constraint(self, name: builtins.str, expression: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], domain: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, description: typing.Optional[builtins.str] = None) -> Constraint:
+        r"""
+        Constructs ``Constraint`` family with the index set ``domain`` and function ``expression`` to build comparison expression from each index, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    @typing.overload
+    def Constraint(self, name: str, expressions: typing.Generator[Expression, None, None], description: typing.Optional[builtins.str] = None) -> Constraint:
+        r"""
+        Comprehension syntax for jm.prod (NOTE: only works with decorated API!)
+        """
+    def used_placeholders(self) -> builtins.list[Placeholder]: ...
+    def get_problem_schema(self) -> dict:
+        r"""
+        Returns the schema of the problem.
+        
+        Returns
+        --------
+        - `schema`: The dictionary containing the schema of the problem.
+        """
+    def generate_random_dataset(self, _default: typing.Any, _options: typing.Any, _seed: typing.Optional[builtins.int]) -> typing.Any:
+        r"""
+        Generates a dictionary of random `InstanceDataValue` for a given problem.
+        To generate `ommx.v1.Instance` object directly, use `InstanceDataValue.generate_random_instance` instead.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" below).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        
+        Returns
+        --------
+        `dict`: The dictionary from the name of placeholders to the generated `InstanceDataValue` objects. To be fed to `Interpreter.eval_problem`.
+        
+        Range Parameters and Range Syntax
+        ----------------------------------
+        A range parameter is a dictionary consisting of the following fields:
+        - `size` (optional): interval of natural numbers for the size of each array dimension (default: `range(1, 6)`)
+        - `value` (optional): interval of real numbers for the value of each array element (default: `range(-1.0, 1.0)` - a uniform distribution on a closed interval $[-1.0, 1.0]$).
+        
+        Example range parameter config:
+        
+        ```python
+        {"size": range(2, 10), "value": jm.range.value.closed(100.0, 200.0)}
+        ```
+        
+        Intervals are expressed as a range object.
+        Currently, the following syntax is supported for range objects:
+        
+        1. Direct value of type `int` or `float` - it corresponds to a singleton interval $[a, a] = \{a\}$. In random generation context, this just means a constant fixed value.
+        2. Use the functions from `jijmodeling.range`, `jijmodeling.range.size`, or `jijmodeling.range.value` modules.
+           - Use functions from `jij.modeling.range.size` to specify (non-negative) integer intervals, and `jij.modeling.range.value` for real intervals. `jij.modeling.range` dynamically determines the type of the range based on the input.
+           - These three modules provides the following combinators (see the module documents for more details.):
+                    - `closed(a, b)`: a closed interval $[a, b]$
+                    - `open(a, b)`: an open interval $(a, b)$
+                    - `closed_open(a, b)`: an upper half-open interval $[a, b)$
+                    - `open_closed(a, b)`: a lower half-open interval $(a, b]$
+                    - `greater_than(a)`: an open interval $(a, \infty)$
+                    - `at_least(a)`: a closed interval $[a, \infty)$
+                    - `less_than(a)`: an open interval $(-\infty, a)$
+                    - `at_most(a)`: a closed interval $(-\infty, a]$
+        3. Use `range` builtin function: this is equivalent to `jijmodeling.range.value.closed_open(a, b)`.
+           - Any python range object with `step = 1` can be used as a size range; otherwise it results in runtime error.
+        4. Use a tuple: raw tuple `(a, b)` is equivalent to `jijmodeling.range.closed_open(a, b)` if `a` and `b` are either `int` or `float`.
+           - You can also use bound object as a tuple component; in such case, both tuple components must be one of the following:
+        
+                1. A string `"Unbounded"` means $-\infty$ (in the first component) or $\infty$ (the second).
+                2. A dictionary `{"Included": a}` means the endpoint is inclusive.
+                3. A dictionary `{"Excluded": a}` means the endpoint is exclusive.
+           - Examples:
+                    - `(1.2, 4)` is equivalent to `closed_open(1.2, 4)`,
+                    - `(-1, {"Included": 1})` is equivalent to `closed(-1, 1)`,
+                    - `(-5, {"Excluded": 4})` is equivalent to `closed_open(-5, 4)` and built in function `range(-5, 4)`,
+                    - `({"Excluded": 1}, {"Excluded": 2.5})` is equivalent to `open(1, 2.5)`,
+                    - `({"Included": -1}, "Unbounded")` is equivalent to `at_least(-1)`.
+                    - `(5, "Unbounded")` is **INVALID**; `5` must be bound object.
+        5. The range object: A dictionary of form `{"start": lb, "end": ub}`, where both `lb` and `ub` are the bound object described as above.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> inputs = problem.generate_random_dataset(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...          # You can also specify "size" for the range of jagged array dimension size.
+        ...     },
+        ...     seed=123 # omittable
+        ... )
+        >>> assert set(inputs.keys()) == {"N", "c"}
+        >>> inputs
+        {'N': 11.0, 'c': array([ 0.93914459, -0.06511935, -0.7460324 , -0.32443706,  0.99981451,
+               -0.24407535,  0.31329469,  0.52206453, -0.1291936 ,  0.30443087,
+                0.53125838])}
+        
+        ```
+        """
+    def generate_random_instance(self, _default: typing.Any, _options: typing.Any, _seed: typing.Optional[builtins.int], _hints: typing.Optional[typing.Any]) -> typing.Any:
+        r"""
+        Generates random `ommx.v1.Instance` for a given problem.
+        See also `InstanceDataValue.generate_random_dataset`.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" section in :func:`~jijmodeling.Problem.generate_random_dataset`).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        - `hints` (optional): the hints to be detected during compilation see `Interpreter.eval_problem` for more details.
+        
+        Returns
+        --------
+        `instance`: The OMMX v1 instance object.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> import ommx.v1
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> instance = problem.generate_random_instance(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...     },
+        ...     seed=123
+        ... )
+        >>> assert type(instance) is ommx.v1.Instance
+        
+        ```
+        """
+    def type_of(self, name: builtins.str) -> Type:
+        r"""
+        Returns the type associated with a given name (eg. of a placeholder or decision variable).
+        
+        This is mostly inteded for testing purposes, and not as part of standard model writing.
+        
+        :raises ModelingError: If the name is undefined in this problem's namespace.
+        """
+    def infer(self, expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Type:
+        r"""
+        Infers the resulting type of an expression using this problem as a namespace.
+        
+        This is mostly intended for testing purposes, and not as part of standard model writing.
+        
+        Examples
+        ===
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Length(name="N")
+        >>> x = problem.BinaryVar("x", shape=(N,))
+        >>> y = problem.IntegerVar("y", shape=(N,), lower_bound=0,upper_bound=10)
+        >>> problem.infer(jm.sum(x))
+        binary!
+        >>> problem.infer(jm.sum(y))
+        int!
+        ```
+        """
+    def decision_vars(self) -> builtins.dict[builtins.str, DecisionVar]:
+        r"""
+        Returns a dictionary of decision variables in the problem.
+        
+        Returns
+        --------
+        `dict[str, DecisionVar]`: Dictionary mapping variable names to DecisionVar objects.
+        """
+    def placeholders(self) -> builtins.dict[builtins.str, Placeholder]:
+        r"""
+        Returns a dictionary of placeholders in the problem.
+        The dictionary may contain placeholders that are not used in the problem;
+        to get only used placeholders, use `used_placeholders` method.
+        
+        Returns
+        --------
+        `dict[str, Placeholder]`: Dictionary mapping placeholder names to Placeholder objects.
+        """
+    def Placeholder(self, name: typing.Optional[builtins.str] = None, *, dtype: DataType | type | tuple, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` in this problem's namespace.
+        
+        Placeholders can be a scalar, multi-dimensional array (representing arrays and
+        matrices), or dictionary keyed by integers or strings.
+        
+        When calling `DecoratedProblem.Placehoder`, you must specify `dtype` explicitly to indicate the type of data the placeholder holds.
+        Alternative shorthand methods like `DecoratedProblem.Integer`, `DecoratedProblem.Binary`,
+        or `DecoratedProblem.Natural` are recommended for convenience in their specific
+        use cases.
+        
+        Representation
+        --------------
+        Depending on the arguments described below, the representation of the placeholder will be determined as follows:
+        
+        1. If none none of `ndim`, `shape`, `jagged`, `dict_keys`, or `partial_dict` is provided, or, `ndim` is set to zero, Placeholder will be considered as a scalar value (= array of dimension 0).
+        2. If either (or both consistently) of `ndim` or `shape` is provided and `jagged` is `False` (or omitted), and none of `dict_keys` or `partial_dict` is given, Placeholder will be considered as a multi-dimensional array with fixed shape.
+        3. If either (or both consistently), of `ndim` or `shape` is provided and `jagged` is `True`, and none of `dict_keys` or `partial_dict` is given,Placeholder will be considered as a jagged array (i.e. a non-rectangular ndim array).
+        4. If `dict_keys` is specified but none of `ndim`, `shape`, `jagged` is provided, then Placeholder will be considered as a total dictionary-like structure with keys specified by `dict_keys`.
+        5. If both `dict_keys` and `partial_dict` (set to `True`) are specified, and none of `ndim`, `shape`, or `jagged` is provided, then Placeholder will be considered as a partial dictionary-like structure with keys specified by `dict_keys`.
+        6. Otherwise, an error is raised.
+        
+        Args
+        -----
+        - `name` (`str | None`): The placeholder's name. If omitted, the local variable name is used.
+        - `dtype` (`DataType`): The type of data this placeholder holds (integer, floating point, etc.).
+        - `ndim` (`int`): The number of dimensions in this placeholder. Defaults to 0 (a scalar value).
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the placeholder. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+          - There is no need to provide `ndim` if `shape` is specified, but they must not conflict if both specified.
+        - `jagged` (`bool`): Whether this placeholder represents a jagged array (ie. a non-square matrix). Ignored if scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this placeholder represents a dictionary-like structure with keys `dict_keys`.
+        - `partial_dict` (`bool`, optional): If `dict_keys` is provided, specifies whether this placeholder represents a partial dictionary (i.e., not all keys are guaranteed to be present). Defaults to `False`.
+        - `latex` (`str`, optional): An optional LaTeX representation to be used in Jupyter notebook.
+          - When not provided, `name` is used by default.
+        - `description` (`str`, optional): An optional description for user reference.
+        
+        Examples
+        ---------
+        Create a scalar integer placeholder whose name is "a".
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> @problem.update
+        >>> def _(problem: jm.DecoratedProblem)
+        >>>     a = problem.Placeholder("a", dtype=jm.DataType.INTEGER)
+        ```
+        """
+    def Integer(self, name: typing.Optional[builtins.str] = None, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing an integer in this problem's namespace.
+        
+        A shorthand for `DecoratedProblem.Placeholder(dtype=DataType.INTEGER)`, provided for clarity and convenience.
+        See `DecoratedProblem.Placeholder` for more details on placeholders.
+        """
+    def Float(self, name: typing.Optional[builtins.str] = None, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a floating-point (real) number in this problem's namespace.
+        
+        A shorthand for `DecoratedProblem.Placeholder(dtype=DataType.FLOAT)`, provided for clarity and convenience.
+        See `DecoratedProblem.Placeholder` for more details on placeholders.
+        """
+    def Natural(self, name: typing.Optional[builtins.str] = None, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a natural number in this problem's namespace.
+        
+        A shorthand for `DecoratedProblem.Placeholder(dtype=DataType.NATURAL)`, provided for clarity and convenience.
+        See `DecoratedProblem.Placeholder` for more details on placeholders.
+        """
+    def Length(self, name: typing.Optional[builtins.str] = None, *, ndim: typing.Optional[builtins.int] = 0, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a natural number in this problem's namespace.
+        
+        This is just a shorthand for `DecoratedProblem.Natural(ndim=0)` and effectively the same as any other natural
+        placeholder for practical purposes. The use of `Length` is recommended just for clarity when
+        defining a placeholder which will be used to define the length of multi-dimensional objects.
+        
+        See `DecoratedProblem.Placeholder` for more details on placeholders.
+        """
+    def Dim(self, name: typing.Optional[builtins.str] = None, *, ndim: typing.Optional[builtins.int] = 0, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a natural number in this problem's namespace.
+        
+        This is just a shorthand for `DecoratedProblem.Natural(ndim=0)` and effectively the same as any other natural
+        placeholder for practical purposes. The use of `Dim` is recommended just for clarity when
+        defining a placeholder which will be used to define the length of multi-dimensional objects.
+        
+        See `DecoratedProblem.Placeholder` for more details on placeholders.
+        """
+    def Binary(self, name: typing.Optional[builtins.str] = None, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a `Placeholder` representing a binary number in this problem's namespace.
+        
+        A shorthand for `DecoratedProblem.Placeholder(dtype=DataType.BINARY)`, provided for clarity and convenience.
+        See `DecoratedProblem.Placeholder` for more details on placeholders.
+        """
+    def PartialDict(self, name: typing.Optional[builtins.str] = None, *, dict_keys: DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple, dtype: DataType | type | tuple, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        A shorthand for creating a partial dictionary placeholder with key type
+        """
+    def TotalDict(self, name: typing.Optional[builtins.str] = None, *, dict_keys: DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple, dtype: DataType | type | tuple, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        A shorthand for creating a total dictionary placeholder with key type
+        """
+    def Graph(self, name: typing.Optional[builtins.str] = None, *, dtype: DataType | type | tuple = DataType.NATURAL, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        A placeholder expressing a directed graph with vertices of type `dtype` (without edge weights), represented by a 1-dimensional array of tuples.
+        
+        A shorthand for `DecoratedProblem.Placeholder(dtype=(dtype, dtype), ndim=1)`.
+        By default `dtype` is `DataType.Natural` but can be specified.
+        """
+    def DecisionVar(self, name: typing.Optional[builtins.str] = None, *, kind: DecisionVarKind, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a :class:`DecisionVar` and registers it to the problem namespace.
+        
+        Decision variables can be scalars, multi-dimensional arrays (eg. representing
+        arrays and matrices of variables), or total dictionaries.
+        
+        Variables must have a `DecisionVarKind` (such as `BINARY`, `INTEGER`, `CONTINUOUS`),
+        as well as defined lower and upper bounds.
+        
+        We recommend using alternative convenience methods which predefine the
+        decision variable's kind, such as `DecoratedProblem.IntegerVar` for integers, or
+        `DecoratedProblem.BinaryVar` for binary variables.
+        
+        Representation
+        --------------
+        Depending on the arguments described below, the representation of the decision variable will be determined as follows:
+        
+        1. If none of `shape` or `dict_keys` is provided, or `shape` is `()`, DecisionVar will be considered as a scalar value (= array of dimension 0).
+        2. If `shape` is provided and `dict_keys` is not provided, DecisionVar will be considered as a multi-dimensional array with fixed shape.
+        3. If `dict_keys` is provided without `shape`, DecisionVar will be considered as a dictionary-like structure with keys specified by `dict_keys`.
+        4. Otherwise, an error is raised.
+        
+        Args
+        -----
+        - `name` (`str | None`): A name for the binary variable. If omitted, local variable name is used.
+        - `kind` (`DecisionVarKind`): A kind of the decision variable.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `lower_bound` and `upper_bound` (`jijmodeling.Expression`): A lower and upper bounds of the variable.
+        - `kind` (`DecisionVarKind`): The kind of the decision variable.
+        - `latex` (`str`, optional): An optional LaTeX representation to be used in Jupyter notebook.
+          - It is set to be the same as `name` by default.
+        - `description` (`str`, optional): An optional description, for user reference.
+        
+        Examples
+        ---------
+        Create a scalar binary variable whose name is "z".
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> @problem.update
+        >>> def update(problem: DecoratedProblem):
+        >>>     z = problem.DecisionVar(kind=jm.DecisionVarKind.BINARY, lower_bound=0, upper_bound=1)
+        
+        ```
+        
+        Create a 2-dimensional binary variable whose name is "x" and has a 2x2 shape.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> @problem.update
+        >>> def update(problem: DecoratedProblem):
+        >>>     z = problem.BinaryVar(shape=[2, 2])
+        
+        ```
+        
+        Create a total dictionary of integer variables with the keys `(I, J, 5)`
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> @problem.update
+        >>> def update(problem: DecoratedProblem):
+        >>>     w = problem.IntegerVar(
+        >>>         lower_bound=l,
+        >>>         upper_bound=u,
+        >>>         dict_keys=(I, J, 5)
+        >>>     )
+        
+        ```
+        """
+    def BinaryVar(self, name: typing.Optional[builtins.str] = None, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a binary decision variable and registers it to the problem namespace. See `DecoratedProblem.DecisionVariable` for more details.
+        
+        A shorthand for `DecoratedProblem.DecisionVariable(dtype=DecisionVarKind.BINARY,
+        lower_bound=0, upper_bound=1)`, provided for clarity and convenience.
+        
+        Args
+        -----
+        - `name` (`str | None`): A name for the binary variable. If omitted, local variable name is used.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the binary variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `latex` (`str`, optional): A LaTeX-name of the binary variable to be represented in Jupyter notebook.
+          - It is set to `name` by default.
+        - `description` (`str`, optional): A description of the binary variable.
+        """
+    def IntegerVar(self, name: typing.Optional[builtins.str] = None, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines an integer decision variable and registers it to the problem namespace. See `DecoratedProblem.DecisionVar` for more details.
+        
+        This is shorthand for `Problem.DecisionVariable(kind=DecisionVarKind.INTEGER)`.
+        
+        Args
+        -----
+        - `name` (`str | None`): A name for the binary variable. If omitted, local variable name is used.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the integer variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `lower_bound`: The lower bound of the variable.
+        - `upper_bound`: The upper bound of the variable.
+        - `latex` (`str`, optional): A LaTeX-name of the integer variable to be represented in Jupyter notebook.
+          - It is set to `name` by default.
+        - `description` (`str`, optional): A description of the integer variable.
+        
+        Raises
+        -------
+        `ModelingError`: Raises if a bound is a `Placeholder` or `Subscript` object whose `ndim`
+        is neither `0` nor the same value as `ndim` of the integer variable.
+        """
+    def SemiIntegerVar(self, name: typing.Optional[builtins.str] = None, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a semi-integer decision variable and registers it to the problem namespace. See `DecoratedProblem.DecisionVar` for more details.
+        
+        This is shorthand for `problem.DecisionVariable(kind=DecisionVarKind.SEMI_INTEGER)`.
+        """
+    def ContinuousVar(self, name: typing.Optional[builtins.str] = None, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a continuous decision variable and registers it to the problem namespace. See `Problem.DecisionVar` for more details.
+        
+        This is shorthand for `problem.DecisionVariable(dtype=DecisionVarKind.CONTINUOUS)`.
+        
+        Args
+        -----
+        - `name` (`str | None`): A name for the binary variable. If omitted, local variable name is used.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the continuous variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `lower_bound`: The lower bound of the variable.
+        - `upper_bound`: The upper bound of the variable.
+        - `latex` (`str`, optional): A LaTeX-name of the continuous variable to be represented in Jupyter notebook.
+          - It is set to `name` by default.
+        - `description` (`str`, optional): A description of the continuous variable.
+        
+        Raises
+        -------
+        `ModelingError`: Raises if a bound is a `Placeholder` or `Subscript` object whose `ndim` is neither `0` nor the same value as `ndim` of the continuous variable.
+        """
+    def SemiContinuousVar(self, name: typing.Optional[builtins.str] = None, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar: ...
+    def CategoryLabel(self, name: typing.Optional[builtins.str] = None, *, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> CategoryLabel:
+        r"""
+        Add a new opaque category label to the namespace.
+        
+        A category label corresponds to a set of labels representing some specific category (e.g. the name of percels, or the ids of factors, etc).
+        A value of category label is treated opaque in JijModeling, and can only be tested for equality / non-equality and used as keys in dictionary-like structures.
+        
+        :class:`CategoryLabel` objects can be created via :meth:`Problem.CategoryLabel`.
+        The concrete values should be given in `instance_data` dictionary together with placeholder values when creating a :class:`Compiler` object or in `Problem.eval`.
+        In `instance_data`, category label should be given a list of either strings or integers.
+        ///
+        Args
+        ----
+        - `name` (`str | None`): A name for the category label. If omitted, local variable name is used.
+        - `latex` (`str`, optional): An optional LaTeX representation to be used in Jupyter notebook.
+          - When not provided, `name` is used by default.
+        - `description` (`str`, optional): An optional description for user reference.
+        """
+    def eval(self, instance_data: typing.Mapping[builtins.str, builtins.int | builtins.float | numpy.typing.NDArray[numpy.float64] | numpy.typing.NDArray[numpy.int64] | list | dict | builtins.str]) -> ommx.v1.Instance:
+        r"""
+        Compiles and evaluates the problem given the specified instance data, returning an OMMX instance.
+        
+        A short-hand of `Compiler.from_problem(self, data).eval_problem(self)`.
+        
+        Args
+        ----
+        - `instance_data` (`dict[str, InstanceValue]`): A dictionary mapping placeholder and category label names to their corresponding values for this instance. See :class:`Compiler` for more details on the expected format of `instance_data`.
+        """
+    @typing.overload
+    def __iadd__(self, other: Constraint) -> DecoratedProblem:
+        r"""
+        Add constraint to the problem.
+        """
+    @typing.overload
+    def __iadd__(self, other: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> DecoratedProblem:
+        r"""
+        Add an expression as a term to the objective function of the problem.
+        """
+
+@typing.final
+class DesugaredProblemBuilder:
+    def __call__(self) -> None: ...
+
+@typing.final
+class Expression:
+    r"""
+    Any expression in Python.
+    """
+    @typing.overload
+    def min(self) -> Expression:
+        r"""
+        Creates an expression which refers to the smallest value in `self`.
+        
+        This method works only on valid sequence expressions, where the resulting
+        expression is a scalar representing the smallest among all values in the sequence.
+        """
+    @typing.overload
+    def min(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, /) -> Expression:
+        r"""
+        Creates an expression representing the smaller value between `self` and `rhs`.
+        
+        This is a method-based alternative to :func:`jijmodeling.min`.
+        """
+    @typing.overload
+    def max(self) -> Expression:
+        r"""
+        Creates an expression which refers to the largest value in `self`.
+        
+        This method works only on valid sequence expressions, where the resulting
+        expression is a scalar representing the largest among all values in the sequence.
+        """
+    @typing.overload
+    def max(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, /) -> Expression:
+        r"""
+        Creates an expression representing the larger value between `self` and `rhs`.
+        
+        This is a method-based alternative to :func:`jijmodeling.max`.
+        """
+    def __eq__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __ne__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __lt__(self, other: typing.Any) -> Expression: ...
+    def __le__(self, other: typing.Any) -> Expression: ...
+    def __gt__(self, other: typing.Any) -> Expression: ...
+    def __ge__(self, other: typing.Any) -> Expression: ...
+    def bnot(self) -> Expression: ...
+    def __and__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rand__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __or__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __ror__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __xor__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rxor__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def diff(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def sum(self, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[builtins.int]] = None) -> Expression:
+        r"""
+        Creates an expression representing the summation of `self`.
+        
+        This is an alternative to using :func:`jijmodeling.sum`, where
+        a method call on an expression may be more convenient/readable.
+        
+        If `self` isn't a valid sequence which can be summed, you will get an
+        error when the resulting expression is added to a :class:`Problem` and is
+        type-checked.
+        
+        The optional `axis` parameter allows you to specify one axis of a
+        multi-dimensional expression across which to perform the operation.
+        
+        Examples
+        ------
+        
+        Simple sum of decision variables.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N)
+        >>> problem += x.sum()
+        ```
+        
+        Performing a weighted sum. Note that this sort of usage may lead to errors
+        when the shapes don't match. In this case we guarantee that `x` has the
+        same shape as `W` through its definition.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> W = problem.Float("W", ndim=1)
+        >>> N = a.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=N)
+        >>> problem += (W * x).sum()
+        ```
+        """
+    def prod(self, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[builtins.int]] = None) -> Expression:
+        r"""
+        Creates an expression representing the multiplication of `self`.
+        
+        This is an alternative to using :func:`jijmodeling.prod`, where
+        a method call on an expression may be more convenient/readable.
+        
+        If `self` isn't a valid sequence which can be multiplied, you will get an
+        error when the resulting expression is added to a :class:`Problem` and is
+        type-checked.
+        
+        The optional `axis` parameter allows you to specify one axis of a
+        multi-dimensional expression across which to perform the operation.
+        
+        Examples
+        ------
+        
+        Simple product of decision variables
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N)
+        >>> problem += x.prod()
+        ```
+        """
+    def __getitem__(self, subscripts: typing.Any) -> Expression: ...
+    def map(self, func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression that maps the values in `self` to `func`.
+        
+        This is an alternative to :func:`jijmodeling.map` which allows you
+        to place the indexing expression first.
+        
+        When called on valid scalar scalars, each number from 0 to this `self`
+        will be passed to `func`. When called on a sequence expression (eg. a
+        1-dimensional placeholder, or the result of functions like
+        :func:`jijmodeling.product` or :func:`jijmodeling.items`), each element
+        in the sequence is passed to `func`.
+        
+        This is mostly used alongside lambdas as a way to access individual values
+        within array-like or dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. The resulting expression is then usually passed to a
+        reducer, like :func:`jijmodeling.sum` (or :meth:`Expression.sum` is called
+        on it), to form part of a constraint or the objective function.
+        
+        Examples
+        ------
+        
+        Indexing by values from 0 to N. In this example we define N as the length of
+        another placeholder, but a scalar Natural placeholder would work as well.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> W = problem.Float("W", ndim=1)
+        >>> N = W.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=N)
+        >>> problem += N.map(lambda i: W[i] * x[i]).sum()
+        ```
+        
+        Indexing by specific values from instance data. In this example only the
+        indices present in `C` in the instance data will be used in this constraint.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N, lower_bound=0, upper_bound=10)
+        >>> C = problem.Natural("C", ndim=1)
+        >>> problem += problem.Constraint("constr", C.map(lambda i: x[i]).sum() <= 100)
+        ```
+        """
+    def roll(self, shift: typing.Any, *, axis: typing.Optional[builtins.int] = None) -> Expression: ...
+    def filter(self, predicate: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression that filters the values of this sequence.
+        
+        `predicate` will be called on each element in `self`. The resulting
+        expression represents only the values for which `predicate` is true.
+        
+        This is an alternative to :func:`jijmodeling.filter` which allows
+        you to place the indexing expression first.
+        
+        This is often useful when trying to create summations which only include
+        a subset of potential indices.The resulting expression is usually used as the
+        basis for :func:`jijmodeling.map`, :func:`jijmodeling.sum`, etc., or a
+        method equivalent.
+        
+        Examples
+        ------
+        
+        Using only variables with even indices as part of a constraint.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> even_xs = N.filter(lambda i: i % 2 == 0).map(lambda i: x[i])
+        >>> problem += problem.Constraint("constr", even_xs.sum() <= 10)
+        ```
+        
+        Using only non-diagonal indices of an NxN matrix as part of a constraint, using the method version of `filter`.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> W = problem.Float("W", shape=(N, N))
+        >>> non_diagonals = jm.product(N, N).filter(lambda i, j: i != j)
+        >>> problem += problem.Constraint("constr", lambda i, j: W[i, j] * x[i, j], domain=non_diagonals)
+        ```
+        """
+    def flat_map(self, func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression which works like :meth:`map`, but flattens nested structure.
+        
+        This is an alternative to :func:`jijmodeling.flat_map` which allows you to
+        place the indexing expression first.
+        
+        `map` is useful when `func` returns scalar values, but in some
+        situations one wants to write a `func` that returns other
+        mappings/sequences instead. That is where `flat_map` should be used,
+        "flattening" all sequences/iterators into a single linear sequence
+        (which can then be reduced with :meth:`sum`, etc.)
+        
+        You can also compare `flat_map` to a nested for-loop, or a generator
+        expression that uses two `for` clauses. Indeed when using the decorated API
+        (see tutorials or :meth:`Problem.update`), you can use a generator
+        expression-like syntax instead.
+        
+        Examples
+        ------
+        
+        Using only non-diagonal indices of an NxN matrix.
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> W = problem.Float("W", shape=(N, N))
+        >>> objective = N.flat_map(
+        ...    lambda i: N.filter(lambda j: i != j).map(lambda j: W[i, j] * x[i, j])
+        ... ).sum()
+        >>> problem += objective
+        ```
+        """
+    def rows(self) -> Expression:
+        r"""
+        Creates a sequence over the rows of this multi-dimensional array expression.
+        
+        That is, each element will be a whole row (itself containing multiple
+        values), which can then be operated on like other sequences (eg. using
+        :func:`jijmodelng.sum` or :func:`jijmodeling.map`).
+        
+        If the array is 3-dimensional or higher, rows will iterate over the first
+        dimension/axis. For example, in a 3D matrix, the first element would be a
+        2D matrix representing all values `x[0, _, _]`
+        
+        Examples
+        ------
+        
+        Create an objective function that multiplies each variable in a row, and
+        then sums each row. In this case we have a 2x3 matrix, so the final expression is
+        `x[0, 0] * x[0, 1] * x[0, 2] + x[1, 0] * x[1, 1] * x[1, 2]`. Using
+        placeholders instead of literals in `shape` would allow this to be written
+        for matrices of arbitrary size.
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> d = problem.BinaryVar("d", shape=(2, 3))
+        >>> problem += d.rows().map(lambda xs: xs.prod()).sum()
+        ```
+        
+        If the number of elements in the row can be guaranteed, the elements can be
+        destructured as separate arguments in a lambda expression:
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> V = problem.Natural("V")
+        >>> E = problem.Natural("E", shape=(N, 2))
+        >>> x = problem.BinaryVar("x", shape=V)
+        >>> problem += jm.map(lambda i, j: x[i] * x[j], E.rows()).sum()
+        ```
+        """
+    def indices(self) -> Expression:
+        r"""
+        Get the set of indices of given array or jagged array.
+        
+        Will throw type error when called on non-array type.
+        """
+    def keys(self) -> Expression:
+        r"""
+        Returns an expression representing this dictionary-like object's keys.
+        
+        In other words, this is the JijModeling equivalent of the `keys()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.values` and :meth:`Expression.items`.
+        
+        Examples
+        ------
+        Refer to a dictionary-like placeholder's keys when
+        creating other objects or writing summations:
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> W = problem.Float("W", dict_keys=I)
+        >>> x = problem.BinaryVar("x", dict_keys=W.keys())
+        >>> problem += jm.sum(W.keys(), lambda i: W[i] * x[i])
+        ```
+        """
+    def values(self) -> Expression:
+        r"""
+        Returns an expression representing this dictionary-like object's values.
+        
+        In other words, this is the JijModeling equivalent of the `values()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.keys` and :meth:`Expression.items`.
+        
+        Examples
+        ------
+        Defining a simple objective function which just sums a dictionary-based decision variable.
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> x = problem.IntegerVar("x", dict_keys=I, lower_bound=0, upper_bound=100)
+        >>> problem += x.values().sum()
+        ```
+        """
+    def items(self) -> Expression:
+        r"""
+        Returns an expression representing this object's `(key,value)` pairs.
+        
+        In other words, this is the JijModeling equivalent of the `items()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.keys` and :meth:`Expression.values`.
+        
+        Examples
+        ------
+        Simple matching of weights to their respective variables, as an alternative to just using `keys()` or the `CategoryLabel`:
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> weights = problem.Float("W", dict_keys=I)
+        >>> x = problem.BinaryVar("x", dict_keys=I)
+        >>> problem += jm.sum(weights.items(), lambda i, w: w * x[i])
+        ```
+        
+        Same as above, but using the decorated API:
+        ```python
+        >>> @problem.update
+        ... def _(problem):
+        ...   I = problem.CategoryLabel()
+        ...   W = problem.Float(dict_keys=I)
+        ...   x = problem.BinaryVar(dict_keys=I)
+        ...   problem += jm.sum(w * x[i] for i, w in W.items())
+        ```
+        """
+    def __neg__(self) -> Expression: ...
+    def abs(self) -> Expression:
+        r"""
+        Returns an expression representing the absolute value of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sqrt(self) -> Expression:
+        r"""
+        Returns an expression representing the square root of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sin(self) -> Expression:
+        r"""
+        Returns an expression representing the sine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def cos(self) -> Expression:
+        r"""
+        Returns an expression representing the cosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def tan(self) -> Expression:
+        r"""
+        Returns an expression representing the tangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def asin(self) -> Expression:
+        r"""
+        Returns an expression representing the arcsine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def acos(self) -> Expression:
+        r"""
+        Returns an expression representing the arccosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def atan(self) -> Expression:
+        r"""
+        Returns an expression representing the arctangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sinh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic sine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def cosh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic cosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def tanh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic tangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def asinh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arcsine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def acosh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arccosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def atanh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arctangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def exp(self) -> Expression:
+        r"""
+        Returns an expression representing the application of the exponential function on the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def ln(self) -> Expression:
+        r"""
+        Returns an expression representing the natural logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def log10(self) -> Expression:
+        r"""
+        Returns an expression representing the decimal logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def log2(self) -> Expression:
+        r"""
+        Returns an expression representing the binary logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def ceil(self) -> Expression:
+        r"""
+        Returns an expression which rounds down to the nearest whole number.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def floor(self) -> Expression: ...
+    def __add__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __radd__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __sub__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rsub__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __mul__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rmul__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __truediv__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rtruediv__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __mod__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rmod__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __pow__(self, exponent: typing.Any, modulo: typing.Optional[typing.Any] = None) -> Expression: ...
+    def __rpow__(self, base: typing.Any, modulo: typing.Optional[typing.Any] = None) -> Expression: ...
+    def _repr_latex_(self) -> builtins.str: ...
+    def __call__(self, *args: typing.Any) -> Expression: ...
+    def shape(self) -> Expression:
+        r"""
+        Returns an expression which represents the shape of this expression.
+        
+        Unlike the attributes in :class:`DecisionVar` and :class:`Placeholder`,
+        this expression is opaque and abstract -- but can still be used to define
+        the shape of new objects according to the shape of arbitrary expressions.
+        """
+    def len_at(self, axis: builtins.int) -> Expression:
+        r"""
+        Returns an expression which represents the length (number of values) of this expression at a given dimension (0-indexed).
+        
+        This can be used, for example, when trying to match the shape of
+        an object to the number of values in an array.
+        """
+    def __repr__(self) -> builtins.str: ...
+    def or_else(self, default: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+        r"""
+        Returns the value inside `option` if `Some`, otherwise returns `default`.
+        """
+    def map_or_else(self, default: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, mapper: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+        r"""
+        If self is `Some(value)`, applies `mapper(value)`, otherwise returns `default`.
+        """
+
+class ModelingError(builtins.Exception):
+    ...
+
+@typing.final
+class Namespace:
+    def __new__(cls) -> Namespace: ...
+    @staticmethod
+    def from_problem(problem: Problem) -> Namespace: ...
+    def add_category_label(self, label: CategoryLabel) -> None:
+        r"""
+        Add a new opaque category label to the namespace.
+        """
+    def add_placeholder(self, placeholder: Placeholder) -> None: ...
+    def Placeholder(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, dtype: DataType | type | tuple = DataType.FLOAT, jagged: builtins.bool = False, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder: ...
+    def add_decision_var(self, var: DecisionVar) -> None: ...
+    def type_of(self, name: builtins.str) -> typing.Optional[Type]: ...
+    def infer(self, expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Type: ...
+
+@typing.final
+class Placeholder:
+    r"""
+    A placeholder for instance-specific parameters.
+    
+    This class represents a symbol of unspecified value, which is to be replaced
+    by numerical values when you evaluate an optimization problem, before
+    solving it. Think of it like a instance-specific constant/parameters you
+    want to abstract in your model (for examples, the weights of different
+    objects/nodes).
+    
+    Like decision variables, `Placeholder`s are often used throughout your model
+    within :class:`Expression`s, and should generally work wherever an
+    `Expression` is expected. Operations will automatically convert as needed.
+    
+    Placeholders must belong to some namespace, i.e. a :class:`Problem`, so you
+    cannot construct one directly. Use `Problem.Placeholder` or shorthand
+    methods shorthands (e.g., `Problem.Integer`, `Problem.Float`, etc.) to
+    define placeholders.
+    
+    Placeholders can be defined and used as scalars (unit values), n-dimensional
+    arrays, or as dictionaries. In the latter two cases, a single `Placeholder`
+    object represents multiple values in the model, and requires subscripting
+    to access individual values. This is similar to how in a mathematical
+    formula you may call a whole set by a symbol $W$, made up of $W_0, W_1,
+    ...$. More details on these usages is provided in the following sections.
+    
+    ## Array placeholders, `shape` and `ndim`
+    
+    You can define `Placeholder`s as n-dimensional arrays (aka. matrix, tensors,
+    etc.). While some operations can work on arrays directly, in general this
+    means you'll have to use subscripts (ie. indexing with `[]`) to refer to
+    individual values writing expressions.
+    
+    Array placeholders are defined by specifying either `ndim` or `shape` in the
+    constructor method. `ndim` simply states the number of dimensions a
+    placeholder will have. Shapes are tuples or lists of expressions, where each
+    entry specifies the number of values in a given dimension. For example:
+    - a `10` shape represents a 1-dimensional array with 10 values. (Defining the shape as `(10,)` would be equivalent)
+    - a `(2, 2)` shape represents a 2-dimensional array with 2 values in each dimension (a 2x2 matrix)
+    
+    Only one of `ndim` or `shape` is required to define an array placeholder,
+    but if both are provided they must be consistent with eachother.
+    
+    When only `ndim` is provided, the shape of the placeholder is not yet
+    defined but it still has one in an abstract sense (which will be defined by
+    the instance data), and :meth:`Placeholder.shape` will return a tuple of "length
+    at" expressions.
+    
+    Scalar placeholders have a shape of `()` (an empty tuple) and 0 dimensions.
+    
+    ## Dictionary placeholders
+    
+    As an alternative to the array-like interface, placeholders can also be used
+    in a style closer to python dictionaries: an unordered collection indexed by
+    a set of labels. This is recommended mostly when you're focused on
+    string-based labels or want non-contiguous indices.
+    
+    To use variables this way, you must first define a set of labels through
+    :meth:`Problem.CategoryLabel`s. This is a special kind of placeholder which
+    will represent the keys to dictionaries, and can be reused throughout your
+    model (eg. to define matching dictionary-like `DecisionVar`s).
+    
+    This `CategoryLabel` instance is then passed to the `dict_keys` parameter in
+    the appropriate constructor (:meth:`Problem.Placeholder`, etc.). Tuples of
+    category labels can be passed to define dictionaries which use multiple
+    keys.
+    
+    By default, dictionary placeholders are "total", that is, each label given
+    by the `CategoryLabel` must have a corresponding value in the data. If you
+    wish to create a partial dictionary, when only certain keys will have data,
+    you must define `partial_dict` as `True` when creating the placeholder.
+    
+    The array and dictionary representations are mutually exclusive, and you
+    **cannot** set `dict_keys` alongside `shape`/`ndim`. Doing so will lead to
+    an exception.
+    
+    Attributes
+    -----------
+    - `name` (`str`): A name of the placeholder.
+    - `dtype` (`DataType`, optional): The data type (eg. `DataType.INT` or `DataType.FLOAT`) of the placeholder.
+    - `ndim` (`int`): The number of dimensions of the placeholder.
+    - `shape` (`tuple` of `Optional[Expression]`, optional): The (partial) shape of the placeholder if given.
+    - `jagged` (`boolean`, defaut: `False`): `True` if the placeholder will be treated as a jagged array in random data generation. Ignored for scalars.
+    - `dict_keys` (`DictKeySpec`): The specification of dictionary keys if the placeholder is a dictionary type.
+    - `partial_dict` (`bool`, default: `False`): `True` if the placeholder is a partial dictionary. Ignored if `dict_keys` is not given.
+    - `description` (`str`, optional): A description for user reference.
+    
+    Raises
+    -------
+    - `TypeError`: Raises if set a float value to `ndim`.
+    - `OverflowError`: Raises if set a negative value to `ndim`.
+    
+    Examples
+    ---------
+    Create a scalar (or `ndim` is `0`) placeholder whose name is "a".
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> a = problem.Placeholder("a", dtype=float)
+    
+    ```
+    
+    Create a 2-dimensional integer placeholder whose name is "m".
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> m = problem.Integer("m", ndim=2)
+    
+    ```
+    
+    Create a 1-dimensional natural number placeholder with the index of `123`.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("example")
+    >>> a = problem.Natural("a", ndim=2)
+    >>> a[123]
+    a[123]
+    >>> problem.get_placeholder("a")
+    Placeholder(name='a', ndim=2, shape=None, dtype=typing.float, jagged=False)
+    ```
+    """
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def ndim(self) -> typing.Optional[builtins.int]:
+        r"""
+        The number of dimensions this decision variable represents.
+        
+        This is 0 for scalar variables, and None for dictionary variables.
+        """
+    @property
+    def shape(self) -> typing.Optional[typing.Tuple[Expression,...]]:
+        r"""
+        The shape tuple of the placeholder, consisting of `Expression`s
+        that define the size of each dimension.
+        
+        This is an empty tuple if the placeholder is a scalar, and `None` if it's a
+        dictionary placeholder.
+        
+        See also `Placeholder.shape_spec` property to get the original value
+        given at the declaration time.
+        
+        ## Difference between `Placeholder.shape` and `Placeholder.shape_spec`
+        
+        - `Placeholder.shape` property always returns a tuple of `Expression`s,
+          filling `None` with `len_at` expressions so that i-th component
+          coincides with the value of `ph.len_at(i)`
+        - `Placeholder.shape_spec` just returns the original `shape` definition,
+          hence the spec itself can be `None` or contain `None` components.
+        
+        ## Use cases
+        
+        - use `Placeholder.shape` property if you want to construct expressions involving the shape of the placeholder.
+        - use `Placeholder.shape_spec` property if you want to inspect the very definition of the placeholder.
+        """
+    @property
+    def shape_spec(self) -> typing.Optional[typing.Tuple[typing.Optional[Expression],...]]:
+        r"""
+        Get the original definition of shape given at the declaration time, possibly `None` if omitted.
+        See also `Placeholder.shape` property to get the shape as `Expression`s.
+        
+        ## Difference between `Placeholder.shape` and `Placeholder.shape_spec`
+        
+        - `Placeholder.shape` property always returns a tuple of `Expression`s,
+          filling `None` with `len_at` expressions so that i-th component
+          coincides with the value of `ph.len_at(i)`
+        - `Placeholder.shape_spec` just returns the original `shape` definition,
+          hence the spec itself can be `None` or contain `None` components.
+        
+        ## Use cases
+        
+        - use `Placeholder.shape_spec` property if you want to inspect the very definition of the placeholder.
+        - use `Placeholder.shape` property if you want to construct expressions involving the shape of the placeholder.
+        """
+    @property
+    def dtype(self) -> DataType | type | tuple:
+        r"""
+        This placeholder's data type (natural, integer, float, etc.)
+        """
+    @property
+    def jagged(self) -> builtins.bool: ...
+    @property
+    def description(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def custom_latex(self) -> typing.Optional[builtins.str]:
+        r"""
+        The custom latex representation of this placeholder, if defined.
+        
+        When no custom latex is defined, the default representation is to use the placeholder name.
+        """
+    @typing.overload
+    def min(self) -> Expression:
+        r"""
+        Creates an expression which refers to the smallest value in `self`.
+        
+        This method works only on valid sequence expressions, where the resulting
+        expression is a scalar representing the smallest among all values in the sequence.
+        """
+    @typing.overload
+    def min(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, /) -> Expression:
+        r"""
+        Creates an expression representing the smaller value between `self` and `rhs`.
+        
+        This is a method-based alternative to :func:`jijmodeling.min`.
+        """
+    @typing.overload
+    def max(self) -> Expression:
+        r"""
+        Creates an expression which refers to the largest value in `self`.
+        
+        This method works only on valid sequence expressions, where the resulting
+        expression is a scalar representing the largest among all values in the sequence.
+        """
+    @typing.overload
+    def max(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, /) -> Expression:
+        r"""
+        Creates an expression representing the larger value between `self` and `rhs`.
+        
+        This is a method-based alternative to :func:`jijmodeling.max`.
+        """
+    def __eq__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __ne__(self, other: typing.Any) -> Expression: ...  # type: ignore[reportIncompatibleMethodOverride]
+    def __lt__(self, other: typing.Any) -> Expression: ...
+    def __le__(self, other: typing.Any) -> Expression: ...
+    def __gt__(self, other: typing.Any) -> Expression: ...
+    def __ge__(self, other: typing.Any) -> Expression: ...
+    def bnot(self) -> Expression: ...
+    def __and__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rand__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __or__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __ror__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __xor__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rxor__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def diff(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def sum(self, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[builtins.int]] = None) -> Expression:
+        r"""
+        Creates an expression representing the summation of `self`.
+        
+        This is an alternative to using :func:`jijmodeling.sum`, where
+        a method call on an expression may be more convenient/readable.
+        
+        If `self` isn't a valid sequence which can be summed, you will get an
+        error when the resulting expression is added to a :class:`Problem` and is
+        type-checked.
+        
+        The optional `axis` parameter allows you to specify one axis of a
+        multi-dimensional expression across which to perform the operation.
+        
+        Examples
+        ------
+        
+        Simple sum of decision variables.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N)
+        >>> problem += x.sum()
+        ```
+        
+        Performing a weighted sum. Note that this sort of usage may lead to errors
+        when the shapes don't match. In this case we guarantee that `x` has the
+        same shape as `W` through its definition.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> W = problem.Float("W", ndim=1)
+        >>> N = a.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=N)
+        >>> problem += (W * x).sum()
+        ```
+        """
+    def prod(self, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[builtins.int]] = None) -> Expression:
+        r"""
+        Creates an expression representing the multiplication of `self`.
+        
+        This is an alternative to using :func:`jijmodeling.prod`, where
+        a method call on an expression may be more convenient/readable.
+        
+        If `self` isn't a valid sequence which can be multiplied, you will get an
+        error when the resulting expression is added to a :class:`Problem` and is
+        type-checked.
+        
+        The optional `axis` parameter allows you to specify one axis of a
+        multi-dimensional expression across which to perform the operation.
+        
+        Examples
+        ------
+        
+        Simple product of decision variables
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N)
+        >>> problem += x.prod()
+        ```
+        """
+    def __getitem__(self, subscripts: typing.Any) -> Expression: ...
+    def map(self, func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression that maps the values in `self` to `func`.
+        
+        This is an alternative to :func:`jijmodeling.map` which allows you
+        to place the indexing expression first.
+        
+        When called on valid scalar scalars, each number from 0 to this `self`
+        will be passed to `func`. When called on a sequence expression (eg. a
+        1-dimensional placeholder, or the result of functions like
+        :func:`jijmodeling.product` or :func:`jijmodeling.items`), each element
+        in the sequence is passed to `func`.
+        
+        This is mostly used alongside lambdas as a way to access individual values
+        within array-like or dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. The resulting expression is then usually passed to a
+        reducer, like :func:`jijmodeling.sum` (or :meth:`Expression.sum` is called
+        on it), to form part of a constraint or the objective function.
+        
+        Examples
+        ------
+        
+        Indexing by values from 0 to N. In this example we define N as the length of
+        another placeholder, but a scalar Natural placeholder would work as well.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> W = problem.Float("W", ndim=1)
+        >>> N = W.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=N)
+        >>> problem += N.map(lambda i: W[i] * x[i]).sum()
+        ```
+        
+        Indexing by specific values from instance data. In this example only the
+        indices present in `C` in the instance data will be used in this constraint.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> x = problem.IntegerVar("x", shape=N, lower_bound=0, upper_bound=10)
+        >>> C = problem.Natural("C", ndim=1)
+        >>> problem += problem.Constraint("constr", C.map(lambda i: x[i]).sum() <= 100)
+        ```
+        """
+    def roll(self, shift: typing.Any, *, axis: typing.Optional[builtins.int] = None) -> Expression: ...
+    def filter(self, predicate: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression that filters the values of this sequence.
+        
+        `predicate` will be called on each element in `self`. The resulting
+        expression represents only the values for which `predicate` is true.
+        
+        This is an alternative to :func:`jijmodeling.filter` which allows
+        you to place the indexing expression first.
+        
+        This is often useful when trying to create summations which only include
+        a subset of potential indices.The resulting expression is usually used as the
+        basis for :func:`jijmodeling.map`, :func:`jijmodeling.sum`, etc., or a
+        method equivalent.
+        
+        Examples
+        ------
+        
+        Using only variables with even indices as part of a constraint.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> even_xs = N.filter(lambda i: i % 2 == 0).map(lambda i: x[i])
+        >>> problem += problem.Constraint("constr", even_xs.sum() <= 10)
+        ```
+        
+        Using only non-diagonal indices of an NxN matrix as part of a constraint, using the method version of `filter`.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> W = problem.Float("W", shape=(N, N))
+        >>> non_diagonals = jm.product(N, N).filter(lambda i, j: i != j)
+        >>> problem += problem.Constraint("constr", lambda i, j: W[i, j] * x[i, j], domain=non_diagonals)
+        ```
+        """
+    def flat_map(self, func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+        r"""
+        Creates an expression which works like :meth:`map`, but flattens nested structure.
+        
+        This is an alternative to :func:`jijmodeling.flat_map` which allows you to
+        place the indexing expression first.
+        
+        `map` is useful when `func` returns scalar values, but in some
+        situations one wants to write a `func` that returns other
+        mappings/sequences instead. That is where `flat_map` should be used,
+        "flattening" all sequences/iterators into a single linear sequence
+        (which can then be reduced with :meth:`sum`, etc.)
+        
+        You can also compare `flat_map` to a nested for-loop, or a generator
+        expression that uses two `for` clauses. Indeed when using the decorated API
+        (see tutorials or :meth:`Problem.update`), you can use a generator
+        expression-like syntax instead.
+        
+        Examples
+        ------
+        
+        Using only non-diagonal indices of an NxN matrix.
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = jm.Natural("N")
+        >>> x = problem.BinaryVar("x", shape=(N, N))
+        >>> W = problem.Float("W", shape=(N, N))
+        >>> objective = N.flat_map(
+        ...    lambda i: N.filter(lambda j: i != j).map(lambda j: W[i, j] * x[i, j])
+        ... ).sum()
+        >>> problem += objective
+        ```
+        """
+    def rows(self) -> Expression:
+        r"""
+        Creates a sequence over the rows of this multi-dimensional array expression.
+        
+        That is, each element will be a whole row (itself containing multiple
+        values), which can then be operated on like other sequences (eg. using
+        :func:`jijmodelng.sum` or :func:`jijmodeling.map`).
+        
+        If the array is 3-dimensional or higher, rows will iterate over the first
+        dimension/axis. For example, in a 3D matrix, the first element would be a
+        2D matrix representing all values `x[0, _, _]`
+        
+        Examples
+        ------
+        
+        Create an objective function that multiplies each variable in a row, and
+        then sums each row. In this case we have a 2x3 matrix, so the final expression is
+        `x[0, 0] * x[0, 1] * x[0, 2] + x[1, 0] * x[1, 1] * x[1, 2]`. Using
+        placeholders instead of literals in `shape` would allow this to be written
+        for matrices of arbitrary size.
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> d = problem.BinaryVar("d", shape=(2, 3))
+        >>> problem += d.rows().map(lambda xs: xs.prod()).sum()
+        ```
+        
+        If the number of elements in the row can be guaranteed, the elements can be
+        destructured as separate arguments in a lambda expression:
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Natural("N")
+        >>> V = problem.Natural("V")
+        >>> E = problem.Natural("E", shape=(N, 2))
+        >>> x = problem.BinaryVar("x", shape=V)
+        >>> problem += jm.map(lambda i, j: x[i] * x[j], E.rows()).sum()
+        ```
+        """
+    def indices(self) -> Expression:
+        r"""
+        Get the set of indices of given array or jagged array.
+        
+        Will throw type error when called on non-array type.
+        """
+    def keys(self) -> Expression:
+        r"""
+        Returns an expression representing this dictionary-like object's keys.
+        
+        In other words, this is the JijModeling equivalent of the `keys()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.values` and :meth:`Expression.items`.
+        
+        Examples
+        ------
+        Refer to a dictionary-like placeholder's keys when
+        creating other objects or writing summations:
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> W = problem.Float("W", dict_keys=I)
+        >>> x = problem.BinaryVar("x", dict_keys=W.keys())
+        >>> problem += jm.sum(W.keys(), lambda i: W[i] * x[i])
+        ```
+        """
+    def values(self) -> Expression:
+        r"""
+        Returns an expression representing this dictionary-like object's values.
+        
+        In other words, this is the JijModeling equivalent of the `values()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.keys` and :meth:`Expression.items`.
+        
+        Examples
+        ------
+        Defining a simple objective function which just sums a dictionary-based decision variable.
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> x = problem.IntegerVar("x", dict_keys=I, lower_bound=0, upper_bound=100)
+        >>> problem += x.values().sum()
+        ```
+        """
+    def items(self) -> Expression:
+        r"""
+        Returns an expression representing this object's `(key,value)` pairs.
+        
+        In other words, this is the JijModeling equivalent of the `items()`
+        method on Python dictionaries, used when creating JijModeling
+        expressions.
+        
+        While it's possible to call this on any :class:`Expression`, this is
+        intended for dictionary-like :class:`Placeholder`s and
+        :class:`DecisionVar`s. Using this with an invalid object will lead
+        to an error when the resulting expression is added to a
+        :class:`Problem` and is type-checked.
+        
+        See also :meth:`Expression.keys` and :meth:`Expression.values`.
+        
+        Examples
+        ------
+        Simple matching of weights to their respective variables, as an alternative to just using `keys()` or the `CategoryLabel`:
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> I = problem.CategoryLabel("I")
+        >>> weights = problem.Float("W", dict_keys=I)
+        >>> x = problem.BinaryVar("x", dict_keys=I)
+        >>> problem += jm.sum(weights.items(), lambda i, w: w * x[i])
+        ```
+        
+        Same as above, but using the decorated API:
+        ```python
+        >>> @problem.update
+        ... def _(problem):
+        ...   I = problem.CategoryLabel()
+        ...   W = problem.Float(dict_keys=I)
+        ...   x = problem.BinaryVar(dict_keys=I)
+        ...   problem += jm.sum(w * x[i] for i, w in W.items())
+        ```
+        """
+    def __neg__(self) -> Expression: ...
+    def abs(self) -> Expression:
+        r"""
+        Returns an expression representing the absolute value of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sqrt(self) -> Expression:
+        r"""
+        Returns an expression representing the square root of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sin(self) -> Expression:
+        r"""
+        Returns an expression representing the sine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def cos(self) -> Expression:
+        r"""
+        Returns an expression representing the cosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def tan(self) -> Expression:
+        r"""
+        Returns an expression representing the tangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def asin(self) -> Expression:
+        r"""
+        Returns an expression representing the arcsine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def acos(self) -> Expression:
+        r"""
+        Returns an expression representing the arccosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def atan(self) -> Expression:
+        r"""
+        Returns an expression representing the arctangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def sinh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic sine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def cosh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic cosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def tanh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic tangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def asinh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arcsine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def acosh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arccosine of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def atanh(self) -> Expression:
+        r"""
+        Returns an expression representing the hyperbolic arctangent of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def exp(self) -> Expression:
+        r"""
+        Returns an expression representing the application of the exponential function on the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def ln(self) -> Expression:
+        r"""
+        Returns an expression representing the natural logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def log10(self) -> Expression:
+        r"""
+        Returns an expression representing the decimal logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def log2(self) -> Expression:
+        r"""
+        Returns an expression representing the binary logarithm of the given expression.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def ceil(self) -> Expression:
+        r"""
+        Returns an expression which rounds down to the nearest whole number.
+        
+        Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+        """
+    def floor(self) -> Expression: ...
+    def __add__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __radd__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __sub__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rsub__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __mul__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rmul__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __truediv__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rtruediv__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __mod__(self, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __rmod__(self, lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+    def __pow__(self, exponent: typing.Any, modulo: typing.Optional[typing.Any] = None) -> Expression: ...
+    def __rpow__(self, base: typing.Any, modulo: typing.Optional[typing.Any] = None) -> Expression: ...
+    def __repr__(self) -> builtins.str: ...
+    def _repr_latex_(self) -> builtins.str: ...
+    def len_at(self, index: builtins.int) -> Expression:
+        r"""
+        Returns an expression representing the length (number of values) a
+        placeholder has at a given dimension (0-indexed).
+        
+        This can be used, for example, when trying to match the shape of
+        an object to the number of values in an array.
+        
+        Examples
+        ------
+        
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> V = problem.Integer(name="V", ndim=1)
+        >>> N = V.len_at(0)
+        >>> x = problem.BinaryVar("x", shape=(N,))
+        ```
+        """
+
+@typing.final
+class Problem:
+    r"""
+    A class for creating an optimization problem.
+    
+    Attributes
+    -----------
+    - `name` (`str`): A name of the optimization problem.
+    - `sense` (`ProblemSense`): Sense of the optimization problem.
+    - `objective`: The objective function of the optimization problem.
+    - `constraints` (`dict`): A dictionary that stores constraints.
+      - A key is the name of a constraint and the value is the constraint object.
+    
+    Args
+    -----
+    - `name` (`str`): A name of the optimization problem.
+    - `sense` (optional): Sense of the optimization problem. Defaults to `ProblemSense.MINIMIZE`.
+    - `description` (`str`, optional): An optional description of the problem, for user reference.
+    """
+    @property
+    def objective(self) -> Expression: ...
+    @property
+    def description(self) -> builtins.str:
+        r"""
+        The problem description.
+        
+        An empty string if no description was defined.
+        """
+    @property
+    def constraints(self) -> builtins.dict[builtins.str, builtins.list[Constraint]]:
+        r"""
+        Returns a dictionary of the constraints in the problem.
+        
+        Returns
+        --------
+        `dict[str, [Constraint]]`: Dictionary mapping constraint names to Constraint objects.
+        """
+    @property
+    def used_placeholders(self) -> builtins.list[Placeholder]:
+        r"""
+        A list of the  :class:`Placeholder`s used in expressions composing this problem (objective function and constraints).
+        
+        This does not include placeholders which have been created but never used.
+        """
+    @property
+    def decision_vars(self) -> builtins.dict[builtins.str, DecisionVar]:
+        r"""
+        Returns a dictionary of decision variables in the problem.
+        The dictionary may contain decision variables that are not used in the problem.
+        
+        Returns
+        --------
+        `dict[str, DecisionVar]`: Dictionary mapping variable names to DecisionVar objects.
+        """
+    @property
+    def placeholders(self) -> builtins.dict[builtins.str, Placeholder]:
+        r"""
+        Returns a dictionary of placeholders in the problem.
+        The dictionary may contain placeholders that are not used in the problem;
+        to get only used placeholders, use `used_placeholders` method.
+        
+        Returns
+        --------
+        `dict[str, Placeholder]`: Dictionary mapping placeholder names to Placeholder objects.
+        """
+    def __new__(cls, name: builtins.str, *, sense: ProblemSense = ProblemSense.MINIMIZE, description: typing.Optional[builtins.str] = None) -> Problem: ...
+    @typing.overload
+    def Constraint(self, name: str, expression: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, description: typing.Optional[builtins.str] = None) -> Constraint:
+        r"""
+        Constructs `Constraint` object from comparison expression, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    @typing.overload
+    def Constraint(self, name: str, expression: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], domain: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, description: typing.Optional[builtins.str] = None) -> Constraint:
+        r"""
+        Constructs ``Constraint`` family with the index set ``domain`` and function ``expression`` to build comparison expression from each index, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    def get_problem_schema(self) -> dict:
+        r"""
+        Returns the schema of the problem.
+        
+        Returns
+        --------
+        - `schema`: The dictionary containing the schema of the problem.
+        """
+    def generate_random_dataset(self, _default: typing.Any, _options: typing.Any, _seed: typing.Optional[builtins.int]) -> typing.Any:
+        r"""
+        Generates a dictionary of random `InstanceDataValue` for a given problem.
+        To generate `ommx.v1.Instance` object directly, use `InstanceDataValue.generate_random_instance` instead.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" below).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        
+        Returns
+        --------
+        `dict`: The dictionary from the name of placeholders to the generated `InstanceDataValue` objects. To be fed to `Interpreter.eval_problem`.
+        
+        Range Parameters and Range Syntax
+        ----------------------------------
+        A range parameter is a dictionary consisting of the following fields:
+        - `size` (optional): interval of natural numbers for the size of each array dimension (default: `range(1, 6)`)
+        - `value` (optional): interval of real numbers for the value of each array element (default: `range(-1.0, 1.0)` - a uniform distribution on a closed interval $[-1.0, 1.0]$).
+        
+        Example range parameter config:
+        
+        ```python
+        {"size": range(2, 10), "value": jm.range.value.closed(100.0, 200.0)}
+        ```
+        
+        Intervals are expressed as a range object.
+        Currently, the following syntax is supported for range objects:
+        
+        1. Direct value of type `int` or `float` - it corresponds to a singleton interval $[a, a] = \{a\}$. In random generation context, this just means a constant fixed value.
+        2. Use the functions from `jijmodeling.range`, `jijmodeling.range.size`, or `jijmodeling.range.value` modules.
+           - Use functions from `jij.modeling.range.size` to specify (non-negative) integer intervals, and `jij.modeling.range.value` for real intervals. `jij.modeling.range` dynamically determines the type of the range based on the input.
+           - These three modules provides the following combinators (see the module documents for more details.):
+                    - `closed(a, b)`: a closed interval $[a, b]$
+                    - `open(a, b)`: an open interval $(a, b)$
+                    - `closed_open(a, b)`: an upper half-open interval $[a, b)$
+                    - `open_closed(a, b)`: a lower half-open interval $(a, b]$
+                    - `greater_than(a)`: an open interval $(a, \infty)$
+                    - `at_least(a)`: a closed interval $[a, \infty)$
+                    - `less_than(a)`: an open interval $(-\infty, a)$
+                    - `at_most(a)`: a closed interval $(-\infty, a]$
+        3. Use `range` builtin function: this is equivalent to `jijmodeling.range.value.closed_open(a, b)`.
+           - Any python range object with `step = 1` can be used as a size range; otherwise it results in runtime error.
+        4. Use a tuple: raw tuple `(a, b)` is equivalent to `jijmodeling.range.closed_open(a, b)` if `a` and `b` are either `int` or `float`.
+           - You can also use bound object as a tuple component; in such case, both tuple components must be one of the following:
+        
+                1. A string `"Unbounded"` means $-\infty$ (in the first component) or $\infty$ (the second).
+                2. A dictionary `{"Included": a}` means the endpoint is inclusive.
+                3. A dictionary `{"Excluded": a}` means the endpoint is exclusive.
+           - Examples:
+                    - `(1.2, 4)` is equivalent to `closed_open(1.2, 4)`,
+                    - `(-1, {"Included": 1})` is equivalent to `closed(-1, 1)`,
+                    - `(-5, {"Excluded": 4})` is equivalent to `closed_open(-5, 4)` and built in function `range(-5, 4)`,
+                    - `({"Excluded": 1}, {"Excluded": 2.5})` is equivalent to `open(1, 2.5)`,
+                    - `({"Included": -1}, "Unbounded")` is equivalent to `at_least(-1)`.
+                    - `(5, "Unbounded")` is **INVALID**; `5` must be bound object.
+        5. The range object: A dictionary of form `{"start": lb, "end": ub}`, where both `lb` and `ub` are the bound object described as above.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> inputs = problem.generate_random_dataset(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...          # You can also specify "size" for the range of jagged array dimension size.
+        ...     },
+        ...     seed=123 # omittable
+        ... )
+        >>> assert set(inputs.keys()) == {"N", "c"}
+        >>> inputs
+        {'N': 11.0, 'c': array([ 0.93914459, -0.06511935, -0.7460324 , -0.32443706,  0.99981451,
+               -0.24407535,  0.31329469,  0.52206453, -0.1291936 ,  0.30443087,
+                0.53125838])}
+        
+        ```
+        """
+    def generate_random_instance(self, _default: typing.Any, _options: typing.Any, _seed: typing.Optional[builtins.int], _hints: typing.Optional[typing.Any]) -> typing.Any:
+        r"""
+        Generates random `ommx.v1.Instance` for a given problem.
+        See also `InstanceDataValue.generate_random_dataset`.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" section in :func:`~jijmodeling.Problem.generate_random_dataset`).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        - `hints` (optional): the hints to be detected during compilation see `Interpreter.eval_problem` for more details.
+        
+        Returns
+        --------
+        `instance`: The OMMX v1 instance object.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> import ommx.v1
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> instance = problem.generate_random_instance(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...     },
+        ...     seed=123
+        ... )
+        >>> assert type(instance) is ommx.v1.Instance
+        
+        ```
+        """
+    def type_of(self, name: builtins.str) -> typing.Optional[Type]:
+        r"""
+        Returns the type associated with a given name (eg. of a placeholder or decision variable).
+        
+        This is mostly inteded for testing purposes, and not as part of standard model writing.
+        
+        :raises ModelingError: If the name is undefined in this problem's namespace.
+        """
+    def infer(self, expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Type:
+        r"""
+        Infers the resulting type of an expression using this problem as a namespace.
+        
+        This is mostly intended for testing purposes, and not as part of standard model writing.
+        
+        Examples
+        ===
+        ```python
+        >>> problem = jm.Problem("MyProblem")
+        >>> N = problem.Length(name="N")
+        >>> x = problem.BinaryVar("x", shape=(N,))
+        >>> y = problem.IntegerVar("y", shape=(N,), lower_bound=0,upper_bound=10)
+        >>> problem.infer(jm.sum(x))
+        binary!
+        >>> problem.infer(jm.sum(y))
+        int!
+        ```
+        """
+    @typing.overload
+    def Placeholder(self, name: str, *, dtype: DataType | type | tuple, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: bool = False, description: typing.Optional[builtins.str] = None, latex: typing.Optional[builtins.str] = None) -> Placeholder: ...
+    @typing.overload
+    def Placeholder(self, name: str, *, dtype: DataType | type | tuple, dict_keys: DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, description: typing.Optional[builtins.str] = None, latex: typing.Optional[builtins.str] = None) -> Placeholder: ...
+    @typing.overload
+    def Placeholder(self, name: str, *, dtype: DataType | type | tuple, dict_keys: DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, partial_dict: typing.Literal[False], description: typing.Optional[builtins.str] = None, latex: typing.Optional[builtins.str] = None) -> Placeholder: ...
+    @typing.overload
+    def Placeholder(self, name: str, *, dtype: DataType | type | tuple, dict_keys: DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple, partial_dict: typing.Literal[True], description: typing.Optional[builtins.str] = None, latex: typing.Optional[builtins.str] = None) -> Placeholder: ...
+    @typing.overload
+    def Placeholder(self, name: str, *, dtype: DataType | type | tuple, dict_keys: DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple, partial_dict: builtins.bool, description: typing.Optional[builtins.str] = None, latex: typing.Optional[builtins.str] = None) -> Placeholder: ...
+    @typing.overload
+    def Placeholder(self, name: str, *, dtype: DataType | type | tuple, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, description: typing.Optional[builtins.str] = None, latex: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` in this problem's namespace.
+        
+        Placeholders can be a scalar, multi-dimensional array (representing arrays and
+        matrices), or dictionary keyed by integers or strings.
+        
+        When calling `Problem.Placehoder`, you must specify `dtype` explicitly to indicate the type of data the placeholder holds.
+        Alternative shorthand methods like `Problem.Integer`, `Problem.Binary`,
+        or `Problem.Natural` are recommended for convenience in their specific
+        use cases.
+        
+        Representation
+        --------------
+        Depending on the arguments described below, the representation of the placeholder will be determined as follows:
+        
+        1. If none of `ndim`, `shape`, `jagged`, `dict_keys`, or `partial_dict` is provided, or, `ndim` is set to zero, Placeholder will be considered as a scalar value (= array of dimension 0).
+        2. If either (or both consistently) of `ndim` or `shape` is provided and `jagged` is `False` (or omitted), and none of `dict_keys` or `partial_dict` is given, Placeholder will be considered as a multi-dimensional array with fixed shape.
+        3. If either (or both consistently), of `ndim` or `shape` is provided and `jagged` is `True`, and none of `dict_keys` or `partial_dict` is given,Placeholder will be considered as a jagged array (i.e. a non-rectangular ndim array).
+        4. If `dict_keys` is specified but none of `ndim`, `shape`, `jagged` is provided, then Placeholder will be considered as a total dictionary-like structure with keys specified by `dict_keys`.
+        5. If both `dict_keys` and `partial_dict` (set to `True`) are specified, and none of `ndim`, `shape`, or `jagged` is provided, then Placeholder will be considered as a partial dictionary-like structure with keys specified by `dict_keys`.
+        6. Otherwise, an error is raised.
+        
+        Args
+        -----
+        - `name` (`str`): The placeholder's name
+        - `dtype` (`DataType`): The type of data this placeholder holds (integer, floating point, etc.).
+        - `ndim` (`int`): The number of dimensions in this placeholder. Defaults to 0 (a scalar value).
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the placeholder. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+          - There is no need to provide `ndim` if `shape` is specified, but they must not conflict if both specified.
+        - `jagged` (`bool`): Whether this placeholder represents a jagged array (ie. a non-square matrix). Ignored if scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this placeholder represents a dictionary-like structure with keys `dict_keys`.
+        - `partial_dict` (`bool`, optional): If `dict_keys` is provided, specifies whether this placeholder represents a partial dictionary (i.e., not all keys are guaranteed to be present). Defaults to `False`.
+        - `latex` (`str`, optional): An optional LaTeX representation to be used in Jupyter notebook.
+          - When not provided, `name` is used by default.
+        - `description` (`str`, optional): An optional description for user reference.
+        
+        Examples
+        ---------
+        Create a scalar integer placeholder whose name is "a".
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> a = problem.Placeholder("a", dtype=jm.DataType.INTEGER)
+        ```
+        
+        Create a 2-dimensional floating-point placeholder whose name is "y" and has a 2x2 shape.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> y = problem.Float("x", shape=(2, 2))
+        ```
+        """
+    def Integer(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing an integer in this problem's namespace.
+        
+        A shorthand for `Problem.Placeholder(dtype=DataType.INTEGER)`, provided for clarity and convenience.
+        See `Problem.Placeholder` for more details on placeholders.
+        """
+    def Float(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a floating-point (real) number in this problem's namespace.
+        
+        A shorthand for `Problem.Placeholder(dtype=DataType.FLOAT)`, provided for clarity and convenience.
+        See `Problem.Placeholder` for more details on placeholders.
+        """
+    def Natural(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a natural number in this problem's namespace.
+        
+        A shorthand for `Problem.Placeholder(dtype=DataType.NATURAL)`, provided for clarity and convenience.
+        See `Problem.Placeholder` for more details on placeholders.
+        """
+    def Length(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = 0, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a natural number in this problem's namespace.
+        
+        This is just a shorthand for `Problem.Natural(ndim=0)` and effectively the same as any other natural
+        placeholder for practical purposes. The use of `Length` is recommended just for clarity when
+        defining a placeholder which will be used to define the length of multi-dimensional objects.
+        
+        See `Problem.Placeholder` for more details on placeholders.
+        """
+    def Dim(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = 0, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a :class:`Placeholder` representing a natural number in this problem's namespace.
+        
+        This is just a shorthand for `Problem.Natural(ndim=0)` and effectively the same as any other natural
+        placeholder for practical purposes. The use of `Dim` is recommended just for clarity when
+        defining a placeholder which will be used to define the length of multi-dimensional objects.
+        
+        See `Problem.Placeholder` for more details on placeholders.
+        """
+    def Binary(self, name: builtins.str, *, ndim: typing.Optional[builtins.int] = None, shape: typing.Optional[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Sequence[typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]]] = None, jagged: builtins.bool = False, dict_keys: typing.Optional[DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple] = None, partial_dict: typing.Optional[builtins.bool] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        Defines a `Placeholder` representing a binary number in this problem's namespace.
+        
+        A shorthand for `Problem.Placeholder(dtype=DataType.BINARY)`, provided for clarity and convenience.
+        See `Problem.Placeholder` for more details on placeholders.
+        """
+    def PartialDict(self, name: builtins.str, *, dtype: DataType | type | tuple, dict_keys: DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        A shorthand for creating a partial dictionary placeholder with key type
+        """
+    def TotalDict(self, name: builtins.str, *, dtype: DataType | type | tuple, dict_keys: DataType | type | CategoryLabel | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | tuple, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        A shorthand for creating a total dictionary placeholder with key type
+        """
+    def Graph(self, name: builtins.str, *, dtype: DataType | type | tuple = DataType.NATURAL, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> Placeholder:
+        r"""
+        A placeholder expressing a directed graph (without edge weights), represented by a 1-dimensional array of tuples.
+        
+        A shorthand for `Problem.Placeholder(dtype=(vertex, vertex), ndim=1)`.
+        By default `vertex` is `DataType.Natural` but can be specified.
+        """
+    def DecisionVar(self, name: builtins.str, *, kind: DecisionVarKind, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a :class:`DecisionVar` and registers it to the problem namespace.
+        
+        Decision variables can be scalars, multi-dimensional arrays (eg.
+        representing arrays and matrices of variables), or total dictionaries.
+        Variables must have a `DecisionVarKind` (such as `BINARY`, `INTEGER`,
+        `CONTINUOUS`), as well as defined lower and upper bounds.
+        
+        See :class:`DecisionVar` documentation for more general info on decision
+        variables, their representation, and bounds.
+        
+        We recommend using alternative convenience methods which predefine the
+        decision variable's kind, such as `Problem.IntegerVar` for integers, or
+        `Problem.BinaryVar` for binary variables.
+        
+        Representation
+        --------------
+        Depending on the arguments described below, the representation of the decision variable will be determined as follows:
+        
+        1. If none of `shape` or `dict_keys` is provided, or `shape` is `()`, DecisionVar will be considered as a scalar value (= array of dimension 0).
+        2. If `shape` is provided and `dict_keys` is not provided, DecisionVar will be considered as a multi-dimensional array with fixed shape.
+        3. If `dict_keys` is provided without `shape`, DecisionVar will be considered as a dictionary-like structure with keys specified by `dict_keys`.
+        4. Otherwise, an error is raised.
+        
+        Args
+        -----
+        - `name` (`str`): A name for the binary variable.
+        - `kind` (`DecisionVarKind`): A kind of the decision variable.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `lower_bound` and `upper_bound` (`jijmodeling.Expression`): A lower and upper bounds of the variable.
+        - `kind` (`DecisionVarKind`): The kind of the decision variable.
+        - `latex` (`str`, optional): An optional LaTeX representation to be used in Jupyter notebook.
+          - It is set to be the same as `name` by default.
+        - `description` (`str`, optional): An optional description, for user reference.
+        
+        Examples
+        ---------
+        Create a scalar binary variable whose name is "z".
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> z = problem.DecisionVar("z", kind=jm.DecisionVarKind.BINARY, lower_bound=0, upper_bound=1)
+        
+        ```
+        
+        Create a 2-dimensional binary variable whose name is "x" and has a 2x2 shape.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> x = problem.BinaryVar("x", shape=[2, 2])
+        
+        ```
+        
+        Create a 1-dimensional binary variable with the index of `123`.
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("my_problem")
+        >>> x = jm.BinaryVar("x", shape=[124])
+        >>> x[123]
+        BinaryVar(name='x', shape=[NumberLit(value=124)])[NumberLit(value=123)]
+        
+        ```
+        """
+    def BinaryVar(self, name: builtins.str, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a binary decision variable and registers it to the problem namespace. See `Problem.DecisionVar` for more details.
+        
+        A shorthand for `Problem.DecisionVariable(dtype=DecisionVarKind.BINARY,
+        lower_bound=0, upper_bound=1)`, provided for clarity and convenience.
+        
+        Args
+        -----
+        - `name` (`str`): A name of the binary variable.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the binary variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `latex` (`str`, optional): A LaTeX-name of the binary variable to be represented in Jupyter notebook.
+          - It is set to `name` by default.
+        - `description` (`str`, optional): A description of the binary variable.
+        """
+    def IntegerVar(self, name: builtins.str, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines an integer decision variable and registers it to the problem namespace. See `Problem.DecisionVar` for more details.
+        
+        This is shorthand for `Problem.DecisionVariable(kind=DecisionVarKind.INTEGER)`.
+        
+        Args
+        -----
+        - `name` (`str): A name of the integer variable.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the integer variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `lower_bound`: The lower bound of the variable.
+        - `upper_bound`: The upper bound of the variable.
+        - `latex` (`str`, optional): A LaTeX-name of the integer variable to be represented in Jupyter notebook.
+          - It is set to `name` by default.
+        - `description` (`str`, optional): A description of the integer variable.
+        
+        Raises
+        -------
+        `ModelingError`: Raises if a bound is a `Placeholder` or `Subscript` object whose `ndim`
+        is neither `0` nor the same value as `ndim` of the integer variable.
+        """
+    def SemiIntegerVar(self, name: builtins.str, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a semi-integer decision variable and registers it to the problem namespace. See :class:`DecisionVar` for more details.
+        
+        This is shorthand for `Problem.DecisionVariable(kind=DecisionVarKind.SEMI_INTEGER)`.
+        """
+    def ContinuousVar(self, name: builtins.str, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar:
+        r"""
+        Defines a continuous decision variable and registers it to the problem namespace. See `Problem.DecisionVar` for more details.
+        
+        This is shorthand for `problem.DecisionVariable(dtype=DecisionVarKind.CONTINUOUS)`.
+        
+        Args
+        -----
+        - `name` (`str`): A name of the continuous variable.
+        - `shape` (`list | tuple`): A sequence with the size of each dimension of the continuous variable. Defaults to an empty tuple (a scalar value).
+          - Each item in `shape` must be a valid expression evaluating to a non-negative scalar.
+        - `dict_keys` (`tuple[Expression, ...]`, optional): If provided, specifies that this variable represents a dictionary-like structure with keys `dict_keys`.
+        - `lower_bound`: The lower bound of the variable.
+        - `upper_bound`: The upper bound of the variable.
+        - `latex` (`str`, optional): A LaTeX-name of the continuous variable to be represented in Jupyter notebook.
+          - It is set to `name` by default.
+        - `description` (`str`, optional): A description of the continuous variable.
+        
+        Raises
+        -------
+        `ModelingError`: Raises if a bound is a `Placeholder` or `Subscript` object whose `ndim` is neither `0` nor the same value as `ndim` of the continuous variable.
+        """
+    def SemiContinuousVar(self, name: builtins.str, *, shape: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict]] = None, dict_keys: typing.Optional[DataType | type | Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None, lower_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], upper_bound: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> DecisionVar: ...
+    def namespace(self) -> Namespace:
+        r"""
+        Access to the internal `Namespace` associated with this problem.
+        
+        Accessing this directly is not normally necessary for regular users.
+        """
+    def CategoryLabel(self, name: builtins.str, *, latex: typing.Optional[builtins.str] = None, description: typing.Optional[builtins.str] = None) -> CategoryLabel:
+        r"""
+        Add a new opaque category label to the namespace.
+        
+        A category label corresponds to a set of labels representing some specific category (e.g. the name of percels, or the ids of factors, etc).
+        A value of category label is treated opaque in JijModeling, and can only be tested for equality / non-equality and used as keys in dictionary-like structures.
+        
+        :class:`CategoryLabel` objects can be created via :meth:`Problem.CategoryLabel`.
+        The concrete values should be given in `instance_data` dictionary together with placeholder values when creating a :class:`Compiler` object or in `Problem.eval`.
+        In `instance_data`, category label should be given a list of either strings or integers.
+        
+        Args
+        ----
+        - `name` (`str`): The name of the category label.
+        - `latex` (`str`, optional): An optional LaTeX representation to be used in Jupyter notebook.
+          - When not provided, `name` is used by default.
+        - `description` (`str`, optional): An optional description for user reference.
+        """
+    def update(self, func: typing.Callable[[DecoratedProblem]]) -> DesugaredProblemBuilder:
+        r"""
+        A function decorator to modify an existing `Problem` using the decorated API.
+        
+        This must be decorated to a function that takes `DecoratedProblem` as
+        the only argument and returns None. You can call `update` multiple
+        times.
+        
+        The given function will automatically be evaluated exactly once by the
+        decocrator, so you DO NOT need to call the original function again.
+        
+        Example
+        -------
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> problem = jm.Problem("Knapsack Problem", sense=jm.ProblemSense.MAXIMIZE)
+        >>>
+        >>> @problem.update
+        >>> def my_updater(problem: jm.DecoratedProblem):
+        >>>     w = problem.Float(ndim=1, description="Weights of the items")
+        >>>     N = w.len_at(0)
+        >>>     v = problem.Float(ndim=1, description="Values of the items")
+        >>>     W = problem.Float(description="Total weight")
+        >>>     x = problem.BinaryVar(shape=(N,), description="Selected items")
+        >>>
+        >>>     problem += problem.Constraint("weight", jm.sum(w * x) <= W)
+        >>>     problem += jm.sum(v * x)
+        >>>
+        >>> w_data = [10, 20, 30]
+        >>> v_data = [60, 100, 120]
+        >>> instance_data = {"w": w_data, "v": v_data, "W": 50}
+        >>> instance = problem.eval(instance_data)
+        ```
+        """
+    def eval(self, instance_data: typing.Mapping[builtins.str, builtins.int | builtins.float | numpy.typing.NDArray[numpy.float64] | numpy.typing.NDArray[numpy.int64] | list | dict | builtins.str], *, constraint_hints: typing.Optional[ConstraintDetectionConfig] = None) -> ommx.v1.Instance:
+        r"""
+        Compiles and evaluates the problem given the specified instance data, returning an OMMX instance.
+        
+        A short-hand of `Compiler.from_problem(self, data).eval_problem(self)`.
+        
+        Args
+        ----
+        - `instance_data` (`dict[str, InstanceValue]`): A dictionary mapping placeholder and category label names to their corresponding values for this instance. See :class:`Compiler` for more details on the expected format of `instance_data`.
+        """
+    def __repr__(self) -> builtins.str: ...
+    def _repr_latex_(self) -> builtins.str: ...
+    @typing.overload
+    def __iadd__(self, other: Constraint) -> Problem:
+        r"""
+        Add constraint to the problem.
+        """
+    @typing.overload
+    def __iadd__(self, other: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Problem:
+        r"""
+        Add an expression as a term to the objective function of the problem.
+        """
+
+@typing.final
+class Type:
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+
+class TypeError(builtins.Exception):
+    ...
+
+@typing.final
+class ConstraintHintName(enum.Enum):
+    OneHot = ...
+
+@typing.final
+class ConstraintSense(enum.Enum):
+    r"""
+    Classification of a constraint based on the comparison used.
+    
+    Constraints can be
+    - `lhs == rhs` Equalities: `ConstraintSense.EQUAL`
+    - `lhs <= rhs` Inequalities: `ConstraintSense.LESS_THAN_EQUAL
+    - `lhs >= rhs` Inequalities: `ConstraintSense.GREATER_THAN_EQUAL`
+    """
+    EQUAL = ...
+    LESS_THAN_EQUAL = ...
+    GREATER_THAN_EQUAL = ...
+
+@typing.final
+class DataType(enum.Enum):
+    r"""
+    The type of values in the instance data.
+    
+    Used to specify the types of values :class:`Placeholder` will be able to
+    hold. This type is used for type checking and error detection, particularly
+    when compiling models into ommx instances -- not allowing data of the wrong
+    kind to be used in a given placeholder. This is also used when trying to
+    generate random instances from a model.
+    
+    Placeholders may also have tuples of `DataType`s as their types, eg.
+    `(DataType.NATURAL, DataType.NATURAL)` for representing edges in a graph.
+    """
+    INTEGER = ...
+    FLOAT = ...
+    BINARY = ...
+    NATURAL = ...
+
+@typing.final
+class DecisionVarKind(enum.Enum):
+    r"""
+    The type of values a decision variable may have.
+    
+    The larger domain, before being restricted by the upper and lower bounds
+    
+    - Binary variables may only be either 1 or 0. (other bounds will lead to errors).
+    - Integer variables can only be discrete integers withing the upper/lower bound range.
+    - Continuous variables can be any real number within the bounded range.
+    - Semi-Integer and Semi-Continuous are like the above, but always accept "0" as a value. Support for these in tooling is limited.
+    """
+    BINARY = ...
+    INTEGER = ...
+    CONTINUOUS = ...
+    SEMI_INTEGER = ...
+    SEMI_CONTINUOUS = ...
+
+@typing.final
+class ProblemSense(enum.Enum):
+    r"""
+    An optimization sense
+    
+    Specifies whether the problem is a minization or maximization problem.
+    Mostly used in the constructor for :class:`Problem`, or obtained from
+    an existing problem through `Problem.sense()`
+    """
+    MINIMIZE = ...
+    MAXIMIZE = ...
+
+def Some(inner: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def abs(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the absolute value of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def acos(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the arccosine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def acosh(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the hyperbolic arccosine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def asin(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the arcsine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def asinh(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the hyperbolic arcsine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def atan(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the arctangent of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def atanh(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the hyperbolic arctangent of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def band(lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def bnot(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def bor(lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def ceil(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression which rounds down to the nearest whole number.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def cos(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the cosine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def cosh(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the hyperbolic cosine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def diff(lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def exp(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the application of the exponential function on the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def filter(predicate: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression that filters the values of another sequence expression.
+    
+    `predicate` will be called on each element in `operand`. The resulting
+    expression represents only the values for which `predicate` is true.
+    
+    This parallels python's built-in `filter()` function, but made to work with
+    JijModeling sequence expressions.
+    
+    This is often useful when trying to create summations which only include a
+    subset of potential indices. The resulting expression is usually used as the
+    basis for :func:`jijmodeling.map`, :func:`jijmodeling.sum`, etc., or a
+    method equivalent.
+    
+    See also the method equivalents: :meth:`Placeholder.filter`,
+    :meth:`DecisionVar.filter` and :meth:`Expression.filter`.
+    
+    Examples
+    ------
+    
+    Using only variables with even indices as part of a constraint.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = jm.Natural("N")
+    >>> x = problem.BinaryVar("x", shape=(N, N))
+    >>> even_xs = jm.filter(lambda i: i % 2 == 0, N).map(lambda i: x[i])
+    >>> problem += problem.Constraint("constr", even_xs.sum() < 10)
+    ```
+    
+    Using only non-diagonal indices of an NxN matrix as part of a constraint, using the method version of `filter`.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = jm.Natural("N")
+    >>> x = problem.BinaryVar("x", shape=(N, N))
+    >>> W = problem.Float("W", shape=(N, N))
+    >>> non_diagonals = jm.product(N, N).filter(lambda i, j: i != j)
+    >>> problem += problem.Constraint("constr", lambda i, j: W[i, j] * x[i, j] <= 100, domain=non_diagonals)
+    ```
+    """
+
+def flat_map(func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], arg: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression which works like :func:`jijmodeling.map`, but flattens nested structure.
+    
+    `map` is useful when `func` returns scalar values, but in some situations
+    one wants to write a `func` that returns other mappings/sequences instead.
+    That is where `flat_map` should be used, "flattening" all
+    sequences/iterators into a single linear sequence (which can then be reduced
+    with :func:`jijmodeling.sum`, etc.)
+    
+    You can also compare `flat_map` to a nested for-loop, or a generator
+    expression that uses two `for` clauses. Indeed when using the decorated API
+    (see tutorials or :meth:`Problem.update`), you can use a generator
+    expression-like syntax instead.
+    
+    See also the method equivalents: :meth:`Placeholder.flat_map`,
+    :meth:`DecisionVar.flat_map` and :meth:`Expression.flat_map`. Using the
+    methods often leads to code that is easier to read. Note that the method is
+    not available for number literals.
+    
+    Examples
+    ------
+    
+    Using only non-diagonal indices of an NxN matrix.
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = jm.Natural("N")
+    >>> x = problem.BinaryVar("x", shape=(N, N))
+    >>> W = problem.Float("W", shape=(N, N))
+    >>> objective = jm.flat_map(
+    ...    lambda i: N.filter(lambda j: i != j).map(lambda j: W[i, j] * x[i, j]), N
+    ... ).sum()
+    >>> problem += objective
+    ```
+    """
+
+def floor(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def indices(array: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Get the set of indices of given array or jagged array.
+    
+    Will throw type error when called on non-array type.
+    """
+
+def is_same(src: typing.Any, dst: typing.Any) -> builtins.bool:
+    r"""
+    Return `true` if `src` and `dst` are the same object defined by Jijmodeling.
+    
+    
+    Args
+    -----
+    - `src`: An object defined by Jijmodeling module, or an iterable of Jijmodeling objects.
+    - `dst`: An object defined by Jijmodeling module, or an iterable of Jijmodeling objects.
+    
+    Returns
+    --------
+    `bool`: `true` if `src` and `dst` is the same object. Otherwise `false`.
+    
+    Examples
+    ---------
+    Check if the two placeholders are the same.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("problem")
+    >>> a = problem.Placeholder("name")
+    >>> b = problem.Placeholder("name")
+    >>> assert jm.is_same(a, b)
+    >>> c = problem.Placeholder("name", ndim=2)
+    >>> assert not jm.is_same(a, c) # the value of `ndim` is different
+    ```
+    
+    Raises
+    -------
+    `TypeError`: Raises if
+    - `src` and `dst` are of different types which are not iterable
+    - called on a type not defined by Jijmodeling (e.g. `str`)
+    
+    Note
+    -----
+    This function does not check the following attributes:
+    - `description`
+    - `latex`
+    
+    For example,
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("problem")
+    >>> src = problem.Placeholder("placeholder", latex="src")
+    >>> dst = problem.Placeholder("placeholder", latex="dst")
+    >>> assert jm.is_same(src, dst)
+    ```
+    
+    this code works without any exception.
+    """
+
+def items(dict: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the `(key,value)` pairs of a
+    dictionary-like :class:`Expression`.
+    
+    In other words, this is the JijModeling equivalent of the `items()` method on Python dictionaries,
+    used when creating JijModeling expressions.
+    
+    While it's possible to call this on any :class:`Expression`, this is
+    intended for dictionary-like :class:`Placeholder`s and
+    :class:`DecisionVar`s. Using this with an invalid object will lead to an
+    error when the resulting expression is added to a :class:`Problem` and is
+    type-checked.
+    
+    See also :meth:`Placeholder.items`, :meth:`DecisionVar.items`, and
+    :meth:`Expression.items` to achieve this with methods, which are recommended
+    for clarity.
+    
+    If you want to refer to the keys used in the dictionary, use
+    :func:`jijmodeling.keys` or its method equivalents. If you want the
+    dictionary's values, use :func:`jijmodeling.values` or its method
+    equivalents instead.
+    """
+
+def keys(dict: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the keys of a dictionary-like
+    :class:`Expression`.
+    
+    In other words, this is the JijModeling equivalent of the `keys()` method on
+    Python dictionaries, used when creating JijModeling expressions.
+    
+    While it's possible to call this on any :class:`Expression`, this is
+    intended for dictionary-like :class:`Placeholder`s and
+    :class:`DecisionVar`s. Using this with an invalid object will lead to an
+    error when the resulting expression is added to a :class:`Problem` and is
+    type-checked.
+    
+    See also :meth:`Placeholder.keys`, :meth:`DecisionVar.keys`, and
+    :meth:`Expression.keys` to achieve this with methods, which is recommended for
+    clarity.
+    
+    If you want to refer to the dictionary's values, use
+    :func:`jijmodeling.values` or its method equivalents. If you want key-value
+    pairs, use :func:`jijmodeling.items` or its method equivalents instead.
+    """
+
+def ln(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the natural logarithm of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def log10(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the decimal logarithm of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def log2(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the binary logarithm of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def map(func: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], arg: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression that maps `func` to a sequence of values.
+    
+    This parallels python's built-in `map()` function, but made to work with
+    and create JijModeling expressions.
+    
+    If `arg` is a number literal or scalar placeholder, each number from 0 to
+    `arg` will be passed to `func`. If `arg` is a sequence expression (eg. a
+    1-dimensional placeholder, or the result of functions like
+    :func:`jijmodeling.product` or :func:`jijmodeling.items`), each element in
+    the sequence is passed to `func`.
+    
+    This is mostly used alongside lambdas as a way to access individual values
+    within array-like or dictionary-like :class:`Placeholder`s and
+    :class:`DecisionVar`s. The resulting expression is then usually passed to a
+    reducer, like :func:`jijmodeling.sum` (or :meth:`Expression.sum` is called
+    on it), to form part of a constraint or the objective function.
+    
+    See also the method equivalents: :meth:`Placeholder.map`,
+    :meth:`DecisionVar.map` and :meth:`Expression.map`. Using the methods often
+    leads to code that is easier to read. Note that the method is not available
+    for number literals.
+    
+    Examples
+    ------
+    
+    Indexing by values from 0 to N. In this example we define N as the length of
+    another placeholder, but a scalar Natural placeholder would work as well.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> W = problem.Float("W", ndim=1)
+    >>> N = W.len_at(0)
+    >>> x = problem.BinaryVar("x", shape=N)
+    >>> problem += jm.sum(jm.map(lambda i: W[i] * x[i], N))
+    >>> # or, same as above
+    >>> problem += jm.map(lambda i: W[i] * x[i], N).sum()
+    >>> # same as above but using method on N instead of this function:
+    >>> problem += N.map(lambda i: W[i] * x[i]).sum()
+    ```
+    
+    Indexing by specific values from instance data. In this example only the
+    indices present in `C` in the instance data will be used in this constraint.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = problem.Natural("N")
+    >>> x = problem.IntegerVar("x", shape=N, lower_bound=0, upper_bound=10)
+    >>> C = problem.Natural("C", ndim=1)
+    >>> problem += problem.Constraint("constr", jm.map(lambda i: x[i], C).sum() <= 100)
+    ```
+    
+    Accessing category label keys. Dictionary-like placeholders &
+    decision-variables require keys from the appropriate :class:`CategoryLabel`,
+    which are accessed by mapping.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> I = problem.CategoryLabel("I")
+    >>> W = problem.Float("W", dict_keys=I)
+    >>> x = problem.BinaryVar("x", dict_keys=I)
+    >>> problem += jm.sum(jm.map(lambda i: W[i] * x[i], I))
+    ```
+    
+    Or, using `items()` on a dictionary placeholder:
+    ```python
+    >>> problem = jm.Problem("MyProblem")
+    >>> I = problem.CategoryLabel("I")
+    >>> W = problem.Float("W", dict_keys=I)
+    >>> x = problem.BinaryVar("x", dict_keys=I)
+    >>> problem += jm.map(lambda i, w: w * x[i], W.items())
+    ```
+    """
+
+def map_or_else(option: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, default: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, mapper: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    If option is `Some(value)`, applies `mapper(value)`, otherwise returns default.
+    """
+
+@typing.overload
+def max(lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression that refers to the largest value among `lhs` and `rhs`.
+    
+    See also the method equivalents :meth:`Placeholder.max`, :meth:`DecisionVar.max`, and :meth:`Expresion.max`.
+    """
+
+@typing.overload
+def max(operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression which refers to the largest of several values.
+    
+    This overload variant accepts a single sequence expression (eg. a one-dimensional placeholder
+    or a :func:`map`ping) as an argument, and the resulting expression is a scalar representing
+    the largest among all values in the sequence.
+    
+    See also the method equivalents :meth:`Placeholder.max`, :meth:`DecisionVar.max`, and :meth:`Expresion.max`.
+    """
+
+@typing.overload
+def min(lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression that refers to the smallest value among `lhs` and `rhs`.
+    
+    See also the method equivalents :meth:`Placeholder.min`, :meth:`DecisionVar.min`, and :meth:`Expresion.min`.
+    """
+
+@typing.overload
+def min(operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates an expression which refers to the smallest of several values.
+    
+    This overload variant accepts a single sequence expression (eg. a one-dimensional placeholder
+    or a :func:`map`ping) as an argument, and the resulting expression is a scalar representing
+    the smallest among all values in the sequence.
+    
+    See also the method equivalents :meth:`Placeholder.min`, :meth:`DecisionVar.min`, and :meth:`Expresion.min`.
+    """
+
+def neg(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def or_else(option: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, default: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns the value inside option if Some, otherwise returns default.
+    """
+
+@typing.overload
+def prod(x: typing.Generator["Expression", None, None]) -> Expression:
+    r"""
+    Comprehension syntax for :func:`jijmodeling.prod`, for use with decorated API.
+    
+    When using the decorated API, you are allowed to use a comprehension/generator
+    expression directly inside `prod`, using `for` clauses to mark the index.
+    
+    NOTE: do not confuse with :func:`jijmodeling.product`. This is a sequence
+    multiplication (like capital-PI notation). `product` is the cartesian product.
+    
+    NOTE: this variant only works with decorated API!
+    
+    See :meth:`Problem.update` or the cheatsheet for more information on the decorated API.
+    
+    Examples
+    ------
+    
+    ```python
+    >>> problem = jm.Problem("MyProblem", sense=jm.ProblemSense.MINIMIZE)
+    >>> @problem.update
+    >>> def _(problem: jm.DecoratedProblem):
+    ...   N = problem.Placeholder(dtype=jm.DataType.NATURAL)
+    ...   x = problem.BinaryVar(shape=N)
+    ...   C = problem.Placeholder(ndim=1, dtype=np.uint64)
+    ...   problem += jm.prod(x[i] for i in C)
+    >>>
+    ```
+    """
+
+@typing.overload
+def prod(operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None) -> Expression:
+    r"""
+    Creates an expression representing the multiplication of a sequence expression.
+    
+    `prod`, though less common than `sum` is a fundamental part of building models,
+    used as a reducer to collapse multiple values into a single value. Everything
+    that applies to `sum` applies to `prod`, they simply represent different mathematical
+    operations.
+    
+    NOTE: do not confuse with :func:`jijmodeling.product`. This is a sequence
+    multiplication (like capital-PI notation). `product` is the cartesian product.
+    
+    While it's possible to call this on any :class:`Expression`, using this with an invalid object will lead to an
+    error when the resulting expression is added to a :class:`Problem` and is
+    type-checked.
+    
+    In this overload variant, `operand` must be a linear sequence expression.
+    That is, it could be, for example:
+    - A one-dimensional array :class:`Placeholder` or :class:`DecisionVariable`
+    - The result of another sequence function/method, like :func:`jijmodeling.map`, :func:`jijmodeling.filter` 
+    - An expression that is a supported operation on the above two categories.
+    
+    Due to many binary operations on two one-dimensional arrays being supported,
+    use of :func`jijmodeling.map` on an index is often not required for simple
+    products (note that for illustrative purposes the documentation examples
+    on the relevant functions may use `map` when not strictly required). `map`
+    is often required when doing more complex indexing.
+    
+    The optional `axis` parameter allows you to specify one axis of a
+    multi-dimensional expression across which to perform the operation.
+    
+    See also the method equivalent :meth:`Expression.prod`, which is often more
+    convenient and clearer.
+    
+    Examples
+    ------
+    Performing a simple product.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = problem.Natural("N")
+    >>> x = problem.IntegerVar("x", shape=N)
+    >>> problem += jm.prod(x)
+    ```
+    
+    Same as above, but using map for indexing. This allows flexibility
+    on how the index is used, including mapping multiple indices, or filtering before mapping.
+    The other overload variant allows you to do this without explicitly calling `map`.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = problem.Natural("N")
+    >>> x = problem.IntegerVar("x", shape=N)
+    >>> problem += jm.prod(N.map(lambda i: x[i])
+    ```
+    """
+
+@typing.overload
+def prod(index: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, operand: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+    r"""
+    Creates a multiplication expression based on an index and an operand function.
+    
+    This overload variant can be thought of as a convenient shorthand for
+    `jm.prod(jm.map(operand, index))`. Each element in `index` will be passed
+    to the `operand` function for indexing, and multiplication will be performed on
+    the results. See :func:`jijmodeling.map` and the other overload of
+    :func:`jijmodeling.prod` for more information.
+    
+    Examples
+    ------
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = problem.Natural("N")
+    >>> x = problem.IntegerVar("x", shape=N)
+    >>> problem += jm.prod(N, lambda i: x[i])
+    ```
+    """
+
+def product(*sets: typing.Any) -> Expression:
+    r"""
+    Returns an expression representing the cartesian product of two :class:`Expression`s.
+    
+    For example `product(10,10)` represents all pairs `(0,0),(0,1),...,(1,0),(1,1),...,(10, 10)`.
+    This can then be :func:`map`ped to access these pairs of values, or :func:`filter`ed to remove unwanted values.
+    
+    Do not confuse with :func:`jijmodeling.prod`, which represents the
+    multiplication of a sequence of values.
+    """
+
+def roll(operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, shift: typing.Any, *, axis: typing.Optional[builtins.int] = None) -> Expression: ...
+
+def rows(array: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Creates a sequence over the rows of a multi-dimensional array expression.
+    
+    That is, each element will be a whole row (itself containing multiple
+    values), which can then be operated on like other sequences (eg. using
+    :func:`jijmodelng.sum` or :func:`jijmodeling.map`).
+    
+    If the array is 3-dimensional or higher, rows will iterate over the first
+    dimension/axis. For example, in a 3D matrix, the first element would be a
+    2D matrix representing all values `x[0, _, _]`
+    
+    See also the method equivalents: :meth:`Placeholder.rows`,
+    :meth:`DecisionVar.rows` and :meth:`Expression.rows`. Using the
+    methods often leads to code that is easier to read.
+    
+    Examples
+    ------
+    
+    Create an objective function that multiplies each variable in a row, and
+    then sums each row. In this case we have a 2x3 matrix, so the final expression is
+    `x[0, 0] * x[0, 1] * x[0, 2] + x[1, 0] * x[1, 1] * x[1, 2]`. Using
+    placeholders instead of literals in `shape` would allow this to be written
+    for matrices of arbitrary size.
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> d = problem.BinaryVar("d", shape=(2, 3))
+    >>> problem += jm.rows(d).map(lambda xs: xs.prod()).sum()
+    ```
+    
+    If the number of elements in the row can be guaranteed, the elements can be
+    destructured as separate arguments in a lambda expression:
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> N = problem.Natural("N")
+    >>> V = problem.Natural("V")
+    >>> E = problem.Natural("E", shape=(N, 2))
+    >>> x = problem.BinaryVar("x", shape=V)
+    >>> problem += jm.map(lambda i, j: x[i] * x[j], jm.rows(E)).sum()
+    ```
+    """
+
+def set(operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+
+def sin(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the sine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def sinh(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the hyperbolic sine of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def sqrt(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the square root of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+@typing.overload
+def sum(x: typing.Generator["Expression", None, None]) -> Expression:
+    r"""
+    Comprehension syntax for :func:`jijmodeling.sum` for use with decorated API.
+    
+    When using the decorated API, you are allowed to use a comprehension/generator
+    expression directly inside `sum`, using `for` clauses to mark the index. 
+    
+    NOTE: only works with decorated API!
+    
+    See :meth:`Problem.update` or the cheatsheet for more information on the decorated API.
+    
+    Examples
+    ------
+    ```python
+    >>> problem = jm.Problem("MyProblem", sense=jm.ProblemSense.MINIMIZE)
+    >>> @problem.update
+    >>> def _(problem: jm.DecoratedProblem):
+    ...   N = problem.Placeholder(dtype=jm.DataType.NATURAL)
+    ...   x = problem.BinaryVar(shape=N)
+    ...   C = problem.Placeholder(ndim=1, dtype=np.uint64)
+    ...   problem += jm.sum(x[i] for i in C)
+    >>>
+    ```
+    """
+
+@typing.overload
+def sum(operand: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, axis: typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict] = None) -> Expression:
+    r"""
+    Creates an expression representing the summation of a sequence expression.
+    
+    `sum` is a fundamental part of building models, used as a reducer to collapse
+    multiple values into a single value.
+    
+    While it's possible to call this on any :class:`Expression`, using this with an invalid object will lead to an
+    error when the resulting expression is added to a :class:`Problem` and is
+    type-checked.
+    
+    In this overload variant, `operand` must be a linear sequence expression.
+    That is, it could be, for example:
+    - A one-dimensional array :class:`Placeholder` or :class:`DecisionVariable`
+    - The result of another sequence function/method, like :func:`jijmodeling.map`, :func:`jijmodeling.filter` 
+    - An expression that is a supported operation on the above two categories.
+    
+    Due to many binary operations on two one-dimensional arrays being supported,
+    use of :func`jijmodeling.map` on an index is often not required for simple
+    summations (note that for illustrative purposes the documentation examples
+    on the relevant functions may use `map` when not strictly required). `map`
+    is often required when doing more complex indexing.
+    
+    The optional `axis` parameter allows you to specify one axis of a
+    multi-dimensional expression across which to perform the operation.
+    
+    See also the method equivalent :meth:`Expression.sum`, which is often more
+    convenient and clearer.
+    
+    Examples
+    ------
+    Performing a weighted sum. Note that this sort of usage may lead to errors
+    when the shapes don't match. In this case we guarantee that `x` has the
+    same shape as `W` through its definition.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> W = problem.Float("W", ndim=1)
+    >>> N = a.len_at(0)
+    >>> x = problem.BinaryVar("x", shape=N)
+    >>> problem += jm.sum(W * x)
+    ```
+    
+    Same as above, but using map for indexing. This allows flexibility
+    on how the index is used, including mapping multiple indices, or filtering before mapping.
+    The other overload variant allows you to do this without explicitly calling `map`.
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> W = problem.Float("W", ndim=1)
+    >>> N = a.len_at(0)
+    >>> x = problem.BinaryVar("x", shape=N)
+    >>> problem += jm.sum(N.map(lambda i: W[i] * x[i])
+    ```
+    """
+
+@typing.overload
+def sum(index: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, operand: typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+    r"""
+    Creates a summation based on an index and an operand function.
+    
+    This overload variant can be thought of as a convenient shorthand for
+    `jm.sum(jm.map(operand, index))`. Each element in `index` will be passed
+    to the `operand` function for indexing, and summation will be performed on
+    the results. See :func:`jijmodeling.map` and the other overload of
+    :func:`jijmodeling.sum` for more information.
+    
+    Examples
+    ------
+    
+    ```python
+    >>> import jijmodeling as jm
+    >>> problem = jm.Problem("MyProblem")
+    >>> W = problem.Float("W", ndim=1)
+    >>> N = a.len_at(0)
+    >>> x = problem.BinaryVar("x", shape=N)
+    >>> problem += jm.sum(N, lambda i: W[i] * x[i])
+    ```
+    """
+
+def tan(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the tangent of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def tanh(expr: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the hyperbolic tangent of the given expression.
+    
+    Note that `expr` must be a scalar. Also, evaluating models where this operation is performed on decision variables is currently unsupported.
+    """
+
+def values(dict: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression:
+    r"""
+    Returns an expression representing the values of a dictionary-like
+    :class:`Expression`.
+    
+    In other words, this is the JijModeling equivalent of the `values()` method
+    on Python dictionaries, used when creating JijModeling expressions.
+    
+    While it's possible to call this on any :class:`Expression`, this is
+    intended for dictionary-like :class:`Placeholder`s and
+    :class:`DecisionVar`s. Using this with an invalid object will lead to an
+    error when the resulting expression is added to a :class:`Problem` and is
+    type-checked.
+    
+    See also :meth:`Placeholder.values`, :meth:`DecisionVar.values`, and
+    :meth:`Expression.values` to achieve this with methods, which is recommended for
+    clarity.
+    
+    If you want to refer to the keys used in the dictionary, use
+    :func:`jijmodeling.keys` or its method equivalents. If you want key-value
+    pairs, use :func:`jijmodeling.items` or its method equivalents instead.
+    """
+
+def xor(lhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict, rhs: Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | dict) -> Expression: ...
+