scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/engine/compile/passes/_check_fractional_noise.py

@@ -0,0 +1,107 @@
+"""Pass that checks the Hurst index and amplitude of fractional noise laws, with Hurst index 1/2 as noise laws."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from __future__ import annotations
+
+import numpy as np
+from sage.all__sagemath_symbolics import SR, Expression
+from sage.modules.free_module_element import FreeModuleElement
+
+from ....core.laws import BaseLaw, FractionalNoiseLaw, NoiseLaw
+from ....errors import ValidationError
+from ..._utils import components_of, symbols_of
+from ...problems import DeclarationsSpec, KernelSpec
+from .._base import BasePass
+from .._compilation import Compilation
+
+BROWNIAN_HURST = 0.5
+
+
+class CheckFractionalNoisePass(BasePass):
+    """Pass that checks the Hurst index and amplitude of fractional noise laws, with Hurst index 1/2 as noise laws."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('lowered', 'layout')
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('lowered',)
+
+    def _run(self, inputs: object = None) -> None:
+        """Check the fractional noise laws."""
+        compilation = self.compilation_
+        declarations = Compilation._required(compilation.layout, 'layout')
+        compilation.lowered = [
+            (spec, self._checked_fractional(spec, laws, declarations), block)
+            for spec, laws, block in Compilation._required(compilation.lowered, 'lowered')
+        ]
+
+    @staticmethod
+    def _checked_hurst(
+        spec: KernelSpec,
+        law: FractionalNoiseLaw,
+        declarations: DeclarationsSpec,
+        description: str,
+    ) -> None:
+        """Raise an error when the Hurst index of a fractional noise law is not a number or a parameter in `(0, 1)`."""
+        hurst = SR(law.hurst)
+        if hurst.is_numeric():
+            values = np.asarray([float(hurst)])
+        else:
+            reference = spec.references.get(hurst)
+            if reference is None or reference.is_state:
+                error_msg = (
+                    f'The {description} of {spec.owner} has the Hurst index {hurst}. Give a number or a parameter.'
+                )
+                raise ValidationError(error_msg)
+            parameters = np.concatenate([np.zeros(0), *declarations.initial_parameters])
+            values = np.asarray(reference.column_of(np.zeros(0), parameters), dtype=float)
+        if not np.all((values > 0) & (values < 1)):
+            error_msg = (
+                f'The {description} of {spec.owner} has the Hurst index {hurst} = {values[0]}, outside the open '
+                'interval (0, 1). Give a Hurst index between 0 and 1.'
+            )
+            raise ValidationError(error_msg)
+
+    @staticmethod
+    def _checked_fractional(spec: KernelSpec, laws: list[BaseLaw], declarations: DeclarationsSpec) -> list[BaseLaw]:
+        """Return laws with every fractional noise law of Hurst index 1/2 as a noise law, after checking the others."""
+        result: list[BaseLaw] = []
+        for law in laws:
+            if not isinstance(law, FractionalNoiseLaw):
+                result.append(law)
+                continue
+            description = CheckFractionalNoisePass._fractional_description(spec, law)
+            CheckFractionalNoisePass._checked_hurst(spec, law, declarations, description)
+            if SR(law.hurst).is_numeric() and float(SR(law.hurst)) == BROWNIAN_HURST:
+                result.append(NoiseLaw(law._get_targets()[0], law.value, law.order))
+                continue
+            values = [item for item in components_of(law.value) if isinstance(item, Expression)]
+            if not isinstance(law.value, Expression | FreeModuleElement) and not SR(law.value).is_numeric():
+                error_msg = (
+                    f'The {description} of {spec.owner} has an amplitude that is not symbolic. Give an expression.'
+                )
+                raise ValidationError(error_msg)
+            read = [
+                item
+                for item in sorted(symbols_of(values), key=str)
+                if (reference := spec.references.get(item)) is not None and reference.is_state
+            ]
+            if read:
+                error_msg = (
+                    f'The {description} of {spec.owner} has an amplitude that depends on the state '
+                    f'{spec._state_name(read[0])}. Only state-independent amplitudes are supported for a '
+                    'Hurst index other than 1/2.'
+                )
+                raise ValidationError(error_msg)
+            result.append(law)
+        return result
+
+    @staticmethod
+    def _fractional_description(spec: KernelSpec, law: FractionalNoiseLaw) -> str:
+        """Return the description of a fractional noise law by the states it drives."""
+        states = dict.fromkeys(spec._state_name(item) for item in components_of(law._get_targets()[0]))
+        return f'fractional noise law of {", ".join(states)}'

