scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/core/laws/_equation.py

@@ -0,0 +1,105 @@
+"""Define equation laws, implicit relations in which the highest time derivatives of states appear."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from sage.all__sagemath_symbolics import SR, Expression
+
+from ...errors import ValidationError
+from ...specs import RequirementSpec
+from ..spaces import ContinuousTime, StaticTime
+from ._base import BaseLaw
+
+
+class EquationLaw(BaseLaw):
+    """Implicit relation in which the highest time derivatives of states appear, such as Newton's second law.
+
+    The states are Sage functions of time, such as `function('theta')(t)`, and their derivatives are Sage derivatives,
+    `theta.diff(t, 2)`. The compiler solves all equations of a system jointly for the highest derivatives, which must
+    appear linearly, and adds the rate laws on the same states to the solution. An equation may name the state whose
+    equation it is, its `target`, and the equations of one target, from any element or interaction, add into one
+    before the solve, so a term of it may hold no highest derivative, such as the part a coupling Lagrangian adds to
+    the Euler-Lagrange equation of a coordinate.
+
+    Args:
+        lhs:
+            The left side, or a Sage relation `lhs == rhs`.
+
+        rhs:
+            The right side, or `None` when `lhs` is a relation.
+
+        target:
+            The state whose equation this is, so that the equations of one target add, or `None` for an equation of
+            its own.
+
+        label:
+            The name of the law, or the empty string for a law without one.
+
+    Attributes:
+        lhs_:
+            The left side.
+
+        rhs_:
+            The right side.
+
+    Examples:
+        >>> from sage.all__sagemath_symbolics import function, sin, var
+        >>> from skcomplex.core.laws import EquationLaw
+        >>> t, g, l = var('t g l')
+        >>> theta = function('theta')(t)
+        >>> EquationLaw(l * theta.diff(t, 2) == -g * sin(theta)).check().prepare().rhs_
+        -g*sin(theta(t))
+    """
+
+    def __init__(self, lhs: object, rhs: object = None, *, target: object = None, label: str = '') -> None:
+        super().__init__(label)
+        self.lhs = lhs
+        self.rhs = rhs
+        self.target = target
+
+    def _get_targets(self) -> tuple[object, ...]:
+        """Return no states, since the compiler finds the states whose derivatives the equation solves for."""
+        return ()
+
+    def _get_requirements(self) -> RequirementSpec:
+        """Return what the law requires of a system: continuous or static time."""
+        return RequirementSpec(time=(ContinuousTime, StaticTime))
+
+    def _get_sides(self) -> tuple[Expression, Expression]:
+        """Return the two sides of the equation as expressions, splitting a relation given as the left side."""
+        if self.rhs is None and isinstance(self.lhs, Expression):
+            return self.lhs.lhs(), self.lhs.rhs()
+        return SR(self.lhs), SR(self.rhs)
+
+    def _check(self) -> None:
+        """Raise an error for a function as a side, or an equation without a right side that is not a relation."""
+        if any(callable(item) and not isinstance(item, Expression) for item in (self.lhs, self.rhs)):
+            error_msg = (
+                'Equations are solved symbolically, so a side of an equation cannot be a function. Use a `RateLaw` of '
+                'the highest derivative with a function as its value.'
+            )
+            raise ValidationError(error_msg)
+        if self.rhs is None and not (isinstance(self.lhs, Expression) and self.lhs.is_relational()):
+            error_msg = 'An equation takes a left and a right side, or one relation `lhs == rhs`.'
+            raise ValidationError(error_msg)
+
+    def _prepare(self, context: str | None = None) -> None:
+        """Set `lhs_` and `rhs_`, the two sides, besides the attributes of every law.
+
+        Args:
+            context:
+                The path of the element or interaction that returns the law, or `None`.
+        """
+        super()._prepare(context)
+        self.lhs_, self.rhs_ = self._get_sides()
+
+    def _run(self, inputs: object) -> None:
+        """Set `value_` to the residual `lhs - rhs` at given values of the symbols it reads.
+
+        Args:
+            inputs:
+                A mapping from the name of every symbol the law reads to its value.
+        """
+        lhs, rhs = self._get_sides()
+        self.value_ = self._evaluate(lhs - rhs, inputs)

skcomplex/core/laws/_extremal.py

@@ -0,0 +1,94 @@
+"""Define extremal laws, which update the site with the smallest or largest value of a state and its neighbours."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections.abc import Callable
+
+from sage.all__sagemath_symbolics import Expression
+
+from ...errors import ValidationError
+from ...specs import RequirementSpec
+from ..spaces import BaseNeighborhood, DiscreteTime, LatticeSpace, NetworkSpace
+from ._base import BaseLaw
+
+EXTREMA = ('min', 'max')
+
+
+class ExtremalLaw(BaseLaw):
+    """Rule applied to the site with the smallest or largest value of a key state and to its neighbours.
+
+    Every application finds the extremal site, with ties broken by the random stream of the simulation, gathers the
+    site and its neighbours without duplicates, the site first, and calls `f(*values, random, **parameters)` with one
+    array per target and a uniform random array of the same length. Every application is recorded as an event.
+
+    Args:
+        targets:
+            The symbol of a lattice state, or a tuple of them that the rule updates together.
+
+        over:
+            The neighbourhood of the extremal site that the rule also updates.
+
+        rule:
+            The function `f(*values, random, **parameters)`.
+
+        key:
+            The lattice state whose extremum is searched, or `None` for the first target.
+
+        extremum:
+            `'min'` for the smallest value or `'max'` for the largest.
+
+        repeat:
+            The number of applications per step.
+
+        label:
+            The name of the events, or the empty string for the path of the element.
+
+    Examples:
+        >>> from sage.all__sagemath_symbolics import var
+        >>> from skcomplex.core.laws import ExtremalLaw
+        >>> from skcomplex.core.spaces import BoxNeighborhood
+        >>> law = ExtremalLaw(var('fitness'), BoxNeighborhood(), lambda values, *, random: random).check()
+        >>> law.extremum, law.repeat
+        ('min', 1)
+    """
+
+    def __init__(
+        self,
+        targets: Expression | tuple[Expression, ...],
+        over: BaseNeighborhood,
+        rule: Callable[..., object],
+        *,
+        key: Expression | None = None,
+        extremum: str = 'min',
+        repeat: int = 1,
+        label: str = '',
+    ) -> None:
+        super().__init__(label)
+        self.targets = targets
+        self.over = over
+        self.rule = rule
+        self.key = key
+        self.extremum = extremum
+        self.repeat = repeat
+
+    def _get_targets(self) -> tuple[object, ...]:
+        """Return the lattice states the rule updates."""
+        return self.targets if isinstance(self.targets, tuple) else (self.targets,)
+
+    def _get_key(self) -> object:
+        """Return the lattice state whose extremum is searched."""
+        return self._get_targets()[0] if self.key is None else self.key
+
+    def _get_requirements(self) -> RequirementSpec:
+        """Return what the law requires of a system: discrete time on a lattice or a network."""
+        return RequirementSpec(time=(DiscreteTime,), space=(LatticeSpace, NetworkSpace))
+
+    def _check(self) -> None:
+        """Raise an error for an unknown extremum or fewer than one application per step."""
+        if self.extremum not in EXTREMA:
+            error_msg = f'Unknown extremum {self.extremum!r}. Use one of {", ".join(EXTREMA)}.'
+            raise ValidationError(error_msg)
+        if int(self.repeat) < 1:
+            error_msg = f'An extremal law applies at least once per step, but its repeat is {self.repeat}.'
+            raise ValidationError(error_msg)

