scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/engine/compile/passes/_reductions.py

@@ -0,0 +1,84 @@
+"""Replace the reductions and neighbourhood reductions of laws by placeholders, compiled once each."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from dataclasses import replace
+
+from ...problems import DeclarationsSpec, KernelSpec, ReductionScheduleSpec
+from ...types import ReadKind
+from .._base import BasePass
+from .._compilation import Compilation
+from ._reduction_lowering import ReductionLowering
+
+
+class ReductionsPass(BasePass):
+    """Pass that lowers the reductions of the laws, of the laws set apart, and of the events, in that order."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('drawn', 'drawn_apart', 'layout', 'draws', 'events')
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('reduced', 'reduced_apart', 'reductions', 'events')
+
+    def _run(self, inputs: object = None) -> None:
+        """Lower the reductions of the drawn laws, the laws set apart, and the events."""
+        compilation = self.compilation_
+        declarations = Compilation._required(compilation.layout, 'layout')
+        reductions = ReductionLowering().check().prepare(compilation)
+        specs = Compilation._required(compilation.drawn, 'drawn')
+        apart = Compilation._required(compilation.drawn_apart, 'drawn_apart')
+        crossings = Compilation._required(compilation.events, 'events')
+        lowered = reductions.run([*specs, *apart]).lowered_
+        events = reductions.run([(spec, [event]) for spec, event in crossings]).lowered_
+        compilation.reduced = lowered[: len(specs)]
+        compilation.reduced_apart = lowered[len(specs) :]
+        compilation.events = [(spec, laws[0]) for spec, laws in events]
+        reductions._apply_references()
+        compilation._replace_specs(
+            {
+                id(spec): self._pruned(spec, declarations)
+                for spec, _ in [*compilation.reduced, *compilation.reduced_apart]
+            },
+        )
+        compilation.reductions = ReductionScheduleSpec(
+            tuple(reductions.found_.values()),
+            reductions.parameters_,
+            tuple(reductions.neighbourhoods_.values()),
+            tuple(reductions.sequence_),
+        )
+
+    @staticmethod
+    def _pruned(spec: KernelSpec, declarations: DeclarationsSpec) -> KernelSpec:
+        """Return a spec without the references of the groups it reads only through reductions, keeping operands.
+
+        Kernels then loop over its own group.
+
+        A spec without such references is returned itself.
+        """
+        if spec.pairs is not None:
+            return spec
+        owners = {
+            reference.entry.name.rpartition('.')[0]
+            for reference in spec.references.values()
+            if reference.source is ReadKind.MEMBER
+        }
+        foreign = (owners & declarations.groups) - {spec.group, *spec.aligned}
+        if not foreign:
+            return spec
+        operands = {
+            symbol
+            for reference in spec.references.values()
+            if reference.source is ReadKind.DERIVED
+            for symbol in reference.derived.symbols
+        }
+        references = {
+            item: reference
+            for item, reference in spec.references.items()
+            if reference.source is not ReadKind.MEMBER
+            or reference.entry.name.rpartition('.')[0] not in foreign
+            or item in operands
+        }
+        return replace(spec, references=references)

skcomplex/engine/compile/passes/_renewal_problem.py