skcomplex/engine/compile/passes/_collect.py

@@ -0,0 +1,31 @@
+"""Collect the laws every component declares for its kernel spec."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from .._base import BasePass
+from .._compilation import Compilation
+from ._census import CensusPass
+
+
+class CollectPass(BasePass):
+    """Pass that collects the declared laws of every kernel spec, with no laws set apart yet."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('specs',)
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('collected', 'apart')
+
+    def _run(self, inputs: object = None) -> None:
+        """Collect the laws of every kernel spec."""
+        compilation = self.compilation_
+        specs = Compilation._required(compilation.specs, 'specs')
+        compilation.collected = [
+            (spec, CensusPass._declared_laws(spec, CensusPass._component_of(block.node)), block)
+            for spec, block in specs
+        ]
+        compilation.apart = []

skcomplex/engine/compile/passes/_compile_encounters.py

@@ -0,0 +1,301 @@
+"""Pass that compiles the encounter laws before reductions prune the groups they read, and takes them out."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections.abc import Mapping, Sequence
+
+import numpy as np
+import numpy.typing as npt
+from sage.all__sagemath_symbolics import SR, Expression
+
+from ....core.elements import FieldElement
+from ....core.laws import BaseLaw, BilinearLaw, EncounterLaw
+from ....core.laws.utils import COORDINATE_PREFIX, coordinate
+from ....core.spaces import PhaseSpace
+from ....errors import ValidationError
+from ....specs import TableValuesSpec
+from ....types import Indices
+from ..._utils import symbols_of
+from ...backends import BaseBackend
+from ...problems import DeclarationsSpec, ReferenceSpec
+from ...problems._encounter_kernel import EncounterKernel
+from ...types import KineticLaw, ReadKind
+from .._base import BaseCompiler, BasePass
+from .._compilation import Compilation, Laws
+
+_KINETIC_LAWS = (EncounterLaw, BilinearLaw)
+
+
+class CompileEncountersPass(BasePass):
+    """Pass that compiles the encounter laws before reductions prune the groups they read, and takes them out."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('drawn', 'layout')
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('drawn', 'encounters')
+
+    def _run(self, inputs: object = None) -> None:
+        """Compile the encounter laws of the drawn laws."""
+        compilation = self.compilation_
+        specs = Compilation._required(compilation.drawn, 'drawn')
+        declarations = Compilation._required(compilation.layout, 'layout')
+        compilation.encounters = self._compiled_encounters(specs, declarations, compilation.backend)
+        compilation.drawn = [
+            (spec, [law for law in laws if not isinstance(law, _KINETIC_LAWS)]) for spec, laws in specs
+        ]
+
+    @staticmethod
+    def _compiled_encounters(
+        specs: Laws,
+        declarations: DeclarationsSpec,
+        backend: BaseBackend | None,
+    ) -> tuple[EncounterKernel, ...]:
+        """Return the encounter laws of every component, lowered for their members."""
+        if not any(isinstance(law, _KINETIC_LAWS) for _, laws in specs for law in laws):
+            return ()
+        members = declarations.members
+        fused = BaseCompiler._resolve_backend(backend, members)._get_name() == 'numba'
+        components = [(spec.owner, dict(spec.references), laws) for spec, laws in specs]
+        phases = {
+            entry.name: block.node.component.space
+            for block in declarations.blocks.values()
+            if isinstance(block.node.component, FieldElement) and isinstance(block.node.component.space, PhaseSpace)
+            for entry in block.entries.values()
+        }
+        return CompileEncountersPass._compile_encounters(components, declarations.time, fused=fused, phases=phases)
+
+    @staticmethod
+    def _nonzero(table: npt.NDArray[np.generic]) -> tuple[Indices, ...]:
+        """Return the indices of the entries of a table that are not zero, numbers or Sage expressions."""
+        if table.dtype != object:
+            return tuple(np.asarray(item, dtype=np.intp) for item in np.nonzero(table))
+        mask = np.vectorize(lambda entry: not (SR(entry).is_numeric() and SR(entry) == 0), otypes=[bool])(table)
+        return tuple(np.asarray(item, dtype=np.intp) for item in np.nonzero(mask))
+
+    @staticmethod
+    def _group_indices(item: Expression | None, references: Mapping[Expression, ReferenceSpec], owner: str) -> Indices:
+        """Return the flat state indices of the density a symbol of an encounter stands for, one per activity."""
+        reference = references.get(item) if item is not None else None
+        if reference is None or not reference.is_state or reference.source is not ReadKind.MEMBER:
+            error_msg = (
+                f'An encounter law of {owner} reads {item}, which is not a state of a group bound to a role. '
+                'Encounters read the densities of groups on the sites of activity lattices, such as `s.candidate.f`.'
+            )
+            raise ValidationError(error_msg)
+        return reference.flat_indices.astype(np.intp)
+
+    @staticmethod
+    def _parameter_indices(
+        table: npt.NDArray[np.generic],
+        references: Mapping[Expression, ReferenceSpec],
+        owner: str,
+    ) -> dict[Expression, int]:
+        """Return the flat parameter index of every symbol of a table, after checking that it is a parameter."""
+        if table.dtype != object:
+            return {}
+        indices = {}
+        for item in sorted(symbols_of([SR(entry) for entry in table.ravel()]), key=str):
+            reference = references.get(item)
+            if reference is None or reference.is_state:
+                error_msg = (
+                    f'An encounter law of {owner} reads {item} in its rates or outcome probabilities, which is not a '
+                    'parameter. Write encounter rates and probabilities with numbers and parameters.'
+                )
+                raise ValidationError(error_msg)
+            indices[item] = reference.index
+        return indices
+
+    @staticmethod
+    def _rate_of_classes(rate: object, space: PhaseSpace | None, sizes: tuple[int, int, int]) -> object:
+        """Return a rate that reads class coordinates as its table `eta[h, k]`, at the classes of the candidate."""
+        names = [str(item) for item in SR(rate).variables()] if isinstance(rate, Expression) else []
+        coordinates = [item for item in names if item.startswith(COORDINATE_PREFIX)]
+        if space is None or not coordinates:
+            return rate
+        points = np.meshgrid(*(space.coordinates_[axis.name] for axis in space.axes), indexing='ij')
+        grid = {coordinate(axis.name): point.ravel() for axis, point in zip(space.axes, points, strict=True)}
+        rows = [SR(rate).subs({item: float(values[row]) for item, values in grid.items()}) for row in range(sizes[0])]
+        return np.tile(np.asarray(rows, dtype=object)[:, None], (1, sizes[1]))
+
+    @staticmethod
+    def _checked_rate(
+        law: KineticLaw,
+        sizes: tuple[int, int, int],
+        owner: str,
+        space: PhaseSpace | None = None,
+    ) -> npt.NDArray[np.generic]:
+        """Return the rate table of a law, after checking that it has one row per candidate and one column per field."""
+        rate = CompileEncountersPass._kinetic_table(CompileEncountersPass._rate_of_classes(law.rate, space, sizes))
+        if rate.ndim and rate.shape != sizes[:2]:
+            error_msg = (
+                f'An encounter law of {owner} has a rate of shape {rate.shape}, but its candidate and field groups '
+                f'need the shape {sizes[:2]}.'
+            )
+            raise ValidationError(error_msg)
+        return rate
+
+    @staticmethod
+    def _outcome_table(law: KineticLaw, sizes: tuple[int, int, int], owner: str) -> npt.NDArray[np.generic]:
+        """Return the outcome table of a law, the identity on the candidate's activity without one."""
+        value = law.transition if isinstance(law, EncounterLaw) else law.outcomes
+        if value is None:
+            if sizes[0] != sizes[2]:
+                error_msg = (
+                    f'A bilinear law of {owner} has no outcome table, so the particles keep the candidate '
+                    f'activity, but the target has {sizes[2]} activities and the candidate {sizes[0]}. Give the '
+                    'outcome table.'
+                )
+                raise ValidationError(error_msg)
+            identity = np.zeros(sizes)
+            identity[np.arange(sizes[0]), :, np.arange(sizes[0])] = 1.0
+            return identity
+        table = CompileEncountersPass._kinetic_table(value)
+        if table.shape != sizes:
+            error_msg = (
+                f'An encounter law of {owner} has an outcome table of shape {table.shape}, but its candidate, field, '
+                f'and test groups need the shape {sizes}.'
+            )
+            raise ValidationError(error_msg)
+        return table
+
+    @staticmethod
+    def _compile_encounter(
+        law: KineticLaw,
+        owner: str,
+        references: Mapping[Expression, ReferenceSpec],
+        time: Expression,
+        *,
+        fused: bool = False,
+        phases: Mapping[str, PhaseSpace] | None = None,
+    ) -> EncounterKernel:
+        """Return an encounter law lowered to sparse contractions over the densities its roles bind.
+
+        Args:
+            law:
+                The encounter or bilinear law.
+
+            owner:
+                The path of the component that returns the law.
+
+            references:
+                The references of the symbols of the component's namespace.
+
+            time:
+                The time symbol.
+
+            fused:
+                Whether the gain runs in one fused loop compiled with Numba.
+
+            phases:
+                The phase space of every entry of a field on one, whose encounters run at every position.
+
+        Returns:
+            encounter:
+                The compiled law.
+
+        Raises:
+            ValidationError:
+                A density is not a state of a group, a table has the wrong shape, or a table reads a state.
+        """
+        bilinear = isinstance(law, BilinearLaw)
+        first, second = (law.first, law.second) if bilinear else (law.candidate, law.field)
+        candidate = CompileEncountersPass._group_indices(first, references, owner)
+        linear = not bilinear and second is None
+        empty = np.zeros(0, dtype=np.intp)
+        field_indices = empty if linear else CompileEncountersPass._group_indices(second, references, owner)
+        space = (phases or {}).get(references[first].entry.name)
+        positions = 1 if space is None else space.position_size_
+        test_symbol = law.target if bilinear else law.test
+        test = (
+            candidate if test_symbol is None else CompileEncountersPass._group_indices(test_symbol, references, owner)
+        )
+        sizes = (candidate.size // positions, max(field_indices.size // positions, 1), test.size // positions)
+        rates = CompileEncountersPass._checked_rate(law, sizes, owner, space)
+        table = CompileEncountersPass._outcome_table(law, sizes, owner)
+        grid = tuple(item.ravel().astype(np.intp) for item in np.indices(sizes[:2]))
+        rate = TableValuesSpec(rates, grid, CompileEncountersPass._parameter_indices(rates, references, owner), time)
+        nonzero = CompileEncountersPass._nonzero(table)
+        entries = (nonzero[0], nonzero[1], nonzero[2])
+        probabilities = TableValuesSpec(
+            table,
+            nonzero,
+            CompileEncountersPass._parameter_indices(table, references, owner),
+            time,
+        )
+        return (
+            EncounterKernel(
+                owner,
+                'bilinear' if bilinear else 'transition',
+                candidate,
+                field_indices,
+                test,
+                rate=rate,
+                entries=entries,
+                probabilities=probabilities,
+                fused=fused,
+                positions=positions,
+            )
+            .check()
+            .prepare()
+        )
+
+    @staticmethod
+    def _compile_encounters(
+        components: Sequence[tuple[str, Mapping[Expression, ReferenceSpec], Sequence[BaseLaw]]],
+        time: Expression,
+        *,
+        fused: bool = False,
+        phases: Mapping[str, PhaseSpace] | None = None,
+    ) -> tuple[EncounterKernel, ...]:
+        """Return the encounter laws of every component, lowered in declaration order.
+
+        Args:
+            components:
+                The path, the references of the namespace, and the laws of every component.
+
+            time:
+                The time symbol.
+
+            fused:
+                Whether the gains run in fused loops compiled with Numba.
+
+            phases:
+                The phase space of every entry of a field on one.
+
+        Returns:
+            encounters:
+                The compiled laws.
+        """
+        return tuple(
+            CompileEncountersPass._compile_encounter(law, owner, references, time, fused=fused, phases=phases)
+            for owner, references, laws in components
+            for law in laws
+            if isinstance(law, _KINETIC_LAWS)
+        )
+
+    @staticmethod
+    def _kinetic_table(value: object) -> npt.NDArray[np.generic]:
+        """Return a rate or outcome table of an encounter law as an array of floats, or of Sage expressions.
+
+        Args:
+            value:
+                The table, a number, a Sage expression, or a nested sequence of them.
+
+        Returns:
+            table:
+                A float array when every entry is a number, otherwise an object array of Sage expressions.
+
+        Examples:
+            >>> from skcomplex.engine.compile.passes._compile_encounters import CompileEncountersPass
+            >>> CompileEncountersPass._kinetic_table([[0.5, 0.5]]).dtype
+            dtype('float64')
+        """
+        array = np.asarray(value, dtype=object)
+        try:
+            return np.asarray(array, dtype=float)
+        except TypeError:
+            return np.asarray(np.vectorize(SR, otypes=[object])(array), dtype=object)

skcomplex/engine/compile/passes/_complex.py

@@ -0,0 +1,198 @@
+"""Split the laws of complex states into laws of their real and imaginary parts."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+import numbers
+from collections.abc import Callable
+
+import numpy as np
+from sage.all__sagemath_symbolics import SR, Expression, I
+from sage.modules.free_module_element import FreeModuleElement
+
+from ....core.laws import BaseLaw, BoundaryLaw, CrossingLaw, EquationLaw, JumpLaw, NoiseLaw, RateLaw, UpdateLaw
+from ....errors import ValidationError
+from ....specs import CallSpec
+from ..._utils import components_of
+from .._base import BasePass
+from .._compilation import Compilation
+from .._complex import _is_zero, _real, _split_complex
+from .._laws import _AGENT_LAWS
+from ._kernels import KernelsPass
+
+
+class LowerComplexPass(BasePass):
+    """Pass that splits every law of a complex state into the laws of its real and imaginary parts."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('collected',)
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('lowered',)
+
+    def _run(self, inputs: object = None) -> None:
+        """Split the collected laws of complex states."""
+        compilation = self.compilation_
+        compilation.lowered = [
+            (
+                spec,
+                [item for law in laws for item in self._split_law(law, spec.owner, spec._state_name)],
+                block,
+            )
+            for spec, laws, block in Compilation._required(compilation.collected, 'collected')
+        ]
+
+    @staticmethod
+    def _split_value(
+        targets: list[Expression],
+        values: list[Expression],
+        description: str,
+        state_of: Callable[[Expression], str],
+    ) -> tuple[list[Expression], list[Expression]]:
+        """Return the real targets and real values of a law, two of each for every complex target."""
+        real_targets, real_values = [], []
+        for target, value in zip(targets, values, strict=True):
+            real, imaginary = _split_complex(value, description)
+            if LowerComplexPass._has_complex(target):
+                real_targets += [target.real_part(), target.imag_part()]
+                real_values += [real, imaginary]
+                continue
+            if not _is_zero(imaginary):
+                error_msg = (
+                    f'The {description} gives the complex value {value} to the real state {state_of(target)}. Take its '
+                    'real part `real_part(...)`, its imaginary part `imag_part(...)`, or its modulus `abs(...)`, or '
+                    'declare the state with `domain=CC`.'
+                )
+                raise ValidationError(error_msg)
+            real_targets.append(target)
+            real_values.append(real)
+        return real_targets, real_values
+
+    @staticmethod
+    def _split_assignment(
+        law: RateLaw | NoiseLaw | UpdateLaw | BoundaryLaw,
+        owner: str,
+        state_of: Callable[[Expression], str],
+    ) -> list[BaseLaw]:
+        """Return the laws of one real target component each that a rate, noise, update, or boundary law stands for."""
+        description = f'{type(law).__name__} of {owner}'
+        targets = components_of(law._get_targets()[0])
+        values = (
+            None
+            if isinstance(law.value, CallSpec)
+            else KernelsPass._symbolic_components(law.value, len(targets), description)
+        )
+        if values is None:
+            error_msg = (
+                f'The {description} on {state_of(targets[0])} calls a function with complex values or on a complex '
+                'state. Functions take and give real values, so pass `real_part(...)` and `imag_part(...)` instead.'
+            )
+            raise ValidationError(error_msg)
+        real_targets, real_values = LowerComplexPass._split_value(targets, values, description, state_of)
+        return [
+            BasePass._replaced(law, target=target, value=value)
+            for target, value in zip(real_targets, real_values, strict=True)
+        ]
+
+    @staticmethod
+    def _split_equation(equation: EquationLaw, owner: str) -> list[BaseLaw]:
+        """Return the real equations of the real and imaginary parts of a complex equation."""
+        description = f'Equation of {owner}'
+        real_lhs, imaginary_lhs = _split_complex(equation.lhs_, description)
+        real_rhs, imaginary_rhs = _split_complex(equation.rhs_, description)
+        real = _is_zero(imaginary_lhs) and _is_zero(imaginary_rhs)
+        target = equation.target if real else None
+        equations: list[BaseLaw] = [EquationLaw(real_lhs, real_rhs, target=target).check().prepare()]
+        if not real:
+            equations.append(EquationLaw(imaginary_lhs, imaginary_rhs).check().prepare())
+        return equations
+
+    @staticmethod
+    def _split_event(event: CrossingLaw, owner: str, state_of: Callable[[Expression], str]) -> CrossingLaw:
+        """Return an event with a real guard and a reset of real states."""
+        description = f'Event of {owner}'
+        guard = _real(_split_complex(event.guard, description), SR(event.guard), description)
+        if event.reset is None:
+            return BasePass._replaced(event, guard=guard)
+        targets = [SR(target) for target in event.reset]
+        values = [SR(value) for value in event.reset.values()]
+        real_targets, real_values = LowerComplexPass._split_value(targets, values, description, state_of)
+        return BasePass._replaced(event, guard=guard, reset=dict(zip(real_targets, real_values, strict=True)))
+
+    @staticmethod
+    def _split_jump(jump: JumpLaw, owner: str) -> JumpLaw:
+        """Return a jump with a real rate, after checking that it changes real states."""
+        description = f'JumpLaw of {owner}'
+        if any(LowerComplexPass._has_complex(target) for target in jump.changes or {}):
+            error_msg = f'The {description} changes a complex state. Jumps change real states by real increments.'
+            raise ValidationError(error_msg)
+        return JumpLaw(_real(_split_complex(jump.rate, description), SR(jump.rate), description), jump.changes)
+
+    @staticmethod
+    def _has_complex(value: object) -> bool:
+        """Check whether a law value or one of its components holds a complex number.
+
+        Args:
+            value:
+                An expression, a vector, a number, a sequence of them, or any other value.
+
+        Returns:
+            is_complex:
+                Whether the value holds the imaginary unit or a number with a nonzero imaginary part.
+        """
+        if isinstance(value, Expression):
+            return bool(value.has(I))
+        if isinstance(value, np.ndarray) and value.dtype != object:
+            return bool(np.iscomplexobj(value) and np.any(value.imag != 0))
+        if isinstance(value, np.ndarray):
+            return any(LowerComplexPass._has_complex(item) for item in value.ravel())
+        if isinstance(value, FreeModuleElement | list | tuple):
+            return any(LowerComplexPass._has_complex(item) for item in np.ravel(np.asarray(list(value), dtype=object)))
+        if isinstance(value, numbers.Complex) and not isinstance(value, numbers.Real):
+            return complex(value).imag != 0
+        return False
+
+    @staticmethod
+    def _split_law(law: BaseLaw, owner: str, state_of: Callable[[Expression], str]) -> list[BaseLaw]:
+        """Return the laws of real states and real values that a law of complex states and values stands for.
+
+        A law with no complex value is returned unchanged. A law with a complex value becomes one law per real component
+        of its target, two for every complex component, and an equation with complex sides becomes the equations of
+        their parts.
+
+        Args:
+            law:
+                The law.
+
+            owner:
+                The path of the component that returned the law.
+
+            state_of:
+                The function that returns the dotted name of the state a target symbol stands for.
+
+        Returns:
+            laws:
+                The real laws.
+
+        Raises:
+            ValidationError:
+                A real state takes a complex value, a law orders complex values, a callable or a jump targets a complex
+                state, or a law of a kind that takes only real values holds a complex value.
+        """
+        if isinstance(law, _AGENT_LAWS) or not any(LowerComplexPass._has_complex(item) for item in law._get_values()):
+            return [law]
+        if isinstance(law, RateLaw | NoiseLaw | UpdateLaw | BoundaryLaw):
+            return LowerComplexPass._split_assignment(law, owner, state_of)
+        if isinstance(law, CrossingLaw):
+            return [LowerComplexPass._split_event(law, owner, state_of)]
+        if isinstance(law, JumpLaw):
+            return [LowerComplexPass._split_jump(law, owner)]
+        if isinstance(law, EquationLaw):
+            return LowerComplexPass._split_equation(law, owner)
+        error_msg = (
+            f'A {type(law).__name__} of {owner} holds a complex value. {type(law).__name__}s take real states and '
+            'real values.'
+        )
+        raise ValidationError(error_msg)