skcomplex/core/laws/_flux.py

@@ -0,0 +1,108 @@
+"""Define flux laws, the fluxes of the conserved states of finite-volume fields."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from ...errors import ValidationError
+from ...specs import RequirementSpec
+from ..spaces import ContinuousTime, LatticeSpace, MeshSpace
+from ..types import Target
+from ._base import BaseLaw
+
+LIMITERS = ('minmod', 'van-leer', None)
+RIEMANN_SOLVERS = ('rusanov', 'godunov')
+
+
+class FluxLaw(BaseLaw):
+    """Flux of a conserved state of a finite-volume field, `du/dt + divergence(flux) = 0`.
+
+    The flux is a symbolic expression of the field's states for one dimension, or one expression per dimension. The
+    states of a field with fluxes form a system of conservation laws, whose wave speeds come from the eigenvalues of
+    the flux Jacobians. Rate laws on the same states add sources.
+
+    Args:
+        target:
+            The symbol of the conserved state.
+
+        flux:
+            The flux, an expression or one expression per dimension.
+
+        limiter:
+            The slope limiter of the MUSCL reconstruction, `'minmod'`, `'van-leer'`, or `None` for first order.
+
+        riemann:
+            The numerical flux, `'rusanov'` or `'godunov'`, the exact solver for one state.
+
+        speed:
+            A function `f(t, values)` of the mapping from the name of every conserved state and parameter of the flux
+            to its array over the cells, which returns the wave speed of the Rusanov flux, or one function per
+            dimension. `None` takes the speeds from the eigenvalues of the flux Jacobians.
+
+        label:
+            The name of the law, or the empty string for a law without one.
+
+    Examples:
+        >>> from sage.all__sagemath_symbolics import var
+        >>> from skcomplex.core.laws import FluxLaw
+        >>> u = var('u')
+        >>> FluxLaw(u, u**2 / 2, riemann='godunov').check().prepare().run({'u': 2.0}).value_
+        2.0
+    """
+
+    def __init__(
+        self,
+        target: Target,
+        flux: object,
+        *,
+        limiter: str | None = 'minmod',
+        riemann: str = 'rusanov',
+        speed: object = None,
+        label: str = '',
+    ) -> None:
+        super().__init__(label)
+        self.target = target
+        self.flux = flux
+        self.limiter = limiter
+        self.riemann = riemann
+        self.speed = speed
+
+    def _get_targets(self) -> tuple[object, ...]:
+        """Return the conserved state."""
+        return (self.target,)
+
+    def _get_requirements(self) -> RequirementSpec:
+        """Return what the law requires of a system: continuous time on a lattice or a mesh."""
+        return RequirementSpec(time=(ContinuousTime,), space=(LatticeSpace, MeshSpace))
+
+    def _check(self) -> None:
+        """Raise an error for an unknown limiter or numerical flux, or for a flux or a speed it cannot take."""
+        self._check_array('flux')
+        if self._is_function(self.flux):
+            error_msg = (
+                f'The {self.riemann} flux of a FluxLaw is a function, but a flux is symbolic only: the wave speeds and '
+                'the critical points of the Godunov flux come from its derivative. Give an expression with `speed=` '
+                'for a wave speed that is a function, or a function as a RateLaw.'
+            )
+            raise ValidationError(error_msg)
+        if self.speed is not None and self.riemann != 'rusanov':
+            error_msg = (
+                f"A FluxLaw with the {self.riemann} flux takes no `speed`, because the Godunov flux is exact and "
+                "symbolic only. Use riemann='rusanov'."
+            )
+            raise ValidationError(error_msg)
+        if self.limiter not in LIMITERS:
+            error_msg = f"Unknown limiter {self.limiter!r}. Use 'minmod', 'van-leer', or None."
+            raise ValidationError(error_msg)
+        if self.riemann not in RIEMANN_SOLVERS:
+            error_msg = f"Unknown numerical flux {self.riemann!r}. Use 'rusanov' or 'godunov'."
+            raise ValidationError(error_msg)
+
+    def _run(self, inputs: object) -> None:
+        """Set `value_` to the flux at given values of the symbols it reads.
+
+        Args:
+            inputs:
+                A mapping from the name of every symbol the law reads to its value.
+        """
+        self.value_ = self._evaluate(self.flux, inputs)

skcomplex/core/laws/_fractional_noise.py

@@ -0,0 +1,65 @@
+"""Define fractional noise laws, amplitudes of the fractional Brownian motions that drive states."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from ...errors import ValidationError
+from ..types import Target
+from ._noise import NoiseLaw
+
+
+class FractionalNoiseLaw(NoiseLaw):
+    """Amplitude of a fractional Brownian motion of a Hurst index that drives the highest time derivative of a state.
+
+    The increments are fractional Gaussian noise, correlated over the whole run. A Hurst index of 1/2 gives the
+    process of a `NoiseLaw`, below 1/2 the increments anticorrelate, and above 1/2 they correlate. For other indices
+    than 1/2 the amplitude must not depend on any state.
+
+    Args:
+        target:
+            The symbol of a scalar state, or the column of symbols of a vector state.
+
+        value:
+            A symbolic expression of parameters and time. A vector target gets one fractional Brownian motion per
+            component.
+
+        order:
+            The order of the derivative the noise drives, checked against the state's order, or `None` to use it.
+
+        hurst:
+            The Hurst index `0 < H < 1`, a number or a parameter.
+
+        convention:
+            The stochastic calculus of the law, `'ito'`, `'stratonovich'`, or `'anti-ito'`, as for `NoiseLaw`.
+
+        label:
+            The name of the law, or the empty string for a law without one.
+
+    Examples:
+        >>> from sage.all__sagemath_symbolics import var
+        >>> from skcomplex.core.laws import FractionalNoiseLaw
+        >>> x, D = var('x'), var('D')
+        >>> FractionalNoiseLaw(x, 2 * D, hurst=0.7).check().hurst
+        0.7
+    """
+
+    def __init__(
+        self,
+        target: Target,
+        value: object,
+        order: int | None = None,
+        *,
+        hurst: object,
+        convention: str = 'ito',
+        label: str = '',
+    ) -> None:
+        super().__init__(target, value, order, convention=convention, label=label)
+        self.hurst = hurst
+
+    def _check(self) -> None:
+        """Raise an error for an invalid noise or a numeric Hurst index outside `(0, 1)`."""
+        super()._check()
+        if isinstance(self.hurst, int | float) and not 0 < self.hurst < 1:
+            error_msg = f'The Hurst index of the noise of {self.target} is {self.hurst}. Give a number in (0, 1).'
+            raise ValidationError(error_msg)

