sofic 0.1.0__py3-none-any.whl

sofic/shifts/cover_construction.py

@@ -0,0 +1,76 @@
+"""Fischer and Krieger cover constructions."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+from sofic.graph import ATTR_SYMBOL, TransitionGraph
+from sofic.shifts.covers import LeftFischerCover, LeftKriegerCover, RightFischerCover, RightKriegerCover
+from sofic.shifts.sofic import SoficShift
+from sofic.states import sequential_labels
+
+
+def _follower_language(shift: SoficShift, vertex: Any, max_len: int = 8) -> frozenset[tuple[Any, ...]]:
+    from collections import deque
+
+    seen: set[tuple[Any, ...]] = set()
+    queue: deque[tuple[Any, tuple[Any, ...]]] = deque([(vertex, ())])
+    while queue:
+        state, prefix = queue.popleft()
+        if len(prefix) > max_len:
+            continue
+        if prefix:
+            seen.add(prefix)
+        for transition in shift.graph.out_transitions(state):
+            symbol = transition.data.get(ATTR_SYMBOL)
+            if symbol is None:
+                continue
+            queue.append((transition.target, prefix + (symbol,)))
+    return frozenset(seen)
+
+
+def _build_left_fischer(shift: SoficShift) -> LeftFischerCover:
+    followers: dict[Any, frozenset[tuple[Any, ...]]] = {
+        vertex: _follower_language(shift, vertex) for vertex in shift.states()
+    }
+    classes: dict[frozenset[tuple[Any, ...]], list[Any]] = defaultdict(list)
+    for vertex, language in followers.items():
+        classes[language].append(vertex)
+
+    graph = TransitionGraph()
+    class_for_vertex = {vertex: language for vertex, language in followers.items()}
+    state_ids = {language: sequential_labels(len(classes))[index] for index, language in enumerate(classes)}
+    for _language, state_id in state_ids.items():
+        graph.add_state(state_id)
+
+    for transition in shift.transitions():
+        source_lang = class_for_vertex[transition.source]
+        target_lang = class_for_vertex[transition.target]
+        symbol = transition.data.get(ATTR_SYMBOL)
+        graph.add_transition(state_ids[source_lang], state_ids[target_lang], **{ATTR_SYMBOL: symbol})
+
+    return LeftFischerCover(
+        graph=graph,
+        symbol_alphabet=shift.symbol_alphabet,
+    )
+
+
+def left_fischer_from_sofic(shift: SoficShift) -> LeftFischerCover:
+    return _build_left_fischer(shift.trim_transient())
+
+
+def right_fischer_from_sofic(shift: SoficShift) -> RightFischerCover:
+    left = left_fischer_from_sofic(shift.reverse())
+    return RightFischerCover(
+        graph=left.graph.copy(),
+        symbol_alphabet=left.symbol_alphabet,
+    )
+
+
+def left_krieger_from_sofic(shift: SoficShift) -> LeftKriegerCover:
+    raise NotImplementedError("Left Krieger cover construction is not yet implemented; use left_fischer_from_sofic")
+
+
+def right_krieger_from_sofic(shift: SoficShift) -> RightKriegerCover:
+    raise NotImplementedError("Right Krieger cover construction is not yet implemented; use right_fischer_from_sofic")

sofic/shifts/covers.py

@@ -0,0 +1,47 @@
+"""Fischer and Krieger covers of sofic shifts."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sofic.shifts.sofic import SoficShift
+
+
+class LeftFischerCover(SoficShift):
+    """Left Fischer cover presentation."""
+
+    @classmethod
+    def from_sofic(cls, shift: SoficShift, **kwargs: Any) -> LeftFischerCover:
+        from sofic.shifts.cover_construction import left_fischer_from_sofic
+
+        return left_fischer_from_sofic(shift)
+
+
+class RightFischerCover(SoficShift):
+    """Right Fischer cover presentation."""
+
+    @classmethod
+    def from_sofic(cls, shift: SoficShift, **kwargs: Any) -> RightFischerCover:
+        from sofic.shifts.cover_construction import right_fischer_from_sofic
+
+        return right_fischer_from_sofic(shift)
+
+
+class LeftKriegerCover(SoficShift):
+    """Left Krieger cover presentation."""
+
+    @classmethod
+    def from_sofic(cls, shift: SoficShift, **kwargs: Any) -> LeftKriegerCover:
+        from sofic.shifts.cover_construction import left_krieger_from_sofic
+
+        return left_krieger_from_sofic(shift)
+
+
+class RightKriegerCover(SoficShift):
+    """Right Krieger cover presentation."""
+
+    @classmethod
+    def from_sofic(cls, shift: SoficShift, **kwargs: Any) -> RightKriegerCover:
+        from sofic.shifts.cover_construction import right_krieger_from_sofic
+
+        return right_krieger_from_sofic(shift)