@@ -0,0 +1,357 @@
+"""Pass that adds the compiled renewal laws and the symbols of their counts to the problem."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+
+import numpy as np
+import numpy.typing as npt
+from sage.all__sagemath_symbolics import SR, Expression
+from sage.modules.free_module_element import FreeModuleElement
+
+from ....core.laws.utils import draws_in, reductions_in
+from ....errors import PipelineError, ValidationError
+from ....specs import DrawSpec
+from ....specs._draw_spec import DRAWS
+from ....types import Indices
+from ..._utils import components_of, symbol, symbols_of
+from ...problems import ExpressionPrinter, ReferenceSpec
+from ...problems._renewal_kernel import _READ_SOURCES, MemberFunction, RenewalKernel, Sampler
+from ...types import ReadKind
+from .._base import BasePass
+from .._bound_renewal_spec import BoundRenewalSpec
+from .._compilation import Compilation
+from .._draw_lowering import DrawLowering
+from .._renewal_law import RenewalLaw
+
+
+class RenewalProblemPass(BasePass):
+    """Pass that adds the compiled renewal laws and the symbols of their counts to the problem."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('problem', 'renewals', 'layout')
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('problem',)
+
+    def _run(self, inputs: object = None) -> None:
+        """Add the renewal laws to the problem."""
+        compilation = self.compilation_
+        problem = Compilation._required(compilation.problem, 'problem')
+        time = Compilation._required(compilation.layout, 'layout').time
+        renewals = compilation.renewals
+        if renewals is None:
+            error_msg = 'RenewalProblemPass reads the renewal laws, which no pass wrote.'
+            raise PipelineError(error_msg)
+        symbols = {item.entry.name: item.symbol for item in renewals}
+        compilation.problem = replace(
+            problem,
+            renewals=self._compile_renewals(renewals, time, compilation.owners),
+            symbols={**problem.symbols, **symbols},
+        )
+
+    @staticmethod
+    def _compile_renewals(
+        renewals: list[BoundRenewalSpec],
+        time: Expression,
+        owners: frozenset[str] | None,
+    ) -> tuple[RenewalKernel, ...]:
+        """Return the renewal laws of the components a problem holds, compiled for their members."""
+        return tuple(
+            RenewalProblemPass._compile_renewal(
+                item.spec.owner,
+                item.law,
+                item.spec.references,
+                time=time,
+                rows=item.spec.rows,
+                label=item.label,
+                group=item.group,
+                counts=item.entry.start + np.arange(item.entry.size, dtype=np.intp),
+            )
+            for item in renewals
+            if owners is None or item.group in owners
+        )
+
+    @staticmethod
+    def _declared(owner: str, found: list[DrawSpec]) -> dict[str, DrawSpec]:
+        """Return the draws of a renewal law by name, after checking that each name has one declaration."""
+        declared: dict[str, DrawSpec] = {}
+        for item in found:
+            known = declared.setdefault(item.name, item)
+            if (known.kind, known.distribution, known.parameters, known.arguments) != (
+                item.kind,
+                item.distribution,
+                item.parameters,
+                item.arguments,
+            ):
+                error_msg = (
+                    f'A renewal law of {owner} uses the draw name {item.name!r} for {known.call} and for {item.call}. '
+                    'Use one declaration per name, or give the draws different names.'
+                )
+                raise ValidationError(error_msg)
+        return declared
+
+    @staticmethod
+    def _lowest_value(owner: str, description: str, waiting: Expression) -> float:
+        """Return the lowest value a waiting time that is a single draw can take, or 0 when it is not known."""
+        operator = waiting.operator()
+        if operator is None or getattr(operator, 'name', lambda: '')() not in DRAWS:
+            return 0.0
+        found = draws_in(waiting)[0]
+        numbers = [float(item) if SR(item).is_numeric() else None for item in found.arguments]
+        if found.kind == 'normal':
+            return -math.inf
+        if found.kind == 'uniform':
+            return numbers[0] if numbers[0] is not None else 0.0
+        if found.kind != 'draw':
+            return 0.0
+        distribution = DrawLowering._distribution_of(owner, description, found)
+        values = dict(zip(found.keywords, numbers, strict=True))
+        shapes = {key: value for key, value in values.items() if key not in {'loc', 'scale'}}
+        lowest = (
+            float(distribution.support(**shapes)[0])
+            if all(value is not None for value in shapes.values())
+            else float(distribution.a)
+        )
+        if lowest < 0:
+            return lowest
+        loc = values.get('loc', 0.0)
+        return 0.0 if loc is None else loc
+
+    @staticmethod
+    def _member_function(
+        owner: str,
+        expressions: Sequence[Expression],
+        references: Mapping[Expression, ReferenceSpec],
+        slots: dict[Expression, str],
+        time: Expression,
+    ) -> MemberFunction:
+        """Return the function of renewing members that evaluates expressions, after checking the symbols they read."""
+        arguments = sorted(symbols_of(list(expressions)) - {time}, key=str)
+        readers: list[ReferenceSpec | str] = []
+        for item in arguments:
+            if item in slots:
+                readers.append(slots[item])
+                continue
+            reference = references.get(item)
+            if reference is None or reference.source not in _READ_SOURCES:
+                error_msg = (
+                    f'A renewal law of {owner} reads {item}, which is not a state or a parameter of its component. '
+                    'Renewal laws read the states and parameters of the renewing member.'
+                )
+                raise ValidationError(error_msg)
+            readers.append(reference)
+        printer = ExpressionPrinter(time=time, compiled=True).check().prepare(arguments)
+        function = printer.run(list(expressions)).code_
+        if not callable(function):
+            error_msg = f'The printer returns no function of the renewal laws of {owner}.'
+            raise TypeError(error_msg)
+
+        def evaluate(*values: object) -> list[npt.ArrayLike]:
+            results = function(*values)
+            if not isinstance(results, list):
+                error_msg = f'The function of the renewal laws of {owner} returns no list of values.'
+                raise TypeError(error_msg)
+            return results
+
+        return evaluate, tuple(readers)
+
+    @staticmethod
+    def _ordered(found: list[DrawSpec]) -> list[DrawSpec]:
+        """Return draws ordered so that every draw comes after the draws in its arguments."""
+        ordered: list[DrawSpec] = []
+        pending = list(found)
+        while pending:
+            done = {item.name for item in ordered}
+            ready = next(item for item in pending if {inner.name for inner in draws_in(list(item.arguments))} <= done)
+            ordered.append(ready)
+            pending.remove(ready)
+        return ordered
+
+    @staticmethod
+    def _recorded_states(
+        group: str,
+        references: Mapping[Expression, ReferenceSpec],
+        rows: int,
+    ) -> tuple[Indices, tuple[str, ...]]:
+        """Return the flat indices and the names of the states of every member of the group a renewal law renews."""
+        columns: dict[int, tuple[Indices, str]] = {}
+        for reference in references.values():
+            owned = reference.entry.name.rpartition('.')[0] == group
+            if not reference.is_state or reference.source not in _READ_SOURCES or not owned:
+                continue
+            flat = reference.flat_indices if reference.source is ReadKind.MEMBER else np.asarray([reference.index])
+            if flat.size != rows:
+                continue
+            name = (
+                reference.entry.name if reference.entry.columns == 1 else f'{reference.entry.name}[{reference.column}]'
+            )
+            columns[int(flat[0])] = (np.asarray(flat, dtype=np.intp), name)
+        ordered = [columns[key] for key in sorted(columns)]
+        indices = np.stack([flat for flat, _ in ordered], axis=-1) if ordered else np.zeros((rows, 0), dtype=np.intp)
+        return indices, tuple(name for _, name in ordered)
+
+    @staticmethod
+    def _target_places(
+        owner: str,
+        targets: list[Expression],
+        references: Mapping[Expression, ReferenceSpec],
+        rows: int,
+    ) -> Indices:
+        """Return the flat indices every reset component writes, one row per component and one column per member."""
+        places = []
+        for item in targets:
+            reference = references.get(item)
+            if reference is None or not reference.is_state or reference.source not in _READ_SOURCES:
+                error_msg = (
+                    f'A renewal law of {owner} resets {item}, which is not a state of an element or a group member.'
+                )
+                raise ValidationError(error_msg)
+            if reference.source is ReadKind.SINGLE and rows > 1:
+                error_msg = (
+                    f'A renewal law of {owner} resets {item}, a state of a single element, while its members renew on '
+                    'their own clocks. Reset the states of the renewing members.'
+                )
+                raise ValidationError(error_msg)
+            flat = reference.flat_indices if reference.source is ReadKind.MEMBER else np.asarray([reference.index])
+            places.append(np.asarray(flat, dtype=np.intp))
+        return np.asarray(places, dtype=np.intp).reshape(len(places), rows)
+
+    @staticmethod
+    def _named_reads(
+        group: str,
+        references: Mapping[Expression, ReferenceSpec],
+        sampler: object,
+    ) -> dict[str, ReferenceSpec]:
+        """Return the scalar states and parameters of the renewing members by name, for a function of the wait."""
+        if sampler is None:
+            return {}
+        return {
+            reference.entry.name.rpartition('.')[2]: reference
+            for reference in references.values()
+            if reference.source in _READ_SOURCES
+            and reference.entry.columns == 1
+            and reference.entry.name.rpartition('.')[0] == group
+        }
+
+    @staticmethod
+    def _compile_renewal(
+        owner: str,
+        law: RenewalLaw,
+        references: Mapping[Expression, ReferenceSpec],
+        *,
+        time: Expression,
+        rows: int,
+        label: str,
+        group: str,
+        counts: Indices,
+    ) -> RenewalKernel:
+        """Return a renewal law compiled for the members of its component.
+
+        Args:
+            owner:
+                The path of the component the law belongs to.
+
+            law:
+                The renewal law.
+
+            references:
+                The references of the symbols of the component.
+
+            time:
+                The time symbol.
+
+            rows:
+                The number of members that renew on their own clocks.
+
+            label:
+                The name of the law.
+
+            group:
+                The path of the element or group whose states the law renews.
+
+            counts:
+                The flat index of the hidden renewal count of every member.
+
+        Returns:
+            renewal:
+                The compiled renewal law.
+
+        Raises:
+            ValidationError:
+                The waiting time can be negative, the law reads a reduction or a symbol of another component, resets a
+                symbol that is not a state of the renewing members, or gives one draw name two declarations.
+        """
+        description = f'renewal law {label}'
+        reset = law.reset or {}
+        targets = [item for target in reset for item in components_of(target)]
+        values = [
+            SR(item)
+            for target, value in reset.items()
+            for item in (
+                components_of(value) if isinstance(value, FreeModuleElement) else [value] * len(components_of(target))
+            )
+        ]
+        sampler = law.waiting if callable(law.waiting) and not isinstance(law.waiting, Expression) else None
+        waiting = SR(0) if sampler is not None else SR(law.waiting)
+        if any(reductions_in(item) for item in [*values, waiting]):
+            error_msg = (
+                f'The {description} of {owner} reads a reduction over a group. Renewal laws read the states and '
+                'parameters of the renewing member.'
+            )
+            raise ValidationError(error_msg)
+        if RenewalProblemPass._lowest_value(owner, description, waiting) < 0:
+            error_msg = (
+                f'The {description} of {owner} draws its waiting time from {waiting}, which can be negative. Draw '
+                "waiting times from a distribution with nonnegative support, such as 'expon', 'pareto', or 'lomax'."
+            )
+            raise ValidationError(error_msg)
+        first = RenewalProblemPass._declared(owner, draws_in(values))
+        later = {
+            name: item
+            for name, item in RenewalProblemPass._declared(owner, [*first.values(), *draws_in(waiting)]).items()
+            if name not in first
+        }
+        slots = {name: symbol(f'_renewal_{name}') for name in [*first, *later]}
+        calls = {item.call: slots[item.name] for item in [*first.values(), *later.values()]}
+        names = {slot: name for name, slot in slots.items()}
+
+        def samplers(found: dict[str, DrawSpec]) -> tuple[Sampler, ...]:
+            return tuple(
+                (
+                    item,
+                    RenewalProblemPass._member_function(
+                        owner,
+                        [SR(arg).subs(calls) for arg in item.arguments],
+                        references,
+                        names,
+                        time,
+                    ),
+                )
+                for item in RenewalProblemPass._ordered(list(found.values()))
+            )
+
+        lowered = [item.subs(calls) for item in values]
+        return (
+            RenewalKernel(
+                label=label,
+                members=rows,
+                counts=counts,
+                states=RenewalProblemPass._recorded_states(group, references, rows)[0],
+                names=RenewalProblemPass._recorded_states(group, references, rows)[1],
+                targets=RenewalProblemPass._target_places(owner, targets, references, rows),
+                reset=RenewalProblemPass._member_function(owner, lowered, references, names, time) if lowered else None,
+                waiting=RenewalProblemPass._member_function(owner, [waiting.subs(calls)], references, names, time),
+                before=samplers(first),
+                after=samplers(later),
+                sampler=sampler,
+                reads=RenewalProblemPass._named_reads(group, references, sampler),
+            )
+            .check()
+            .prepare()
+        )