skcomplex/core/laws/_generator.py

@@ -0,0 +1,66 @@
+"""Define generator laws, the Hermitian operators that add up to the generator of a linear evolution."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from sage.all__sagemath_symbolics import Expression
+
+from ...errors import ValidationError
+from ...specs import RequirementSpec
+from ..spaces import ContinuousTime
+from ._base import BaseLaw
+from .utils import has_operator
+
+
+class GeneratorLaw(BaseLaw):
+    """Hermitian operator that adds to the generator `H` of the linear evolution `dx/dt = -i H x` on a tensor product.
+
+    Args:
+        operator:
+            The Hermitian operator, an expression of local operators of the namespaces the law receives.
+
+        label:
+            The name of the law, or the empty string for a law without one.
+
+    Examples:
+        >>> from sage.all__sagemath_symbolics import SR, var
+        >>> from skcomplex.core.laws import GeneratorLaw
+        >>> from skcomplex.core.laws.utils import local_operator
+        >>> z = local_operator(SR.symbol('q'), SR.symbol('z'))
+        >>> GeneratorLaw(var('h') * z).check().prepare().run({'h': 0.5}).value_
+        0.5*local_operator(q, z)
+    """
+
+    def __init__(self, operator: object, *, label: str = '') -> None:
+        super().__init__(label)
+        self.operator = operator
+
+    def _get_targets(self) -> tuple[object, ...]:
+        """Return no states, since the generator changes the operator state of the whole system."""
+        return ()
+
+    def _get_requirements(self) -> RequirementSpec:
+        """Return what the law requires of a system: continuous time."""
+        return RequirementSpec(time=(ContinuousTime,))
+
+    def _check(self) -> None:
+        """Raise an error for a function as the operator, or an operator without local operators."""
+        if callable(self.operator) and not isinstance(self.operator, Expression):
+            error_msg = (
+                'Generators need symbolic operators, so a generator cannot be a function. Give the coefficient '
+                'as a `series` of time, or use a `RateLaw` with a function on the states of a classical system.'
+            )
+            raise ValidationError(error_msg)
+        if not has_operator(self.operator):
+            error_msg = f'A generator takes an operator built from local operators, but got {self.operator!r}.'
+            raise ValidationError(error_msg)
+
+    def _run(self, inputs: object) -> None:
+        """Set `value_` to the operator with its coefficients at given values of the symbols they read.
+
+        Args:
+            inputs:
+                A mapping from the name of every symbol the law reads to its value.
+        """
+        self.value_ = self._evaluate(self.operator, inputs)

skcomplex/core/laws/_gradient_step.py

@@ -0,0 +1,89 @@
+"""Define gradient-step laws, optimizer steps on the adaptive parameters of a nested system once per epoch."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections.abc import Sequence
+
+from ...specs import DatasetSpec, ObservableSpec, RequirementSpec
+from ..spaces import DiscreteTime
+from ._base import BaseLaw
+
+
+class GradientStepLaw(BaseLaw):
+    """Optimizer steps on adaptive parameters of a nested system, on the gradient of a loss over unrolled runs.
+
+    One step of the discrete time that holds the law is one epoch. In an epoch the sequences of the dataset are shuffled
+    and split into batches, and for every batch the nested system runs from its initial states over every sequence,
+    the loss is averaged over the steps and sequences with the step weights, and the optimizer changes the trained
+    parameters by the gradient of that mean. The gradient is exact, by automatic differentiation of the unrolled runs.
+    The law records the mean batch loss of the epoch and every metric over the whole dataset at the end of the epoch.
+
+    Args:
+        trained:
+            The dotted paths of the adaptive parameters of the nested system that the law trains, such as
+            `readout.W`.
+
+        loss:
+            The observable of the nested system whose weighted mean over the steps of a batch is minimized.
+
+        data:
+            The sequences of the parameters of the nested system that set its inputs and targets at every step.
+
+        optimizer:
+            The name of the optimizer, `'sgd'`, `'momentum'`, `'rmsprop'`, or `'adam'`.
+
+        batch_size:
+            The number of sequences of a batch. The last batch of an epoch holds the rest.
+
+        truncation:
+            The number of inner steps the gradient flows back through the inner states, or `None` for the whole run.
+
+        metrics:
+            The observables of the nested system recorded at the end of every epoch, as weighted means over every
+            sequence.
+
+        label:
+            The name of the law, or the empty string for a law without one.
+
+    Examples:
+        >>> import numpy as np
+        >>> from skcomplex.core.laws import GradientStepLaw
+        >>> from skcomplex.specs import DatasetSpec, ObservableSpec
+        >>> data = DatasetSpec({'inputs.x': np.zeros((4, 3, 1))})
+        >>> law = GradientStepLaw(['readout.W'], ObservableSpec('error', 0.0), data, 'adam', 2).check()
+        >>> law.prepare('training').targets_
+        ()
+    """
+
+    def __init__(
+        self,
+        trained: Sequence[str],
+        loss: ObservableSpec,
+        data: DatasetSpec,
+        optimizer: str,
+        batch_size: int,
+        *,
+        truncation: int | None = None,
+        metrics: Sequence[ObservableSpec] = (),
+        label: str = '',
+    ) -> None:
+        super().__init__(label)
+        self.trained = trained
+        self.loss = loss
+        self.data = data
+        self.optimizer = optimizer
+        self.batch_size = batch_size
+        self.truncation = truncation
+        self.metrics = metrics
+
+    def _get_targets(self) -> tuple[object, ...]:
+        """Return no state, since the law changes parameters of a nested system."""
+        return ()
+
+    def _get_requirements(self) -> RequirementSpec:
+        """Return what the law requires of a system: discrete time, one step per epoch."""
+        return RequirementSpec(time=(DiscreteTime,))
+
+    def _check(self) -> None:
+        """Accept the arguments, which the interaction that returns the law validates."""

