scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/engine/compile/passes/_orders.py

@@ -0,0 +1,409 @@
+"""Read derivatives and lags of states through their companion states, and solve equations for highest derivatives."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from __future__ import annotations
+
+import itertools
+from collections.abc import Callable
+from types import SimpleNamespace
+
+import numpy as np
+import numpy.typing as npt
+from sage.all__sagemath_symbolics import SR, Expression, matrix, solve
+from sage.modules.free_module_element import FreeModuleElement
+
+from ....core.laws import BaseLaw, BoundaryLaw, CrossingLaw, EquationLaw, JumpLaw, NoiseLaw, RateLaw, UpdateLaw
+from ....core.laws.utils import reductions_in
+from ....core.spaces import StaticTime
+from ....errors import ValidationError
+from ....specs import CallSpec
+from ....specs._orders_spec import _OrdersSpec
+from ....types import Array, VariableKind
+from ..._utils import components_of, declarations_of, symbol, vector
+from ...problems import BlockSpec, KernelSpec
+from ...problems._relation_spec import _RelationSpec
+from .._base import BasePass
+from .._compilation import Compilation
+from .._laws import _KERNEL_FREE_LAWS
+from .._renewal_law import RenewalLaw
+from ._complex import LowerComplexPass
+
+_EQUATION_UNKNOWNS = 6
+
+
+class OrdersPass(BasePass):
+    """Pass that reads derivatives and lags through companion states, adds their chains, and solves equations."""
+
+    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 ('ordered',)
+
+    def _run(self, inputs: object = None) -> None:
+        """Lower the orders and lags of the laws and solve their equations."""
+        compilation = self.compilation_
+        blocks = list(Compilation._required(compilation.layout, 'layout').blocks.values())
+        orders = self._orders_of(blocks)
+        specs = [
+            (spec, self._with_orders(spec, laws, block, orders))
+            for spec, laws, block in Compilation._required(compilation.lowered, 'lowered')
+        ]
+        static = isinstance(compilation.system.time, StaticTime)
+        compilation.ordered = self._solve_static(specs) if static else self._solve_equations(specs)
+
+    @staticmethod
+    def _orders_of(blocks: list[BlockSpec]) -> _OrdersSpec:
+        """Return the orders above 1 and the lags of every state of the blocks."""
+        orders, lags = {}, {}
+        for block in blocks:
+            if block.node.interaction or block.node.is_agent:
+                continue
+            declarations = declarations_of(block.node.component_type, VariableKind.STATE)
+            for variable, entry in block.entries.items():
+                declaration = declarations.get(variable)
+                if declaration is not None and declaration.derivatives:
+                    orders[entry.name] = declaration.derivatives + 1
+                if declaration is not None and declaration.lags:
+                    lags[entry.name] = declaration.lags
+        return _OrdersSpec(orders, lags)
+
+    @staticmethod
+    def _companion_symbol(spec: KernelSpec, item: Expression, suffix: str) -> Expression:
+        """Return the symbol of a companion state of the state a symbol reads, in the same namespace and column."""
+        reference = spec.references[item]
+        name = f'{reference.entry.name}{suffix}'
+        for other, candidate in spec.references.items():
+            if (
+                candidate.entry.name == name
+                and candidate.column == reference.column
+                and candidate.source == reference.source
+            ):
+                return other
+        error_msg = f'A law of {spec.owner} reads {name}, which the namespace does not hold.'
+        raise ValidationError(error_msg)
+
+    @staticmethod
+    def _substitute(
+        value: object,
+        spec: KernelSpec,
+        orders: _OrdersSpec,
+        owner: str,
+        highest: dict[Expression, Expression] | None = None,
+    ) -> object:
+        """Return a law value with derivatives and lags of states replaced by their companion symbols.
+
+        When `highest` is given, derivatives of a state's own order become placeholders that map to the symbol of the
+        state's highest derivative, which an equation solves for.
+        """
+        if isinstance(value, FreeModuleElement):
+            return vector(OrdersPass._substitute(item, spec, orders, owner, highest) for item in value)
+        if not isinstance(value, Expression):
+            return value
+        replacements = {}
+        for call in BasePass._calls_of(value, 'derivative'):
+            item, degree = call.operands()
+            reference = spec.references.get(item)
+            order = orders.orders.get(reference.entry.name, 1) if reference is not None else 1
+            if highest is not None and reference is not None and degree.is_integer() and int(degree) == order:
+                top = item if order == 1 else OrdersPass._companion_symbol(spec, item, f'_d{order - 1}')
+                placeholder = symbol(f'_highest_{top}')
+                highest[placeholder] = top
+                replacements[call] = placeholder
+                continue
+            if reference is None or not degree.is_integer() or not 0 < int(degree) < order:
+                error_msg = (
+                    f'{owner} uses {call}, but laws read derivatives of a state only below its declared order, here '
+                    f'{order}. Declare a higher order with `state(order=...)`, or state the highest derivative with an '
+                    '`EquationLaw`.'
+                )
+                raise ValidationError(error_msg)
+            replacements[call] = OrdersPass._companion_symbol(spec, item, f'_d{int(degree)}')
+        for call in BasePass._calls_of(value, 'lag'):
+            item, steps = call.operands()
+            reference = spec.references.get(item)
+            kept = orders.lags.get(reference.entry.name, 0) if reference is not None else 0
+            if reference is None or not steps.is_integer() or not 0 < int(steps) <= kept:
+                error_msg = (
+                    f'{owner} uses {call}, but the state keeps {kept} past values. Declare more with `state(lags=...)`.'
+                )
+                raise ValidationError(error_msg)
+            replacements[call] = OrdersPass._companion_symbol(spec, item, f'_lag{int(steps)}')
+        return value.subs(replacements) if replacements else value
+
+    @staticmethod
+    def _retarget(law: RateLaw | NoiseLaw, spec: KernelSpec, orders: _OrdersSpec) -> RateLaw | NoiseLaw:
+        """Return a rate or noise law that targets the highest derivative of its state, after checking its order."""
+        items = components_of(law._get_targets()[0])
+        references = [spec.references.get(item) for item in items]
+        declared = {orders.orders.get(reference.entry.name, 1) for reference in references if reference is not None}
+        order = max(declared, default=1)
+        if law.order is not None and law.order != order:
+            names = ', '.join(sorted({reference.entry.name for reference in references if reference is not None}))
+            error_msg = (
+                f'A {type(law).__name__} of {spec.owner} on {names} gives the derivative of order {law.order}, but the '
+                f'state has order {order}. Match the law to the order declared with `state(order=...)`.'
+            )
+            raise ValidationError(error_msg)
+        if order == 1:
+            return law
+        tops = [OrdersPass._companion_symbol(spec, item, f'_d{order - 1}') for item in items]
+        target = vector(tops) if isinstance(law._get_targets()[0], FreeModuleElement) else tops[0]
+        return BasePass._replaced(law, target=target)
+
+    @staticmethod
+    def _intrinsic_laws(spec: KernelSpec, block: BlockSpec, orders: _OrdersSpec) -> list[BaseLaw]:
+        """Return the chain `x' = x_d1, ...` of every higher-order state and the shifts of every lagged state."""
+        laws: list[BaseLaw] = []
+        for variable, entry in block.entries.items():
+            names = [variable, *(f'{variable}_d{index}' for index in range(1, orders.orders.get(entry.name, 1)))]
+            laws += [
+                RateLaw(getattr(spec.namespace, lower), getattr(spec.namespace, upper))
+                for lower, upper in itertools.pairwise(names)
+            ]
+            shifted = [variable, *(f'{variable}_lag{index}' for index in range(1, orders.lags.get(entry.name, 0) + 1))]
+            laws += [
+                UpdateLaw(getattr(spec.namespace, older), getattr(spec.namespace, newer))
+                for newer, older in itertools.pairwise(shifted)
+            ]
+        return laws
+
+    @staticmethod
+    def _relation(spec: KernelSpec, law: EquationLaw, orders: _OrdersSpec) -> _RelationSpec:
+        """Return an equation law as a relation in placeholders of the highest derivatives it contains."""
+        description = f'the equation {law.lhs_} == {law.rhs_} of {spec.owner}'
+        if spec.pairs is not None:
+            error_msg = f'Pair interaction {spec.owner} returns {description}. Pair interactions take only rate laws.'
+            raise ValidationError(error_msg)
+        highest: dict[Expression, Expression] = {}
+        lhs = OrdersPass._substitute(SR(law.lhs_), spec, orders, f'In {description}, it', highest)
+        rhs = OrdersPass._substitute(SR(law.rhs_), spec, orders, f'In {description}, it', highest)
+        reference = spec.references.get(law.target) if isinstance(law.target, Expression) else None
+        key = None if reference is None else (reference.entry.name, reference.column)
+        target = None if key is None else law.target
+        return _RelationSpec(spec, SR(lhs) - SR(rhs), highest, description, key, target)
+
+    @staticmethod
+    def _check_relation(relation: _RelationSpec) -> None:
+        """Raise an error for a relation with no highest derivative of a state to solve for."""
+        if not relation.highest:
+            description = relation.description
+            error_msg = (
+                f'{description[0].upper()}{description[1:]} contains no highest derivative of a state to solve for.'
+            )
+            raise ValidationError(error_msg)
+
+    @staticmethod
+    def _summed(relations: list[_RelationSpec]) -> list[_RelationSpec]:
+        """Return the relations with those of one target added into one."""
+        groups: dict[tuple[str, int] | int, list[_RelationSpec]] = {}
+        for index, relation in enumerate(relations):
+            groups.setdefault(index if relation.key is None else relation.key, []).append(relation)
+        summed = []
+        for group in groups.values():
+            first = group[0]
+            if len(group) > 1:
+                references = {key: value for item in group for key, value in item.spec.references.items()}
+                owner = ', '.join(dict.fromkeys(item.spec.owner for item in group))
+                spec = KernelSpec(owner, SimpleNamespace(), references, max(item.spec.rows for item in group))
+                first = _RelationSpec(
+                    spec,
+                    sum((item.expression for item in group), SR(0)),
+                    {key: value for item in group for key, value in item.highest.items()},
+                    ' + '.join(item.description for item in group),
+                    first.key,
+                    first.target,
+                )
+            summed.append(first)
+        return summed
+
+    @staticmethod
+    def _ordered_law(spec: KernelSpec, law: BaseLaw, orders: _OrdersSpec) -> BaseLaw:
+        """Return a jump, event, renewal, or assignment law with derivatives and lags replaced and rates retargeted."""
+        owner = f'A {type(law).__name__} of {spec.owner}'
+        if isinstance(law, JumpLaw):
+            return JumpLaw(OrdersPass._substitute(law.rate, spec, orders, owner), law.changes)
+        if isinstance(law, CrossingLaw | RenewalLaw):
+            reset = {
+                OrdersPass._substitute(SR(target), spec, orders, owner): (
+                    value if BaseLaw._is_function(value) else OrdersPass._substitute(SR(value), spec, orders, owner)
+                )
+                for target, value in (law.reset or {}).items()
+            }
+            reset_value = reset if law.reset is not None else None
+            if isinstance(law, RenewalLaw):
+                return BasePass._replaced(
+                    law,
+                    waiting=(
+                        law.waiting
+                        if BaseLaw._is_function(law.waiting)
+                        else OrdersPass._substitute(SR(law.waiting), spec, orders, owner)
+                    ),
+                    reset=reset_value,
+                )
+            return BasePass._replaced(
+                law,
+                guard=(
+                    law.guard
+                    if BaseLaw._is_function(law.guard)
+                    else OrdersPass._substitute(SR(law.guard), spec, orders, owner)
+                ),
+                reset=reset_value,
+            )
+        if not isinstance(law, RateLaw | NoiseLaw | UpdateLaw | BoundaryLaw):
+            return law
+        value = OrdersPass._substitute(law.value, spec, orders, owner)
+        if isinstance(law, RateLaw | NoiseLaw):
+            return OrdersPass._retarget(BasePass._replaced(law, value=value), spec, orders)
+        return BasePass._replaced(law, value=value)
+
+    @staticmethod
+    def _with_orders(
+        spec: KernelSpec,
+        laws: list[BaseLaw],
+        block: BlockSpec,
+        orders: _OrdersSpec,
+    ) -> list[BaseLaw | _RelationSpec]:
+        """Return laws with derivatives and lags replaced, rates retargeted, equations as relations, chains added."""
+        if not orders.orders and not orders.lags and not any(isinstance(law, EquationLaw) for law in laws):
+            return list(laws)
+        result: list[BaseLaw | _RelationSpec] = []
+        for law in laws:
+            if isinstance(law, _KERNEL_FREE_LAWS):
+                result.append(law)
+            elif isinstance(law, EquationLaw):
+                result.append(OrdersPass._relation(spec, law, orders))
+            else:
+                result.append(OrdersPass._ordered_law(spec, law, orders))
+        if not block.node.interaction:
+            result += [
+                item
+                for law in OrdersPass._intrinsic_laws(spec, block, orders)
+                for item in LowerComplexPass._split_law(
+                    law,
+                    spec.owner,
+                    spec._state_name,
+                )
+            ]
+        return result
+
+    @staticmethod
+    def _numeric_solution(rows: int, size: int, index: int) -> Callable[..., Array]:
+        """Return a function of the matrix and right side entries that solves the linear system for one unknown."""
+
+        def solve(t: float, *entries: npt.ArrayLike) -> Array:
+            del t
+            values = [np.broadcast_to(np.asarray(entry, dtype=float), (rows,)) for entry in entries]
+            matrix_ = np.stack(values[: size * size], axis=-1).reshape(rows, size, size)
+            right = np.stack(values[size * size :], axis=-1)
+            return np.linalg.solve(matrix_, right[..., None])[..., 0][:, index]
+
+        return solve
+
+    @staticmethod
+    def _checked_relations(specs: list[tuple[KernelSpec, list[BaseLaw | _RelationSpec]]]) -> list[_RelationSpec]:
+        """Return the relations of specs with those of one target added, each checked for a highest derivative."""
+        relations = OrdersPass._summed([item for _, laws in specs for item in laws if isinstance(item, _RelationSpec)])
+        for relation in relations:
+            OrdersPass._check_relation(relation)
+        return relations
+
+    @staticmethod
+    def _solve_equations(
+        specs: list[tuple[KernelSpec, list[BaseLaw | _RelationSpec]]],
+    ) -> list[tuple[KernelSpec, list[BaseLaw]]]:
+        """Return specs whose equations are replaced by rate laws on the highest derivatives they solve for jointly."""
+        relations = OrdersPass._checked_relations(specs)
+        kept = [(spec, [law for law in laws if not isinstance(law, _RelationSpec)]) for spec, laws in specs]
+        if not relations:
+            return kept
+        highest: dict[Expression, Expression] = {}
+        for relation in relations:
+            highest.update(relation.highest)
+        unknowns = list(highest)
+        for relation in relations:
+            for first in unknowns:
+                for second in unknowns:
+                    if not relation.expression.diff(first).diff(second).is_trivial_zero():
+                        error_msg = (
+                            f'{relation.description[0].upper()}{relation.description[1:]} is not linear in the highest '
+                            f'derivative {highest[first]}. Write the equation so that highest derivatives appear '
+                            'linearly.'
+                        )
+                        raise ValidationError(error_msg)
+        descriptions = '; '.join(relation.description for relation in relations)
+        if len(relations) != len(unknowns):
+            error_msg = (
+                f'{len(relations)} equations give {len(unknowns)} highest derivatives, '
+                f'{", ".join(str(highest[item]) for item in unknowns)}, in {descriptions}. Give one equation per '
+                'derivative.'
+            )
+            raise ValidationError(error_msg)
+        zero = dict.fromkeys(unknowns, 0)
+        coefficients = [[relation.expression.diff(item) for item in unknowns] for relation in relations]
+        right = [-relation.expression.subs(zero) for relation in relations]
+        references = {key: value for relation in relations for key, value in relation.spec.references.items()}
+        rows = max(relation.spec.rows for relation in relations)
+        owner = ', '.join(dict.fromkeys(relation.spec.owner for relation in relations))
+        merged = KernelSpec(owner, SimpleNamespace(), references, rows)
+        laws: list[BaseLaw]
+        if len(unknowns) <= _EQUATION_UNKNOWNS:
+            system = matrix(SR, coefficients)
+            if system.det().simplify_full().is_trivial_zero():
+                error_msg = f'The highest derivatives of {descriptions} cannot be solved for: the system is singular.'
+                raise ValidationError(error_msg)
+            solution = system.solve_right(vector([SR(item) for item in right]), check=False)
+            laws = [RateLaw(highest[item], value) for item, value in zip(unknowns, solution, strict=True)]
+        else:
+            entries = [entry for row in coefficients for entry in row] + right
+            laws = [
+                RateLaw(
+                    highest[item],
+                    CallSpec(OrdersPass._numeric_solution(rows, len(unknowns), index), tuple(entries)),
+                )
+                for index, item in enumerate(unknowns)
+            ]
+        return [*kept, (merged, laws)]
+
+    @staticmethod
+    def _exact_solution(relations: list[_RelationSpec]) -> list[Expression] | None:
+        """Return the unique explicit solution of static equations for their targets, or `None` when Sage finds none."""
+        unknowns = [item.target for item in relations]
+        reduced = {
+            name for item in relations for call in reductions_in(item.expression) for name in call.call.variables()
+        }
+        if len(relations) > _EQUATION_UNKNOWNS or reduced & set(unknowns):
+            return None
+        known = {name for item in relations for name in item.expression.variables()}
+        try:
+            solutions = solve([item.expression == 0 for item in relations], unknowns, solution_dict=True)
+        except TypeError:
+            return None
+        if len(solutions) != 1 or any(item not in solutions[0] for item in unknowns):
+            return None
+        values = [SR(solutions[0][item]) for item in unknowns]
+        explicit = all(set(value.variables()) <= known - set(unknowns) for value in values)
+        return values if explicit else None
+
+    @staticmethod
+    def _solve_static(
+        specs: list[tuple[KernelSpec, list[BaseLaw | _RelationSpec]]],
+    ) -> list[tuple[KernelSpec, list[BaseLaw]]]:
+        """Return specs whose equations are replaced by updates of an exact solution, or else rates of their residuals.
+
+        An equation without a state as its target is left out, since the compiler reports it.
+        """
+        declared = [item for _, laws in specs for item in laws if isinstance(item, _RelationSpec)]
+        relations = OrdersPass._summed([item for item in declared if item.key is not None])
+        kept = [(spec, [law for law in laws if not isinstance(law, _RelationSpec)]) for spec, laws in specs]
+        if not relations:
+            return kept
+        values = OrdersPass._exact_solution(relations)
+        if values is None:
+            return [*kept, *((item.spec, [RateLaw(item.target, item.expression)]) for item in relations)]
+        pairs = zip(relations, values, strict=True)
+        return [*kept, *((item.spec, [UpdateLaw(item.target, value)]) for item, value in pairs)]

skcomplex/engine/compile/passes/_owners.py

@@ -0,0 +1,90 @@
+"""Keep the laws of the owners a compilation compiles, masked to the rows present of capacity groups."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from collections import defaultdict
+
+from sage.all__sagemath_symbolics import SR, Expression
+from sage.modules.free_module_element import FreeModuleElement
+
+from ....core.laws import BaseLaw, JumpLaw, NoiseLaw, RateLaw, UpdateLaw
+from ..._utils import vector
+from ...problems import DeclarationsSpec, KernelSpec
+from .._base import BasePass
+from .._compilation import Compilation, Laws
+from ._census import CensusPass
+from ._kernels import KernelsPass
+from ._mask_requests import MaskRequestsPass
+
+
+class OwnersPass(BasePass):
+    """Pass that keeps the laws of the compiled owners, masks them to the rows present, and finds their kinds."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('shifted', 'apart', 'nodes', 'layout')
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('drawn', 'kinds', 'drawn_apart')
+
+    def _run(self, inputs: object = None) -> None:
+        """Keep the laws of the owners of the compilation and find their kinds."""
+        compilation = self.compilation_
+        declarations = Compilation._required(compilation.layout, 'layout')
+        agents = {node.path for node in Compilation._required(compilation.nodes, 'nodes') if node.is_agent}
+        owned = self._owned(Compilation._required(compilation.shifted, 'shifted'), compilation.owners, agents)
+        compilation.drawn = [(spec, self._masked(spec, laws, declarations)) for spec, laws in owned]
+        apart = Compilation._required(compilation.apart, 'apart')
+        compilation.drawn_apart = self._owned(apart, compilation.owners, agents)
+        compilation.kinds = self._law_kinds([*compilation.drawn, *compilation.drawn_apart], agents)
+
+    @staticmethod
+    def _kept_update(law: UpdateLaw, mask: Expression) -> UpdateLaw:
+        """Return an update law that keeps the value of its target on the free rows of a capacity layout."""
+        value, kept = (
+            MaskRequestsPass._masked_value(law.value, mask),
+            MaskRequestsPass._masked_value(law._get_targets()[0], 1 - mask),
+        )
+        if isinstance(value, FreeModuleElement) and isinstance(kept, FreeModuleElement):
+            return BasePass._replaced(law, value=vector(a + b for a, b in zip(value, kept, strict=True)))
+        return BasePass._replaced(law, value=SR(value) + SR(kept))
+
+    @staticmethod
+    def _masked(spec: KernelSpec, laws: list[BaseLaw], declarations: DeclarationsSpec) -> list[BaseLaw]:
+        """Return laws that leave the free rows of a capacity layout unchanged and fire no event for them."""
+        mask = MaskRequestsPass._mask_of(spec, declarations)
+        if mask is None:
+            return laws
+        masked: list[BaseLaw] = []
+        for law in laws:
+            if isinstance(law, RateLaw | NoiseLaw):
+                masked.append(BasePass._replaced(law, value=MaskRequestsPass._masked_value(law.value, mask)))
+            elif isinstance(law, JumpLaw) and law.rate is not None:
+                masked.append(BasePass._replaced(law, rate=MaskRequestsPass._masked_value(law.rate, mask)))
+            elif isinstance(law, UpdateLaw) and isinstance(law.value, Expression | FreeModuleElement | int | float):
+                masked.append(OwnersPass._kept_update(law, mask))
+            else:
+                masked.append(law)
+        return masked
+
+    @staticmethod
+    def _owned(specs: Laws, owners: frozenset[str] | None, agents: set[str]) -> Laws:
+        """Return the laws of the components in `owners`, or every law."""
+        return [
+            (
+                spec,
+                laws if owners is None else [law for law in laws if CensusPass._law_owner(spec, law, agents) in owners],
+            )
+            for spec, laws in specs
+        ]
+
+    @staticmethod
+    def _law_kinds(specs: list[tuple[KernelSpec, list[BaseLaw]]], agents: set[str]) -> dict[str, set[type]]:
+        """Return the kinds of the laws of every component."""
+        kinds: dict[str, set[type]] = defaultdict(set)
+        for spec, laws in specs:
+            for law in laws:
+                kinds[CensusPass._law_owner(spec, law, agents)].add(KernelsPass._kind_of(law))
+        return kinds

skcomplex/engine/compile/passes/_particles.py

@@ -0,0 +1,69 @@
+"""Compile particles: pair interactions within a cutoff and the boundaries of the continuous space they move in."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from sage.all__sagemath_symbolics import SR
+
+from ....core.laws import BaseLaw, BoundaryLaw
+from ....core.laws.utils import either, mod, where
+from ....core.spaces import ContinuousSpace
+from ....types import VariableKind
+from ..._utils import components_of, declarations_of
+from ...problems import BlockSpec, KernelSpec
+from .._base import BasePass
+from .._compilation import Compilation
+
+
+class BoundaryLawsPass(BasePass):
+    """Pass that adds the laws by which the boundary of a continuous space acts on the positions of components."""
+
+    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 ('collected',)
+
+    def _run(self, inputs: object = None) -> None:
+        """Add the boundary laws of continuous spaces."""
+        compilation = self.compilation_
+        compilation.collected = [
+            (spec, [*laws, *self._space_boundary_laws(block, spec)], block)
+            for spec, laws, block in Compilation._required(compilation.collected, 'collected')
+        ]
+
+    @staticmethod
+    def _space_boundary_laws(block: BlockSpec, spec: KernelSpec) -> list[BaseLaw]:
+        """Return the laws by which the boundary of a continuous space acts on the position states of a component.
+
+        A periodic boundary wraps every position component into the box. A reflecting boundary mirrors a position that
+        crossed a wall back into the box and reverses the velocity component across the wall, where the velocity is the
+        first derivative of a position of order 2.
+        """
+        space = block.node.space
+        if block.node.interaction or not isinstance(space, ContinuousSpace) or space.boundary == 'open':
+            return []
+        declarations = declarations_of(block.node.component_type, VariableKind.STATE)
+        laws: list[BaseLaw] = []
+        for name, declaration in declarations.items():
+            if not declaration.is_place:
+                continue
+            velocity_name = f'{name}_d1' if declaration.order > 1 else None
+            positions = [SR(item) for item in components_of(getattr(spec.namespace, name))]
+            velocities = (
+                [SR(item) for item in components_of(getattr(spec.namespace, velocity_name))]
+                if velocity_name
+                else [None] * len(positions)
+            )
+            for position, velocity, side in zip(positions, velocities, space.extent_, strict=True):
+                if space.boundary == 'periodic':
+                    laws.append(BoundaryLaw(position, mod(position, side)))
+                    continue
+                below, above = position < 0, position > side
+                laws.append(BoundaryLaw(position, where(below, -position, where(above, 2 * side - position, position))))
+                if velocity is not None:
+                    laws.append(BoundaryLaw(velocity, where(either(below, above), -velocity, velocity)))
+        return laws