sofic/shifts/dyck_algorithms.py

@@ -0,0 +1,100 @@
+"""Algorithms for Dyck shift presentations."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Hashable, Iterator, Sequence
+from typing import TYPE_CHECKING, Any
+
+from sofic.graph import ATTR_KIND, ATTR_SYMBOL, KIND_CALL, KIND_INTERNAL, KIND_RETURN, Transition
+from sofic.shifts.sofic_dyck import TransitionRef, transition_ref
+
+if TYPE_CHECKING:
+    from sofic.shifts.sofic_dyck import SoficDyckShift
+
+Configuration = tuple[Hashable, tuple[TransitionRef, ...]]
+
+
+def is_admissible_word(shift: SoficDyckShift, word: Sequence[Any]) -> bool:
+    """Return whether ``word`` labels an admissible finite Dyck path."""
+    word = tuple(word)
+    if not word:
+        return True
+    if any(symbol not in shift.symbol_alphabet for symbol in word):
+        return False
+
+    current: set[Configuration] = {(state, ()) for state in shift.states()}
+    for symbol in word:
+        next_configs: set[Configuration] = set()
+        for state, stack in current:
+            for transition in shift.graph.out_transitions(state):
+                if transition.data.get(ATTR_SYMBOL) != symbol:
+                    continue
+                _advance_transition(shift, transition, stack, next_configs)
+        if not next_configs:
+            return False
+        current = next_configs
+
+    return bool(current)
+
+
+def admissible_words(shift: SoficDyckShift, length: int) -> Iterator[tuple[Any, ...]]:
+    """Yield distinct admissible words of exactly ``length`` symbols."""
+    if length <= 0:
+        yield ()
+        return
+
+    seen_words: set[tuple[Any, ...]] = set()
+    seen_configs: set[tuple[Hashable, tuple[Any, ...], tuple[TransitionRef, ...]]] = set()
+    queue: deque[tuple[Hashable, tuple[Any, ...], tuple[TransitionRef, ...]]] = deque()
+    for state in shift.states():
+        config = (state, (), ())
+        queue.append(config)
+        seen_configs.add(config)
+
+    while queue:
+        state, prefix, stack = queue.popleft()
+        if len(prefix) == length:
+            if prefix not in seen_words:
+                seen_words.add(prefix)
+                yield prefix
+            continue
+
+        for transition in shift.graph.out_transitions(state):
+            symbol = transition.data.get(ATTR_SYMBOL)
+            if symbol is None:
+                continue
+            for target, next_stack in _successors(shift, transition, stack):
+                config = (target, prefix + (symbol,), next_stack)
+                if config in seen_configs:
+                    continue
+                seen_configs.add(config)
+                queue.append(config)
+
+
+def _advance_transition(
+    shift: SoficDyckShift,
+    transition: Transition,
+    stack: tuple[TransitionRef, ...],
+    next_configs: set[Configuration],
+) -> None:
+    for target, next_stack in _successors(shift, transition, stack):
+        next_configs.add((target, next_stack))
+
+
+def _successors(
+    shift: SoficDyckShift,
+    transition: Transition,
+    stack: tuple[TransitionRef, ...],
+) -> Iterator[tuple[Hashable, tuple[TransitionRef, ...]]]:
+    kind = transition.data.get(ATTR_KIND)
+    ref = transition_ref(transition)
+    if kind == KIND_CALL:
+        yield transition.target, stack + (ref,)
+    elif kind == KIND_RETURN:
+        if not stack:
+            yield transition.target, stack
+        elif (stack[-1], ref) in shift.matched_edges:
+            yield transition.target, stack[:-1]
+    elif kind == KIND_INTERNAL:
+        yield transition.target, stack

sofic/shifts/dyck_enumeration.py

@@ -0,0 +1,275 @@
+"""Canonical strings and enumeration for small Sofic-Dyck topologies."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass
+from itertools import product
+from typing import Any
+
+from sofic.exceptions import SoficValidationError
+from sofic.graph import ATTR_KIND, ATTR_SYMBOL, KIND_CALL, KIND_INTERNAL, KIND_RETURN
+from sofic.shifts.dyck_algorithms import is_admissible_word
+from sofic.shifts.sofic_dyck import SoficDyckShift, TransitionRef, transition_ref
+
+__all__ = [
+    "DyckGraphString",
+    "count_dyck_graph_strings",
+    "dyck_graph_string_to_shift",
+    "iter_dyck_graph_strings",
+    "iter_sofic_dyck_topologies",
+    "shift_to_dyck_graph_string",
+]
+
+_KIND_CALL = 0
+_KIND_RETURN = 1
+_KIND_INTERNAL = 2
+
+
+class DyckEnumerationError(SoficValidationError):
+    """Raised when Dyck-graph enumeration fails."""
+
+
+@dataclass(frozen=True, slots=True)
+class DyckGraphString:
+    """Canonical encoding of a small matched-edge Dyck graph.
+
+    ``transitions`` lists ``(source, kind, symbol_index, target)`` in
+    lexicographic order. ``matched_pairs`` lists ``(call_transition_index,
+    return_transition_index)`` into ``transitions``.
+    """
+
+    n: int
+    call_symbols: tuple[Any, ...]
+    return_symbols: tuple[Any, ...]
+    internal_symbols: tuple[Any, ...]
+    transitions: tuple[tuple[int, int, int, int], ...]
+    matched_pairs: tuple[tuple[int, int], ...]
+
+
+def shift_to_dyck_graph_string(shift: SoficDyckShift) -> DyckGraphString:
+    """Serialize a ``SoficDyckShift`` into canonical edge-index form."""
+    states = sorted(shift.states(), key=repr)
+    state_index = {state: index for index, state in enumerate(states)}
+    call_symbols = tuple(sorted(shift.call_alphabet, key=repr))
+    return_symbols = tuple(sorted(shift.return_alphabet, key=repr))
+    internal_symbols = tuple(sorted(shift.internal_alphabet, key=repr))
+    call_index = {symbol: index for index, symbol in enumerate(call_symbols)}
+    return_index = {symbol: index for index, symbol in enumerate(return_symbols)}
+    internal_index = {symbol: index for index, symbol in enumerate(internal_symbols)}
+
+    encoded: list[tuple[int, int, int, int]] = []
+    call_positions: dict[TransitionRef, int] = {}
+    return_positions: dict[TransitionRef, int] = {}
+
+    for transition in sorted(shift.transitions(), key=lambda item: (repr(item.source), repr(item.target), item.key)):
+        kind = transition.data.get(ATTR_KIND)
+        symbol = transition.data.get(ATTR_SYMBOL)
+        if kind == KIND_CALL:
+            kind_code = _KIND_CALL
+            symbol_index = call_index[symbol]
+        elif kind == KIND_RETURN:
+            kind_code = _KIND_RETURN
+            symbol_index = return_index[symbol]
+        elif kind == KIND_INTERNAL:
+            kind_code = _KIND_INTERNAL
+            symbol_index = internal_index[symbol]
+        else:
+            raise DyckEnumerationError(f"unknown edge kind {kind!r}")
+        encoded.append((state_index[transition.source], kind_code, symbol_index, state_index[transition.target]))
+        ref = transition_ref(transition)
+        position = len(encoded) - 1
+        if kind == KIND_CALL:
+            call_positions[ref] = position
+        elif kind == KIND_RETURN:
+            return_positions[ref] = position
+
+    matched = tuple(
+        sorted((call_positions[call_ref], return_positions[return_ref]) for call_ref, return_ref in shift.matched_edges)
+    )
+
+    return DyckGraphString(
+        n=len(states),
+        call_symbols=call_symbols,
+        return_symbols=return_symbols,
+        internal_symbols=internal_symbols,
+        transitions=tuple(encoded),
+        matched_pairs=tuple(sorted(matched)),
+    )
+
+
+def dyck_graph_string_to_shift(spec: DyckGraphString) -> SoficDyckShift:
+    """Build a ``SoficDyckShift`` from a ``DyckGraphString``."""
+    shift = SoficDyckShift(
+        call_alphabet=frozenset(spec.call_symbols),
+        return_alphabet=frozenset(spec.return_symbols),
+        internal_alphabet=frozenset(spec.internal_symbols),
+    )
+    states = [f"q{index}" for index in range(spec.n)]
+    for state in states:
+        shift.graph.add_state(state)
+
+    edge_refs: list[TransitionRef] = []
+    for source, kind_code, symbol_index, target in spec.transitions:
+        source_state = states[source]
+        target_state = states[target]
+        if kind_code == _KIND_CALL:
+            symbol = spec.call_symbols[symbol_index]
+            edge_refs.append(shift.add_call_transition(source_state, target_state, symbol))
+        elif kind_code == _KIND_RETURN:
+            symbol = spec.return_symbols[symbol_index]
+            edge_refs.append(shift.add_return_transition(source_state, target_state, symbol))
+        else:
+            symbol = spec.internal_symbols[symbol_index]
+            edge_refs.append(shift.add_internal_transition(source_state, target_state, symbol))
+
+    for call_index, return_index in spec.matched_pairs:
+        shift.add_matched_pair(edge_refs[call_index], edge_refs[return_index])
+
+    shift.validate()
+    return shift
+
+
+def _one_state_transition_choices(
+    symbols_per_kind: Sequence[int],
+    *,
+    include_empty: bool,
+) -> Iterator[tuple[tuple[int, int, int, int], ...]]:
+    """Enumerate transition subsets on a single state looping to itself."""
+    slots: list[tuple[int, int, int, int]] = []
+    for kind_code, symbol_count in enumerate(symbols_per_kind):
+        for symbol_index in range(symbol_count):
+            slots.append((0, kind_code, symbol_index, 0))
+    if not slots:
+        if include_empty:
+            yield ()
+        return
+    for mask in range(1 if not include_empty else 0, 1 << len(slots)):
+        selected = tuple(slots[index] for index in range(len(slots)) if mask & (1 << index))
+        if selected or include_empty:
+            yield selected
+
+
+def iter_dyck_graph_strings(
+    *,
+    n: int = 1,
+    call_symbols: Sequence[Any] = ("a",),
+    return_symbols: Sequence[Any] = ("A",),
+    internal_symbols: Sequence[Any] = (),
+    include_empty: bool = False,
+) -> Iterator[DyckGraphString]:
+    """Yield canonical Dyck-graph strings for small topologies."""
+    if n != 1:
+        raise DyckEnumerationError("iter_dyck_graph_strings currently supports n=1 only")
+    calls = tuple(call_symbols)
+    returns = tuple(return_symbols)
+    internals = tuple(internal_symbols)
+    if len(calls) != len(returns):
+        raise DyckEnumerationError("call and return symbol counts must match")
+
+    for transitions in _one_state_transition_choices(
+        (len(calls), len(returns), len(internals)),
+        include_empty=include_empty,
+    ):
+        call_edge_indices = [index for index, item in enumerate(transitions) if item[1] == _KIND_CALL]
+        return_edge_indices = [index for index, item in enumerate(transitions) if item[1] == _KIND_RETURN]
+        call_by_symbol: dict[int, list[int]] = defaultdict(list)
+        return_by_symbol: dict[int, list[int]] = defaultdict(list)
+        for edge_index in call_edge_indices:
+            call_by_symbol[transitions[edge_index][2]].append(edge_index)
+        for edge_index in return_edge_indices:
+            return_by_symbol[transitions[edge_index][2]].append(edge_index)
+
+        matched_options: list[list[tuple[int, int]]] = []
+        for symbol_index in call_by_symbol:
+            if symbol_index not in return_by_symbol:
+                matched_options = []
+                break
+            pairs = [
+                (call_index, return_index)
+                for call_index, return_index in zip(
+                    call_by_symbol[symbol_index],
+                    return_by_symbol[symbol_index],
+                    strict=False,
+                )
+            ]
+            if not pairs:
+                matched_options = []
+                break
+            matched_options.append(pairs)
+        if call_by_symbol and not matched_options:
+            continue
+
+        if not matched_options:
+            yield DyckGraphString(
+                n=1,
+                call_symbols=calls,
+                return_symbols=returns,
+                internal_symbols=internals,
+                transitions=transitions,
+                matched_pairs=(),
+            )
+            continue
+
+        for combo in product(*matched_options):
+            pairs: list[tuple[int, int]] = []
+            for item in combo:
+                if isinstance(item, tuple) and len(item) == 2:
+                    pairs.append(item)
+            matched = tuple(sorted(set(pairs)))
+            yield DyckGraphString(
+                n=1,
+                call_symbols=calls,
+                return_symbols=returns,
+                internal_symbols=internals,
+                transitions=transitions,
+                matched_pairs=matched,
+            )
+
+
+def iter_sofic_dyck_topologies(
+    *,
+    n: int = 1,
+    call_symbols: Sequence[Any] = ("a",),
+    return_symbols: Sequence[Any] = ("A",),
+    internal_symbols: Sequence[Any] = (),
+) -> Iterator[SoficDyckShift]:
+    """Yield valid ``SoficDyckShift`` topologies from canonical Dyck-graph strings."""
+    seen: set[tuple[Any, ...]] = set()
+    for spec in iter_dyck_graph_strings(
+        n=n,
+        call_symbols=call_symbols,
+        return_symbols=return_symbols,
+        internal_symbols=internal_symbols,
+    ):
+        try:
+            shift = dyck_graph_string_to_shift(spec)
+        except (SoficValidationError, ValueError):
+            continue
+        if not is_admissible_word(shift, ()):
+            continue
+        key = (spec.transitions, spec.matched_pairs)
+        if key in seen:
+            continue
+        seen.add(key)
+        yield shift
+
+
+def count_dyck_graph_strings(
+    *,
+    n: int = 1,
+    call_symbols: Sequence[Any] = ("a",),
+    return_symbols: Sequence[Any] = ("A",),
+    internal_symbols: Sequence[Any] = (),
+) -> int:
+    """Count canonical Dyck-graph strings for the given signature."""
+    return sum(
+        1
+        for _spec in iter_dyck_graph_strings(
+            n=n,
+            call_symbols=call_symbols,
+            return_symbols=return_symbols,
+            internal_symbols=internal_symbols,
+        )
+    )