skcomplex/engine/compile/passes/_request_jumps.py

@@ -0,0 +1,51 @@
+"""Pass that turns the jumps that request topology changes into jumps of no state change, noting the requests."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from ....core.laws import BaseLaw, JumpLaw
+from ....specs import TopologyRequestSpec
+from ...problems import KernelSpec
+from ...problems._topology_kernel import TopologyKernel
+from .._base import BasePass
+from .._compilation import Compilation, Laws
+
+
+class RequestJumpsPass(BasePass):
+    """Pass that turns the jumps that request topology changes into jumps of no state change, noting the requests."""
+
+    def _get_reads(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass reads."""
+        return ('reduced',)
+
+    def _get_writes(self) -> tuple[str, ...]:
+        """Return the fields of the compilation the pass writes."""
+        return ('reduced', 'request_jumps')
+
+    def _run(self, inputs: object = None) -> None:
+        """Note the requests of the jumps."""
+        compilation = self.compilation_
+        compilation.reduced, compilation.request_jumps = self._set_request_jumps_apart(
+            Compilation._required(compilation.reduced, 'reduced'),
+        )
+
+    @staticmethod
+    def _set_request_jumps_apart(
+        specs: Laws,
+    ) -> tuple[Laws, dict[int, tuple[KernelSpec, TopologyRequestSpec]]]:
+        """Return laws whose jumps that request topology changes change no state, with the request of each such jump."""
+        requests: dict[int, tuple[KernelSpec, TopologyRequestSpec]] = {}
+        result: Laws = []
+        for spec, laws in specs:
+            kept: list[BaseLaw] = []
+            for law in laws:
+                request = TopologyKernel._request_of(law) if isinstance(law, JumpLaw) else None
+                if not isinstance(law, JumpLaw) or request is None:
+                    kept.append(law)
+                    continue
+                jump = JumpLaw(law.rate, {})
+                requests[id(jump)] = (spec, request)
+                kept.append(jump)
+            result.append((spec, kept))
+        return result, requests