skcomplex/core/laws/_jump.py

@@ -0,0 +1,137 @@
+"""Define jump laws, random events that change states."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections.abc import Mapping
+
+from sage.all__sagemath_symbolics import SR, Expression
+
+from ...errors import ValidationError
+from ...specs import CallSpec, RequirementSpec
+from ..spaces import ContinuousTime
+from ._base import BaseLaw
+
+
+class JumpLaw(BaseLaw):
+    """Random event that changes states, on an exponential clock of a given rate or on a clock of drawn waiting times.
+
+    With a `rate`, the event fires at the times of a Poisson process of that propensity and changes states by fixed
+    increments, as in continuous-time Markov chains. With a `waiting` time instead, it fires after a waiting time drawn
+    anew at every firing, and applies its `reset`, as in renewal processes such as the jumps of a random walk. Every
+    member of a group then fires on its own clock, and the trajectory records every firing and counts them in
+    `<label>.renewals`. Jumps combine with rate and noise laws, which evolve the states between firings.
+
+    Args:
+        rate:
+            The propensity of the event, a symbolic expression, a `Call`, or a callable `f(t, values)`, or `None` with a
+            waiting time.
+
+        changes:
+            A mapping from the symbol of a scalar state to its increment when the event fires. In a law of a group, a
+            target may also be a member offset read `shift_member(namespace.n, k)`.
+
+        waiting:
+            The waiting time until the next firing, usually a draw from a distribution with nonnegative support, such
+            as `draw('wait', 'pareto', b=alpha)`, or `None` for the exponential clock of `rate`.
+
+        reset:
+            With a waiting time, a mapping from state symbol to its new value, which may hold draws, or `None`.
+
+        label:
+            With a waiting time, the name of the firings in the trajectory, or the empty string for the path of the
+            element.
+
+    Examples:
+        >>> from sage.all__sagemath_symbolics import var
+        >>> from skcomplex.core.laws import JumpLaw
+        >>> from skcomplex.core.laws.utils import draw
+        >>> s, i = var('s'), var('i')
+        >>> JumpLaw(0.1 * s * i, {s: -1, i: 1}).check().prepare().targets_
+        (s, i)
+        >>> n = var('n')
+        >>> JumpLaw(waiting=draw('wait', 'expon'), reset={n: 0}).check().prepare().targets_
+        (n,)
+    """
+
+    def __init__(
+        self,
+        rate: object = None,
+        changes: Mapping[Expression, object] | None = None,
+        waiting: object = None,
+        reset: Mapping[Expression, object] | None = None,
+        *,
+        label: str = '',
+    ) -> None:
+        super().__init__(label)
+        self.rate = rate
+        self.changes = changes
+        self.waiting = waiting
+        self.reset = reset
+
+    def _get_targets(self) -> tuple[object, ...]:
+        """Return the states the jump changes: the states of its increments, or of its reset."""
+        return tuple(self.changes or {}) if self.waiting is None else tuple(self.reset or {})
+
+    def _get_requirements(self) -> RequirementSpec:
+        """Return what the law requires of a system: continuous time."""
+        return RequirementSpec(time=(ContinuousTime,))
+
+    def _check_clock(self) -> None:
+        """Raise an error for a jump with both or neither clock, or with an option of the clock it does not use."""
+        if (self.rate is None) == (self.waiting is None):
+            error_msg = 'A jump fires at a rate or after a waiting time. Give exactly one of them.'
+            raise ValidationError(error_msg)
+        if self.waiting is not None and self.changes:
+            given, fix = 'changes', 'Give the new values of the states as `reset`.'
+        elif self.waiting is None and (self.reset is not None or self.label):
+            given = 'a reset' if self.reset is not None else 'a label'
+            fix = 'Give the increments of the states as `changes`, or a waiting time instead of the rate.'
+        else:
+            return
+        clock = 'a waiting-time clock' if self.waiting is not None else 'an exponential clock'
+        error_msg = (
+            f'A jump on {clock} takes {given}, but changes belong to the exponential clock of a rate, and resets and '
+            f'labels to the waiting-time clock. {fix}'
+        )
+        raise ValidationError(error_msg)
+
+    def _check_reset(self) -> None:
+        """Raise an error for a function in the reset of a renewal, whose values lower with its symbolic draws."""
+        if isinstance(self.waiting, CallSpec):
+            error_msg = 'The waiting time of a jump takes a function `f(rng, size=, t=, **values)`, not a `CallSpec`.'
+            raise ValidationError(error_msg)
+        if any(self._is_function(value) for value in (self.reset or {}).values()):
+            error_msg = (
+                'The reset of a jump on a waiting-time clock takes symbolic values, because they share draws with the '
+                'waiting time. Give symbols, or a function as the `waiting` time.'
+            )
+            raise ValidationError(error_msg)
+
+    def _check_changes(self) -> None:
+        """Raise an error for an increment that holds a symbol."""
+        for state, increment in (self.changes or {}).items():
+            if not self._is_function(increment) and not SR(increment).is_numeric():
+                error_msg = (
+                    f'The jump of {state} has the increment {increment}, which holds a symbol. Give the increment as a '
+                    'number or as a function `f(t, values)` of time and the values of the states and parameters.'
+                )
+                raise ValidationError(error_msg)
+
+    def _check(self) -> None:
+        """Raise an error for a jump with an invalid clock, a rate that is a NumPy array, or a symbolic increment."""
+        self._check_clock()
+        self._check_reset()
+        self._check_array('rate')
+        self._check_array('waiting')
+        self._check_changes()
+
+    def _run(self, inputs: object) -> None:
+        """Set `value_` to the increments of the jump, or its reset at given values of the symbols it reads.
+
+        Args:
+            inputs:
+                A mapping from the name of every symbol the law reads to its value.
+        """
+        changes = dict(self.changes or {}) if self.waiting is None else dict(self.reset or {})
+        self.value_ = self._evaluate(changes, inputs)