sofic/shifts/markov_dyck.py

@@ -0,0 +1,172 @@
+"""Markov-Dyck shift constructions."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Sequence
+from typing import Any, Literal
+
+import numpy as np
+
+from sofic.graph import ATTR_KIND, ATTR_SYMBOL, KIND_CALL, KIND_RETURN, TransitionGraph
+from sofic.shifts.sofic_dyck import MatchedEdge, SoficDyckShift, TransitionRef, transition_ref
+
+GraphKind = Literal["edge", "vertex"]
+
+
+class MarkovDyckShift(SoficDyckShift):
+    """Markov-Dyck shift associated with a finite directed graph or matrix."""
+
+    @classmethod
+    def from_adjacency(
+        cls,
+        matrix: np.ndarray,
+        labels: Sequence[Hashable] | None = None,
+        **kwargs: Any,
+    ) -> MarkovDyckShift:
+        """Build the Markov-Dyck shift from a square adjacency matrix."""
+        arr = _as_square_binary_matrix(matrix)
+        resolved_labels = _resolve_labels(arr.shape[0], labels)
+        return _from_binary_matrix(cls, arr, resolved_labels, **kwargs)
+
+    @classmethod
+    def from_graph(
+        cls,
+        graph: Any,
+        *,
+        kind: GraphKind = "edge",
+        **kwargs: Any,
+    ) -> MarkovDyckShift:
+        """Build an edge- or vertex-type Markov-Dyck shift from ``graph``."""
+        if kind == "edge":
+            matrix, labels = _edge_adjacency(graph)
+        elif kind == "vertex":
+            matrix, labels = _vertex_adjacency(graph)
+        else:
+            raise ValueError("kind must be 'edge' or 'vertex'")
+        return _from_binary_matrix(cls, matrix, labels, **kwargs)
+
+
+def _from_binary_matrix(
+    cls: type[MarkovDyckShift],
+    matrix: np.ndarray,
+    labels: tuple[Hashable, ...],
+    **kwargs: Any,
+) -> MarkovDyckShift:
+    graph = TransitionGraph()
+    call_symbols = tuple((KIND_CALL, label) for label in labels)
+    return_symbols = tuple((KIND_RETURN, label) for label in labels)
+
+    for symbol in (*call_symbols, *return_symbols):
+        graph.add_state(symbol)
+
+    row_intersections = _row_intersections(matrix)
+    n = matrix.shape[0]
+    for previous_index in range(n):
+        for next_index in range(n):
+            previous_call = call_symbols[previous_index]
+            previous_return = return_symbols[previous_index]
+            next_call = call_symbols[next_index]
+            next_return = return_symbols[next_index]
+
+            if matrix[next_index, previous_index]:
+                graph.add_transition(previous_call, next_call, **{ATTR_KIND: KIND_CALL, ATTR_SYMBOL: next_call})
+            if previous_index == next_index:
+                graph.add_transition(previous_call, next_return, **{ATTR_KIND: KIND_RETURN, ATTR_SYMBOL: next_return})
+            if row_intersections[next_index, previous_index]:
+                graph.add_transition(previous_return, next_call, **{ATTR_KIND: KIND_CALL, ATTR_SYMBOL: next_call})
+            if matrix[previous_index, next_index]:
+                graph.add_transition(previous_return, next_return, **{ATTR_KIND: KIND_RETURN, ATTR_SYMBOL: next_return})
+
+    matched_edges = _matched_edges_by_label(graph, labels)
+    return cls(
+        graph=graph,
+        call_alphabet=frozenset(call_symbols),
+        return_alphabet=frozenset(return_symbols),
+        matched_edges=matched_edges,
+        **kwargs,
+    )
+
+
+def _as_square_binary_matrix(matrix: np.ndarray) -> np.ndarray:
+    arr = np.asarray(matrix)
+    if arr.ndim != 2 or arr.shape[0] != arr.shape[1]:
+        raise ValueError("adjacency matrix must be square")
+    return (arr != 0).astype(bool)
+
+
+def _resolve_labels(n: int, labels: Sequence[Hashable] | None) -> tuple[Hashable, ...]:
+    if labels is None:
+        return tuple(range(n))
+    resolved = tuple(labels)
+    if len(resolved) != n:
+        raise ValueError("labels length must match adjacency matrix size")
+    if len(frozenset(resolved)) != n:
+        raise ValueError("labels must be distinct")
+    return resolved
+
+
+def _row_intersections(matrix: np.ndarray) -> np.ndarray:
+    n = matrix.shape[0]
+    intersections = np.zeros((n, n), dtype=bool)
+    for i in range(n):
+        for j in range(n):
+            intersections[i, j] = bool(np.any(matrix[i] & matrix[j]))
+    return intersections
+
+
+def _matched_edges_by_label(graph: TransitionGraph, labels: tuple[Hashable, ...]) -> frozenset[MatchedEdge]:
+    call_edges: dict[Hashable, set[TransitionRef]] = {label: set() for label in labels}
+    return_edges: dict[Hashable, set[TransitionRef]] = {label: set() for label in labels}
+    for transition in graph.transitions():
+        symbol = transition.data.get(ATTR_SYMBOL)
+        if not isinstance(symbol, tuple) or len(symbol) != 2:
+            continue
+        role, label = symbol
+        if role == KIND_CALL:
+            call_edges[label].add(transition_ref(transition))
+        elif role == KIND_RETURN:
+            return_edges[label].add(transition_ref(transition))
+
+    matched_edges: set[MatchedEdge] = set()
+    for label in labels:
+        for call_ref in call_edges[label]:
+            for return_ref in return_edges[label]:
+                matched_edges.add((call_ref, return_ref))
+    return frozenset(matched_edges)
+
+
+def _vertex_adjacency(graph: Any) -> tuple[np.ndarray, tuple[Hashable, ...]]:
+    if isinstance(graph, TransitionGraph):
+        labels = tuple(graph.states())
+        index = {label: i for i, label in enumerate(labels)}
+        matrix = np.zeros((len(labels), len(labels)), dtype=bool)
+        for transition in graph.transitions():
+            matrix[index[transition.target], index[transition.source]] = True
+        return matrix, labels
+
+    labels = tuple(graph.nodes())
+    index = {label: i for i, label in enumerate(labels)}
+    matrix = np.zeros((len(labels), len(labels)), dtype=bool)
+    for source, target in graph.edges():
+        matrix[index[target], index[source]] = True
+    return matrix, labels
+
+
+def _edge_adjacency(graph: Any) -> tuple[np.ndarray, tuple[Hashable, ...]]:
+    endpoints: tuple[tuple[Hashable, Hashable], ...]
+    if isinstance(graph, TransitionGraph):
+        transitions = tuple(graph.transitions())
+        labels = tuple(transition_ref(transition) for transition in transitions)
+        endpoints = tuple((transition.source, transition.target) for transition in transitions)
+    elif graph.is_multigraph():
+        labels = tuple((source, target, key) for source, target, key in graph.edges(keys=True))
+        endpoints = tuple((source, target) for source, target, _key in labels)
+    else:
+        labels = tuple((source, target) for source, target in graph.edges())
+        endpoints = labels
+
+    matrix = np.zeros((len(labels), len(labels)), dtype=bool)
+    for previous, (_source_previous, target_previous) in enumerate(endpoints):
+        for next_, (source_next, _target_next) in enumerate(endpoints):
+            matrix[next_, previous] = target_previous == source_next
+    return matrix, labels