Skip to content

ogs.dsl.types

Bases: Interface

The (X, Y, R, S) 4-tuple boundary of an open game.

Backwards-compatible constructor that maps game theory conventions to GDS directional pairs:

  • x → forward_in (observation inputs, covariant)
  • y → forward_out (decision outputs, covariant)
  • r → backward_in (utility inputs, contravariant)
  • s → backward_out (coutility outputs, contravariant)
Source code in packages/gds-games/ogs/dsl/types.py 
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
class Signature(Interface, frozen=True):
    """The ``(X, Y, R, S)`` 4-tuple boundary of an open game.

    Backwards-compatible constructor that maps game theory conventions
    to GDS directional pairs:

    - **x** → forward_in (observation inputs, covariant)
    - **y** → forward_out (decision outputs, covariant)
    - **r** → backward_in (utility inputs, contravariant)
    - **s** → backward_out (coutility outputs, contravariant)
    """

    if TYPE_CHECKING:

        def __init__(
            self,
            *,
            x: tuple[Port, ...] = (),
            y: tuple[Port, ...] = (),
            r: tuple[Port, ...] = (),
            s: tuple[Port, ...] = (),
            forward_in: tuple[Port, ...] = (),
            forward_out: tuple[Port, ...] = (),
            backward_in: tuple[Port, ...] = (),
            backward_out: tuple[Port, ...] = (),
        ) -> None: ...

    @model_validator(mode="before")
    @classmethod
    def _map_xyrs(cls, data: dict) -> dict:
        if isinstance(data, dict):
            mapping = {
                "x": "forward_in",
                "y": "forward_out",
                "r": "backward_in",
                "s": "backward_out",
            }
            for old, new in mapping.items():
                if old in data:
                    data[new] = data.pop(old)
        return data

    @property
    def x(self) -> tuple[Port, ...]:
        return self.forward_in

    @property
    def y(self) -> tuple[Port, ...]:
        return self.forward_out

    @property
    def r(self) -> tuple[Port, ...]:
        return self.backward_in

    @property
    def s(self) -> tuple[Port, ...]:
        return self.backward_out

Bases: str, Enum

Classification of an open game component by its port structure.

Source code in packages/gds-games/ogs/dsl/types.py 
42
43
44
45
46
47
48
49
50
class GameType(str, Enum):
    """Classification of an open game component by its port structure."""

    DECISION = "decision"
    FUNCTION_COVARIANT = "function_covariant"
    FUNCTION_CONTRAVARIANT = "function_contravariant"
    DELETION = "deletion"
    DUPLICATION = "duplication"
    COUNIT = "counit"

Bases: str, Enum

Semantic classification of an information flow between components.

Source code in packages/gds-games/ogs/dsl/types.py 
53
54
55
56
57
58
59
class FlowType(str, Enum):
    """Semantic classification of an information flow between components."""

    OBSERVATION = "observation"
    CHOICE_OBSERVATION = "choice_observation"
    UTILITY_COUTILITY = "utility_coutility"
    PRIMITIVE = "primitive"

Bases: str, Enum

How games are composed within a pattern.

Extends GDS composition types with game-theory naming.

Source code in packages/gds-games/ogs/dsl/types.py 
30
31
32
33
34
35
36
37
38
39
class CompositionType(str, Enum):
    """How games are composed within a pattern.

    Extends GDS composition types with game-theory naming.
    """

    SEQUENTIAL = "sequential"
    PARALLEL = "parallel"
    FEEDBACK = "feedback"
    CORECURSIVE = "corecursive"

Bases: str, Enum

Classification of external inputs that cross the pattern boundary.

Source code in packages/gds-games/ogs/dsl/types.py 
62
63
64
65
66
67
68
class InputType(str, Enum):
    """Classification of external inputs that cross the pattern boundary."""

    SENSOR = "sensor"
    RESOURCE = "resource"
    INITIALIZATION = "initialization"
    EXTERNAL_WORLD = "external_world"