skcomplex/engine/compile/passes/_residences.py

@@ -0,0 +1,140 @@
+"""Read the residence of states through hidden states that keep their previous values and counts."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from dataclasses import replace
+
+import numpy as np
+from sage.all__sagemath_symbolics import RR, SR, Expression
+from sage.modules.free_module_element import FreeModuleElement
+
+from ....core.laws import BaseLaw, UpdateLaw
+from ....core.laws.utils import where
+from ....errors import ValidationError
+from ....specs import EntrySpec
+from ..._utils import components_of, symbol, vector
+from ...problems import KernelSpec, ReferenceSpec
+from ...types import ReadKind
+from .._base import BasePass
+from .._compilation import Compilation
+from ._layout import LayoutPass
+
+RESIDENCE_PREFIX = '__residence'
+
+
+class ResidencesPass(BasePass):
+    """Pass that reads the residence of states through hidden states of their previous values and their counts."""
+
+    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:
+        """Replace the residences of the lowered laws by hidden states, with the update laws of those states."""
+        compilation = self.compilation_
+        lowered = Compilation._required(compilation.lowered, 'lowered')
+        replaced: dict[int, KernelSpec] = {}
+        for index, (spec, laws, block) in enumerate(lowered):
+            if not any(self._calls_in(law) for law in laws):
+                continue
+            references: dict[Expression, ReferenceSpec] = {}
+            found = self._with_residences(spec, laws, compilation, references)
+            lowered[index] = (spec, found, block)
+            replaced[id(spec)] = replace(spec, references={**spec.references, **references})
+        compilation._replace_specs(replaced)
+
+    @staticmethod
+    def _calls_in(law: BaseLaw) -> list[Expression]:
+        """Return the residences that the values of a law read."""
+        values = [item for item in law._get_values() if isinstance(item, Expression | FreeModuleElement)]
+        return [
+            call
+            for value in values
+            for item in components_of(value)
+            if isinstance(item, Expression)
+            for call in BasePass._calls_of(item, 'residence')
+        ]
+
+    @staticmethod
+    def _declare(
+        spec: KernelSpec,
+        reference: ReferenceSpec,
+        compilation: Compilation,
+        references: dict[Expression, ReferenceSpec],
+    ) -> tuple[Expression, Expression]:
+        """Return the symbols of the hidden previous value and count of a state, declared in the layout."""
+        declarations = Compilation._required(compilation.layout, 'layout')
+        entry = reference.entry
+        members = entry.members if reference.source is ReadKind.MEMBER else None
+        indices = reference.flat_indices if members is not None else np.asarray([reference.index])
+        initial = np.concatenate([np.zeros(0), *declarations.initial_states])[indices]
+        position = sum(item.name.startswith(RESIDENCE_PREFIX) for item in declarations.states) // 2
+        shape = (members,) if members is not None else ()
+        found = []
+        for name, value in (('previous', initial), ('count', np.full(initial.shape, -1.0))):
+            hidden = EntrySpec(f'{RESIDENCE_PREFIX}_{position}.{name}', declarations.ends[True], shape, RR, members)
+            declarations = LayoutPass._with_entry(declarations, hidden, np.asarray(value, dtype=float), is_state=True)
+            item = symbol(f'_residence_{position}_{name}')
+            references[item] = ReferenceSpec(hidden, True, 0, reference.source)
+            found.append(item)
+        compilation.layout = declarations
+        return found[0], found[1]
+
+    @staticmethod
+    def _with_residences(
+        spec: KernelSpec,
+        laws: list[BaseLaw],
+        compilation: Compilation,
+        references: dict[Expression, ReferenceSpec],
+    ) -> list[BaseLaw]:
+        """Return update laws with every residence replaced by its count, followed by the laws of the hidden states.
+
+        The references of the hidden states are added to `references`, which the spec receives after its laws.
+        """
+        counts: dict[Expression, Expression] = {}
+        added: list[BaseLaw] = []
+        for law in laws:
+            for call in ResidencesPass._calls_in(law):
+                if not isinstance(law, UpdateLaw):
+                    error_msg = (
+                        f'A {type(law).__name__} of {spec.owner} reads {call}, which only update laws of discrete time '
+                        'read.'
+                    )
+                    raise ValidationError(error_msg)
+                item = call.operands()[0]
+                reference = spec.references.get(item)
+                if (
+                    reference is None
+                    or not reference.is_state
+                    or reference.source
+                    not in {
+                        ReadKind.SINGLE,
+                        ReadKind.MEMBER,
+                    }
+                ):
+                    error_msg = f'{spec.owner} reads {call}, but {item} is not a state of an element or a group member.'
+                    raise ValidationError(error_msg)
+                if call in counts:
+                    continue
+                previous, count = ResidencesPass._declare(spec, reference, compilation, references)
+                counts[call] = where(item == previous, count + 1, 0)
+                added += [UpdateLaw(previous, item), UpdateLaw(count, counts[call])]
+        return [*(ResidencesPass._substituted(law, counts) for law in laws), *added]
+
+    @staticmethod
+    def _substituted(law: BaseLaw, counts: dict[Expression, Expression]) -> BaseLaw:
+        """Return an update law with its residences replaced by their counts, or any other law unchanged."""
+        if not isinstance(law, UpdateLaw) or not counts:
+            return law
+        value = law.value
+        if isinstance(value, FreeModuleElement):
+            value = vector(SR(item).subs(counts) for item in value)
+        elif isinstance(value, Expression):
+            value = value.subs(counts)
+        order = law.order.subs(counts) if isinstance(law.order, Expression) else law.order
+        return BasePass._replaced(law, value=value, order=order)