flakepl 0.3.1__py3-none-any.whl

flake/runtime.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .actions import Action, Receive, Send, Tau
+from .agent import Agent
+from .process import Process
+from .sos import transitions
+
+
+@dataclass(frozen=True, slots=True)
+class GlobalState:
+    """
+    Environment-level state.
+
+    Agent-local state is stored in Agent.state.
+    """
+
+    values: tuple[tuple[str, Any], ...] = ()
+
+    @classmethod
+    def from_dict(
+        cls,
+        values: dict[str, Any],
+    ) -> GlobalState:
+
+        return cls(
+            values=tuple(
+                sorted(
+                    values.items(),
+                    key=lambda item: item[0],
+                )
+            )
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(
+            self.values
+        )
+
+    def get(
+        self,
+        name: str,
+        default: Any = None,
+    ) -> Any:
+
+        return dict(
+            self.values
+        ).get(
+            name,
+            default,
+        )
+
+    def with_value(
+        self,
+        name: str,
+        value: Any,
+    ) -> GlobalState:
+
+        values = self.to_dict()
+
+        values[name] = value
+
+        return GlobalState.from_dict(
+            values
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class Configuration:
+    """
+    Global system configuration.
+
+    Conceptually:
+
+        C = (s, A)
+
+    where:
+
+        s = global state
+        A = tuple of agents
+    """
+
+    state: GlobalState
+    agents: tuple[Agent, ...]
+
+    def __post_init__(self) -> None:
+
+        names = [
+            agent.name
+            for agent in self.agents
+        ]
+
+        if len(names) != len(set(names)):
+            raise ValueError(
+                "Configuration contains "
+                "duplicate agent names"
+            )
+
+    def agent(
+        self,
+        name: str,
+    ) -> Agent:
+
+        for agent in self.agents:
+
+            if agent.name == name:
+                return agent
+
+        raise KeyError(
+            f"Unknown agent: {name}"
+        )
+
+    @property
+    def processes(
+        self,
+    ) -> tuple[Process, ...]:
+
+        return tuple(
+            agent.process
+            for agent in self.agents
+        )
+
+    def with_agent(
+        self,
+        updated: Agent,
+    ) -> Configuration:
+
+        if not any(
+            agent.name == updated.name
+            for agent in self.agents
+        ):
+            raise KeyError(
+                f"Unknown agent: "
+                f"{updated.name}"
+            )
+
+        updated_agents = tuple(
+            updated
+            if agent.name == updated.name
+            else agent
+            for agent in self.agents
+        )
+
+        return Configuration(
+            state=self.state,
+            agents=updated_agents,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class SystemTransition:
+    """
+    Global transition:
+
+        C --action--> C'
+    """
+
+    source: Configuration
+    action: Action
+    target: Configuration
+
+
+def _replace_two_agents(
+    agents: tuple[Agent, ...],
+    first: Agent,
+    second: Agent,
+) -> tuple[Agent, ...]:
+
+    if first.name == second.name:
+        raise ValueError(
+            "Cannot replace the same agent twice"
+        )
+
+    result: list[Agent] = []
+
+    found_first = False
+    found_second = False
+
+    for agent in agents:
+
+        if agent.name == first.name:
+
+            result.append(first)
+            found_first = True
+
+        elif agent.name == second.name:
+
+            result.append(second)
+            found_second = True
+
+        else:
+
+            result.append(agent)
+
+    if not found_first:
+        raise KeyError(
+            f"Unknown agent: {first.name}"
+        )
+
+    if not found_second:
+        raise KeyError(
+            f"Unknown agent: {second.name}"
+        )
+
+    return tuple(result)
+
+
+def system_transitions(
+    configuration: Configuration,
+) -> tuple[SystemTransition, ...]:
+    """
+    Generate all system-level transitions.
+
+    Includes:
+
+        1. Independent agent actions.
+        2. Synchronous communication.
+
+    Communication:
+
+        send(c, v) | recv(c, x)
+        ---------------------
+                  τ
+
+    The sender advances its process.
+
+    The receiver advances its process and stores
+    v in local variable x.
+    """
+
+    result: list[SystemTransition] = []
+
+    agents = configuration.agents
+
+    # ========================================================
+    # Independent actions
+    # ========================================================
+
+    for index, agent in enumerate(agents):
+
+        for transition in transitions(
+            agent.process
+        ):
+
+            updated_agent = (
+                agent.with_process(
+                    transition.target
+                )
+            )
+
+            updated_agents = tuple(
+                updated_agent
+                if i == index
+                else other
+                for i, other in enumerate(
+                    agents
+                )
+            )
+
+            target = Configuration(
+                state=configuration.state,
+                agents=updated_agents,
+            )
+
+            result.append(
+                SystemTransition(
+                    source=configuration,
+                    action=transition.action,
+                    target=target,
+                )
+            )
+
+    # ========================================================
+    # Synchronous communication
+    # ========================================================
+
+    for sender_index, sender in enumerate(
+        agents
+    ):
+
+        sender_transitions = transitions(
+            sender.process
+        )
+
+        for sender_transition in (
+            sender_transitions
+        ):
+
+            if not isinstance(
+                sender_transition.action,
+                Send,
+            ):
+                continue
+
+            for receiver_index, receiver in enumerate(
+                agents
+            ):
+
+                if sender_index == receiver_index:
+                    continue
+
+                receiver_transitions = transitions(
+                    receiver.process
+                )
+
+                for receiver_transition in (
+                    receiver_transitions
+                ):
+
+                    if not isinstance(
+                        receiver_transition.action,
+                        Receive,
+                    ):
+                        continue
+
+                    send_action = (
+                        sender_transition.action
+                    )
+
+                    receive_action = (
+                        receiver_transition.action
+                    )
+
+                    if (
+                        send_action.channel
+                        != receive_action.channel
+                    ):
+                        continue
+
+                    updated_sender = (
+                        sender.with_process(
+                            sender_transition.target
+                        )
+                    )
+
+                    updated_receiver = (
+                        receiver
+                        .with_process(
+                            receiver_transition.target
+                        )
+                        .with_state(
+                            receive_action.variable,
+                            send_action.value,
+                        )
+                    )
+
+                    updated_agents = (
+                        _replace_two_agents(
+                            agents,
+                            updated_sender,
+                            updated_receiver,
+                        )
+                    )
+
+                    target = Configuration(
+                        state=configuration.state,
+                        agents=updated_agents,
+                    )
+
+                    result.append(
+                        SystemTransition(
+                            source=configuration,
+                            action=Tau(),
+                            target=target,
+                        )
+                    )
+
+    return tuple(result)

flake/semantics.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from .actions import (
+    Receive,
+    Send,
+    Tau,
+)
+from .agent import Agent
+from .runtime import (
+    Configuration,
+    SystemTransition,
+)
+from .sos import transitions
+
+
+def _replace_agents(
+    configuration: Configuration,
+    updates: Iterable[Agent],
+) -> Configuration:
+    """
+    Return a configuration with the supplied agents replaced.
+    """
+
+    result = configuration
+
+    for agent in updates:
+        result = result.with_agent(agent)
+
+    return result
+
+
+def synchronous_system_transitions(
+    configuration: Configuration,
+) -> tuple[SystemTransition, ...]:
+    """
+    Strict synchronous process semantics.
+
+    Tau transitions are executed independently.
+
+    Send and Receive transitions never execute independently.
+    They must synchronize on the same channel.
+
+    Therefore:
+
+        send(c, v) | recv(c, x)
+
+    becomes one transition where:
+
+        receiver.x = v
+
+    while the two processes advance simultaneously.
+
+    This semantics is useful for modeling protocols where
+    communication is synchronous, such as the examples in
+    the FlakePL benchmark suite.
+    """
+
+    result: list[SystemTransition] = []
+
+    agents = configuration.agents
+
+    # ------------------------------------------------------------------
+    # Independent internal transitions.
+    # ------------------------------------------------------------------
+
+    for agent in agents:
+        for transition in transitions(
+            agent.process
+        ):
+            if not isinstance(
+                transition.action,
+                Tau,
+            ):
+                continue
+
+            updated_agent = agent.with_process(
+                transition.target
+            )
+
+            target = configuration.with_agent(
+                updated_agent
+            )
+
+            result.append(
+                SystemTransition(
+                    source=configuration,
+                    action=transition.action,
+                    target=target,
+                )
+            )
+
+    # ------------------------------------------------------------------
+    # Synchronous communication.
+    #
+    # We inspect each pair only once.
+    # ------------------------------------------------------------------
+
+    for left_index in range(
+        len(agents)
+    ):
+        for right_index in range(
+            left_index + 1,
+            len(agents),
+        ):
+            left_agent = agents[left_index]
+            right_agent = agents[right_index]
+
+            left_transitions = transitions(
+                left_agent.process
+            )
+
+            right_transitions = transitions(
+                right_agent.process
+            )
+
+            for left_transition in left_transitions:
+                left_action = left_transition.action
+
+                for right_transition in right_transitions:
+                    right_action = right_transition.action
+
+                    # --------------------------------------------------
+                    # left sends, right receives
+                    # --------------------------------------------------
+
+                    if (
+                        isinstance(
+                            left_action,
+                            Send,
+                        )
+                        and isinstance(
+                            right_action,
+                            Receive,
+                        )
+                        and left_action.channel
+                        == right_action.channel
+                    ):
+                        updated_left = (
+                            left_agent.with_process(
+                                left_transition.target
+                            )
+                        )
+
+                        updated_right = (
+                            right_agent
+                            .with_process(
+                                right_transition.target
+                            )
+                            .with_state(
+                                right_action.variable,
+                                left_action.value,
+                            )
+                        )
+
+                        target = _replace_agents(
+                            configuration,
+                            (
+                                updated_left,
+                                updated_right,
+                            ),
+                        )
+
+                        result.append(
+                            SystemTransition(
+                                source=configuration,
+                                action=Tau(),
+                                target=target,
+                            )
+                        )
+
+                    # --------------------------------------------------
+                    # left receives, right sends
+                    # --------------------------------------------------
+
+                    elif (
+                        isinstance(
+                            left_action,
+                            Receive,
+                        )
+                        and isinstance(
+                            right_action,
+                            Send,
+                        )
+                        and left_action.channel
+                        == right_action.channel
+                    ):
+                        updated_left = (
+                            left_agent
+                            .with_process(
+                                left_transition.target
+                            )
+                            .with_state(
+                                left_action.variable,
+                                right_action.value,
+                            )
+                        )
+
+                        updated_right = (
+                            right_agent.with_process(
+                                right_transition.target
+                            )
+                        )
+
+                        target = _replace_agents(
+                            configuration,
+                            (
+                                updated_left,
+                                updated_right,
+                            ),
+                        )
+
+                        result.append(
+                            SystemTransition(
+                                source=configuration,
+                                action=Tau(),
+                                target=target,
+                            )
+                        )
+
+    return tuple(result)

flake/sos.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .actions import Action, Receive, Send, Tau
+from .process import Choice, Nil, Parallel, Prefix, Process
+
+
+@dataclass(frozen=True, slots=True)
+class Transition:
+    """One process-level operational transition: P --action--> P'."""
+
+    action: Action
+    target: Process
+
+
+def transitions(process: Process) -> tuple[Transition, ...]:
+    """Generate all one-step SOS transitions for a process.
+
+    The MVP supports prefix, nondeterministic choice, parallel composition,
+    and synchronous communication between matching send/receive prefixes.
+    """
+
+    if isinstance(process, Nil):
+        return ()
+
+    if isinstance(process, Prefix):
+        return (Transition(process.action, process.continuation),)
+
+    if isinstance(process, Choice):
+        result: list[Transition] = []
+        for option in process.options:
+            result.extend(transitions(option))
+        return tuple(result)
+
+    if isinstance(process, Parallel):
+        result: list[Transition] = []
+        processes = process.processes
+
+        # Independent actions.
+        for index, current in enumerate(processes):
+            for transition in transitions(current):
+                updated = list(processes)
+                updated[index] = transition.target
+                result.append(
+                    Transition(
+                        transition.action,
+                        Parallel(tuple(updated)),
+                    )
+                )
+
+        # Pairwise synchronous communication.
+        for left_index in range(len(processes)):
+            for right_index in range(left_index + 1, len(processes)):
+                left = processes[left_index]
+                right = processes[right_index]
+
+                left_transitions = transitions(left)
+                right_transitions = transitions(right)
+
+                for left_transition in left_transitions:
+                    left_action = left_transition.action
+                    for right_transition in right_transitions:
+                        right_action = right_transition.action
+
+                        if isinstance(left_action, Send) and isinstance(right_action, Receive):
+                            if left_action.channel != right_action.channel:
+                                continue
+                            updated = list(processes)
+                            updated[left_index] = left_transition.target
+                            updated[right_index] = right_transition.target
+                            result.append(
+                                Transition(
+                                    Tau(),
+                                    Parallel(tuple(updated)),
+                                )
+                            )
+
+                        elif isinstance(left_action, Receive) and isinstance(right_action, Send):
+                            if left_action.channel != right_action.channel:
+                                continue
+                            updated = list(processes)
+                            updated[left_index] = left_transition.target
+                            updated[right_index] = right_transition.target
+                            result.append(
+                                Transition(
+                                    Tau(),
+                                    Parallel(tuple(updated)),
+                                )
+                            )
+
+        return tuple(result)
+
+    raise TypeError(f"Unsupported process type: {type(process).__name__}")
+
+
+__all__ = ["Transition", "transitions"]