lp2graph 0.3.0__py3-none-any.whl

lp2graph/export/dgl.py

@@ -0,0 +1,51 @@
+"""DGL export (lazy import; stubbed for v0.1)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lp2graph.core.graph import Graph
+
+if TYPE_CHECKING:
+    pass
+
+
+def to_dgl(g: Graph) -> Any:
+    """Convert to a DGL heterograph.
+
+    Raises:
+        ImportError: if DGL is not installed.
+    """
+    try:
+        import dgl
+        import torch
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "to_dgl requires dgl and torch; install with 'pip install lp2graph[dgl]'"
+        ) from exc
+
+    nodes_by_class: dict[str, list[int]] = {}
+    id_to_idx: dict[str, tuple[str, int]] = {}
+    for i, n in enumerate(g.nodes):
+        bucket = nodes_by_class.setdefault(n.cls, [])
+        id_to_idx[n.id] = (n.cls, len(bucket))
+        bucket.append(i)
+
+    edge_buckets: dict[tuple[str, str, str], tuple[list[int], list[int]]] = {}
+    for edge in g.edges:
+        sc, sidx = id_to_idx[edge.src]
+        dc, didx = id_to_idx[edge.dst]
+        key = (sc, edge.type, dc)
+        if key not in edge_buckets:
+            edge_buckets[key] = ([], [])
+        edge_buckets[key][0].append(sidx)
+        edge_buckets[key][1].append(didx)
+
+    data_dict: dict[tuple[str, str, str], tuple[Any, Any]] = {
+        k: (torch.tensor(v[0]), torch.tensor(v[1])) for k, v in edge_buckets.items()
+    }
+    num_nodes_dict = {k: len(v) for k, v in nodes_by_class.items()}
+    return dgl.heterograph(data_dict, num_nodes_dict=num_nodes_dict)
+
+
+__all__ = ["to_dgl"]

lp2graph/export/latex.py

@@ -0,0 +1,126 @@
+"""LaTeX export of a formulation's algebraic form.
+
+Produces a LaTeX ``align*`` block for the objective and constraints.
+Useful for embedding in papers and for visual inspection of the parsed
+model. Does *not* render the graph — that is what
+:mod:`lp2graph.render` is for.
+"""
+
+from __future__ import annotations
+
+from lp2graph.core.model import (
+    Formulation,
+    Quantifier,
+    Term,
+)
+
+_CMP = {"le": r"\le", "ge": r"\ge", "eq": "="}
+
+
+def to_latex(f: Formulation) -> str:
+    """Render the formulation's algebraic form as LaTeX."""
+    lines: list[str] = []
+    lines.append(r"\begin{align*}")
+    if f.objective is not None:
+        sense = r"\min" if f.objective.sense == "min" else r"\max"
+        body = _render_term_sum(f.objective.terms)
+        lines.append(rf"  {sense}\quad & {body} \\")
+    for c in f.constraints:
+        lhs = _render_term_sum(c.lhs)
+        rhs = _render_term_sum(c.rhs) if c.rhs else "0"
+        cmp = _CMP[c.comparator]
+        quant = _render_quantifiers(c.quantifiers)
+        suffix = rf" & \quad {quant}" if quant else ""
+        lines.append(rf"  & {lhs} {cmp} {rhs}{suffix} \\")
+    # Variable domains as a final block.
+    for v in f.variables:
+        shape = _render_shape(v.shape)
+        if v.domain == "binary":
+            lines.append(rf"  & {v.name}{shape} \in \{{0,1\}} \\")
+        elif v.domain == "integer":
+            lines.append(rf"  & {v.name}{shape} \in \mathbb{{Z}} \\")
+        elif v.domain == "non_negative":
+            lines.append(rf"  & {v.name}{shape} \ge 0 \\")
+        else:
+            lines.append(rf"  & {v.name}{shape} \in \mathbb{{R}} \\")
+    lines.append(r"\end{align*}")
+    return "\n".join(lines)
+
+
+def _render_term_sum(terms: tuple[Term, ...]) -> str:
+    if not terms:
+        return "0"
+    parts: list[str] = []
+    for i, t in enumerate(terms):
+        s = _render_term(t)
+        if i == 0:
+            parts.append(("-" + s) if t.sign == -1 else s)
+        else:
+            sep = "-" if t.sign == -1 else "+"
+            parts.append(f"{sep} {s}")
+    return " ".join(parts)
+
+
+def _render_term(t: Term) -> str:
+    if t.ref_kind == "literal":
+        return str(t.coefficient if t.coefficient is not None else 1)
+    coef = ""
+    if isinstance(t.coefficient, str) or (
+        isinstance(t.coefficient, (int, float)) and t.coefficient != 1
+    ):
+        coef = f"{t.coefficient} \\cdot "
+    body = t.ref
+    if t.bindings:
+        idx = ",".join(b.expr for b in t.bindings)
+        body = f"{t.ref}_{{{idx}}}"
+    if t.operator == "sum":
+        sub = ",".join(t.operator_over)
+        return rf"\sum_{{{sub}}} {coef}{body}"
+    if t.operator == "max":
+        return rf"\max\;{coef}{body}"
+    if t.operator == "min":
+        return rf"\min\;{coef}{body}"
+    if t.operator == "abs":
+        return rf"\left|{coef}{body}\right|"
+    return f"{coef}{body}"
+
+
+def _render_quantifiers(quantifiers: tuple[Quantifier, ...]) -> str:
+    if not quantifiers:
+        return ""
+    parts = [rf"\forall {q.index} \in {q.over}" for q in quantifiers]
+    restr = []
+    for q in quantifiers:
+        if q.restriction == "ne_other":
+            restr.append(rf"{q.index} \ne {q.restriction_other}")
+        elif q.restriction == "lt_other":
+            restr.append(rf"{q.index} < {q.restriction_other}")
+        elif q.restriction == "le_other":
+            restr.append(rf"{q.index} \le {q.restriction_other}")
+        elif q.restriction == "gt_other":
+            restr.append(rf"{q.index} > {q.restriction_other}")
+        elif q.restriction == "ge_other":
+            restr.append(rf"{q.index} \ge {q.restriction_other}")
+        elif q.restriction == "ordered_pair":
+            restr.append(rf"{q.index} < {q.restriction_other}")
+        if q.where is not None:
+            restr.append(rf"{q.where.parameter}_{{{q.index}}} = {_render_value(q.where.equals)}")
+    out = ", ".join(parts)
+    if restr:
+        out += ", " + ", ".join(restr)
+    return out
+
+
+def _render_value(v: bool | int | float | str) -> str:
+    if isinstance(v, bool):
+        return r"\mathrm{true}" if v else r"\mathrm{false}"
+    return str(v)
+
+
+def _render_shape(shape: tuple[str, ...]) -> str:
+    if not shape:
+        return ""
+    return f"_{{{','.join(shape)}}}"
+
+
+__all__ = ["to_latex"]

lp2graph/export/networkx_adapter.py

@@ -0,0 +1,50 @@
+"""NetworkX export.
+
+Converts an internal :class:`~lp2graph.core.graph.Graph` to a
+``networkx.MultiDiGraph``. Node attributes preserve ``cls``, ``subtype``,
+``label``, ``shape``, and ``data``. Edge attributes preserve ``type``,
+``role``, ``label``, ``data``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lp2graph.core.graph import Graph
+
+if TYPE_CHECKING:
+    import networkx as nx
+
+
+def to_networkx(g: Graph) -> nx.MultiDiGraph:
+    """Convert to a NetworkX MultiDiGraph."""
+    try:
+        import networkx as nx
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "to_networkx requires networkx; install with 'pip install lp2graph[networkx]'"
+        ) from exc
+
+    nxg: Any = nx.MultiDiGraph()
+    for n in g.nodes:
+        nxg.add_node(
+            n.id,
+            cls=n.cls,
+            subtype=n.subtype,
+            label=n.label,
+            shape=list(n.shape),
+            data=dict(n.data),
+        )
+    for edge in g.edges:
+        nxg.add_edge(
+            edge.src,
+            edge.dst,
+            type=edge.type,
+            role=edge.role,
+            label=edge.label,
+            data=dict(edge.data),
+        )
+    return nxg
+
+
+__all__ = ["to_networkx"]

lp2graph/export/pyg.py

@@ -0,0 +1,79 @@
+"""PyG export.
+
+Converts an internal :class:`~lp2graph.core.graph.Graph` to a
+``torch_geometric.data.HeteroData`` instance. Node classes become node
+types; edge types become PyG edge types ``(src_cls, edge_type, dst_cls)``.
+
+Node features are minimal in v0.1: a single one-hot of the node's
+subtype. Callers who want richer features should consume the typed
+graph and build their own.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lp2graph.core.graph import Graph
+
+if TYPE_CHECKING:
+    from torch_geometric.data import HeteroData
+
+
+def to_pyg(g: Graph) -> HeteroData:
+    """Convert to a PyG HeteroData object.
+
+    Raises:
+        ImportError: if torch and torch_geometric are not installed.
+    """
+    try:
+        import torch
+        from torch_geometric.data import HeteroData
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "to_pyg requires torch and torch_geometric; install with 'pip install lp2graph[pyg]'"
+        ) from exc
+
+    data: Any = HeteroData()
+
+    # Group nodes by class; assign per-class indices.
+    nodes_by_class: dict[str, list[int]] = {}
+    id_to_idx: dict[str, tuple[str, int]] = {}
+    subtype_vocab: dict[str, list[str]] = {}
+
+    for i, n in enumerate(g.nodes):
+        bucket = nodes_by_class.setdefault(n.cls, [])
+        idx = len(bucket)
+        bucket.append(i)
+        id_to_idx[n.id] = (n.cls, idx)
+        subtype_vocab.setdefault(n.cls, [])
+        if n.subtype and n.subtype not in subtype_vocab[n.cls]:
+            subtype_vocab[n.cls].append(n.subtype)
+
+    for cls, indices in nodes_by_class.items():
+        n_subtypes = max(1, len(subtype_vocab[cls]))
+        x = torch.zeros((len(indices), n_subtypes), dtype=torch.float32)
+        for local_i, global_i in enumerate(indices):
+            n = g.nodes[global_i]
+            if n.subtype:
+                col = subtype_vocab[cls].index(n.subtype)
+                x[local_i, col] = 1.0
+        data[cls].x = x
+
+    # Edges: bucket by (src_cls, edge_type, dst_cls).
+    edge_buckets: dict[tuple[str, str, str], tuple[list[int], list[int]]] = {}
+    for edge in g.edges:
+        sc, sidx = id_to_idx[edge.src]
+        dc, didx = id_to_idx[edge.dst]
+        key = (sc, edge.type, dc)
+        if key not in edge_buckets:
+            edge_buckets[key] = ([], [])
+        edge_buckets[key][0].append(sidx)
+        edge_buckets[key][1].append(didx)
+    for (sc, etype, dc), (src, dst) in edge_buckets.items():
+        edge_index = torch.tensor([src, dst], dtype=torch.long)
+        data[(sc, etype, dc)].edge_index = edge_index
+
+    return data
+
+
+__all__ = ["to_pyg"]

lp2graph/export/pyomo_stub.py

@@ -0,0 +1,81 @@
+"""Pyomo export — generates a model skeleton (stub for v0.1).
+
+Emits a Python module string that, when executed, defines a Pyomo
+``ConcreteModel`` with sets, parameters, variables, the objective, and
+constraint declarations. The constraint *bodies* are emitted as
+docstring placeholders for v0.1; full body translation lands in v1.0.
+
+This is a deliberate v0.1 scope choice — see issue
+``open-question/solver-language-export-scope`` and the v1 acceptance
+criteria.
+"""
+
+from __future__ import annotations
+
+from lp2graph.core.model import Formulation
+
+
+def to_pyomo_stub(f: Formulation) -> str:
+    """Generate a Pyomo skeleton string from a formulation."""
+    lines: list[str] = []
+    lines.append('"""Auto-generated Pyomo skeleton from lp2graph.')
+    lines.append("")
+    lines.append(f"Formulation: {f.id}  ({f.name})")
+    lines.append(f"Family:      {f.family}")
+    lines.append('"""')
+    lines.append("from pyomo.environ import (")
+    lines.append("    ConcreteModel, Set, Param, Var, Constraint, Objective,")
+    lines.append("    NonNegativeReals, Reals, Integers, Binary, minimize, maximize,")
+    lines.append(")")
+    lines.append("")
+    lines.append("def build_model() -> ConcreteModel:")
+    lines.append("    m = ConcreteModel()")
+    for idx in f.indices:
+        lines.append(f"    m.{idx.name} = Set()  # ordered={idx.ordered}, cyclic={idx.cyclic}")
+    for p in f.parameters:
+        if p.shape:
+            sets = ", ".join(f"m.{s}" for s in p.shape)
+            lines.append(f"    m.{p.name} = Param({sets}, mutable=True)")
+        else:
+            lines.append(f"    m.{p.name} = Param(mutable=True)")
+    for v in f.variables:
+        domain = {
+            "continuous": "Reals",
+            "non_negative": "NonNegativeReals",
+            "integer": "Integers",
+            "binary": "Binary",
+        }[v.domain]
+        bounds = ""
+        if v.lower is not None or v.upper is not None:
+            bounds = f", bounds=({v.lower!r}, {v.upper!r})"
+        if v.shape:
+            sets = ", ".join(f"m.{s}" for s in v.shape)
+            lines.append(f"    m.{v.name} = Var({sets}, domain={domain}{bounds})")
+        else:
+            lines.append(f"    m.{v.name} = Var(domain={domain}{bounds})")
+    if f.objective is not None:
+        sense = "minimize" if f.objective.sense == "min" else "maximize"
+        lines.append("")
+        lines.append("    def _obj_rule(m):")
+        lines.append(f'        """{f.objective.description or "Objective"}."""')
+        lines.append("        raise NotImplementedError('lp2graph v0.1 emits stubs only')")
+        lines.append(f"    m.obj = Objective(rule=_obj_rule, sense={sense})")
+    for c in f.constraints:
+        lines.append("")
+        sets_args = ""
+        if c.quantifiers:
+            sets_args = ", " + ", ".join(f"m.{q.over}" for q in c.quantifiers)
+            arg_names = ", ".join(q.index for q in c.quantifiers)
+            lines.append(f"    def _{c.name}_rule(m, {arg_names}):")
+        else:
+            lines.append(f"    def _{c.name}_rule(m):")
+        lines.append(f'        """{c.description or c.name}."""')
+        lines.append("        raise NotImplementedError('lp2graph v0.1 emits stubs only')")
+        lines.append(f"    m.{c.name} = Constraint(rule=_{c.name}_rule{sets_args})")
+    lines.append("")
+    lines.append("    return m")
+    lines.append("")
+    return "\n".join(lines)
+
+
+__all__ = ["to_pyomo_stub"]

lp2graph/metrics/__init__.py

@@ -0,0 +1,58 @@
+"""Structural metrics over formulations and derived graphs.
+
+Every metric is a pure function. Two categories:
+
+- **Formulation metrics** consume the canonical model directly.
+  Cheaper, exact, no grounding needed.
+- **Graph metrics** consume an internal :class:`~lp2graph.core.graph.Graph`
+  (typically the schema or hybrid view). Used when the metric is
+  inherently topological (e.g. graph diameter).
+
+All metrics return a :class:`MetricResult` — a name, a value, and a
+short human-readable explanation. Determinism is required: snapshot
+tests verify that identical inputs produce identical outputs.
+"""
+
+from lp2graph.metrics.classification import (
+    CONSTRAINT_TYPE_KEYWORDS,
+    classify_constraints,
+)
+from lp2graph.metrics.flags import (
+    has_aggregation_operator,
+    has_big_m,
+    has_integer_vars,
+    has_modulo_offset,
+    has_soft_slack,
+    presence_flags,
+)
+from lp2graph.metrics.result import MetricResult
+from lp2graph.metrics.structural import (
+    constraint_variable_ratio,
+    edge_density,
+    graph_diameter,
+    minimal_size,
+    model_coherence,
+    model_completeness,
+    node_counts_by_class,
+    structural_summary,
+)
+
+__all__ = [
+    "CONSTRAINT_TYPE_KEYWORDS",
+    "MetricResult",
+    "classify_constraints",
+    "constraint_variable_ratio",
+    "edge_density",
+    "graph_diameter",
+    "has_aggregation_operator",
+    "has_big_m",
+    "has_integer_vars",
+    "has_modulo_offset",
+    "has_soft_slack",
+    "minimal_size",
+    "model_coherence",
+    "model_completeness",
+    "node_counts_by_class",
+    "presence_flags",
+    "structural_summary",
+]

lp2graph/metrics/classification.py

@@ -0,0 +1,113 @@
+"""Constraint-type classification by keyword matching.
+
+Adapted from joernmht/raiLPminerExperimentation
+(railpminer/analysis/constraints.py), MIT License. The keyword tables
+are preserved; the integration consumes the canonical model rather than
+the source repo's flat node lists.
+
+Classification is heuristic and intentionally so. It complements the
+declarative ``constraint.kind`` field (which the formulation author
+sets explicitly): ``classify_constraints`` infers the same kinds from
+free-form text in name and description, useful for catalog audits and
+for cross-checking author-supplied kinds.
+"""
+
+from __future__ import annotations
+
+import re
+
+from lp2graph.core.model import Formulation
+from lp2graph.metrics.result import MetricResult
+
+CONSTRAINT_TYPE_KEYWORDS: dict[str, list[str]] = {
+    "ordering": [
+        r"\bprecedence\b",
+        r"\border\b",
+        r"\bordering\b",
+        r"\bovertaking\b",
+        r"\bovertake\b",
+        r"\bre-?ordering\b",
+    ],
+    "routing": [
+        r"\broute\s+selection\b",
+        r"\brouting\b",
+        r"\brerouting\b",
+        r"\bre-?routing\b",
+    ],
+    "timing": [
+        r"\bdepart(ure)?\b",
+        r"\bdwell\b",
+        r"\bdelay\b",
+        r"\bscheduled\b",
+        r"\brunning\s+time\b",
+        r"\bminimum\s+duration\b",
+        r"\bre-?timing\b",
+    ],
+    "cancellation": [
+        r"\bcancel(l?ation|l?ed|l?ing)?\b",
+        r"\btrain\s+service\s+balance\b",
+        r"\bunbalanced\s+timetable\b",
+    ],
+    "headway": [
+        r"\bheadway\b",
+        r"\bconflict-free\b",
+        r"\bincompatible\s+arc\b",
+        r"\btrain\s+incompatibility\b",
+    ],
+    "capacity": [
+        r"\binfrastructure\s+capacity\b",
+        r"\btrack\s+capacity\b",
+        r"\bstation\s+capacity\b",
+        r"\bblock\s+section\b",
+        r"\bsingle-?track\b",
+        r"\bno-?store\b",
+    ],
+    "flow_balance": [
+        r"\bflow\s+balance\b",
+        r"\bflow\s+conservation\b",
+    ],
+    "big_m": [
+        r"\blarge\s+constant\b",
+        r"\bbig-?M\s+constraint\b",
+        r"\bbig-?M\b",
+    ],
+    "passenger_connection": [
+        r"\bminimum\s+transfer\s+time\b",
+        r"\bpassenger\s+connection\b",
+    ],
+    "rolling_stock_connection": [
+        r"\brolling\s+stock\s+connection\b",
+    ],
+}
+
+
+def classify_constraints(f: Formulation) -> MetricResult:
+    """Heuristic classification of every constraint by keyword matches.
+
+    Returns a dict mapping constraint name to a list of matched type
+    tags. Empty list means no keyword matched. The overall ``value`` is
+    the per-tag count summary.
+    """
+    matrix: dict[str, list[str]] = {}
+    type_counts: dict[str, int] = {tag: 0 for tag in CONSTRAINT_TYPE_KEYWORDS}
+
+    for c in f.constraints:
+        haystack = f"{c.name} {c.description}"
+        matched: list[str] = []
+        for tag, patterns in CONSTRAINT_TYPE_KEYWORDS.items():
+            joined = "|".join(patterns)
+            if re.search(joined, haystack, re.IGNORECASE):
+                matched.append(tag)
+                type_counts[tag] += 1
+        matrix[c.name] = matched
+
+    classified = sum(1 for tags in matrix.values() if tags)
+    return MetricResult(
+        name="classify_constraints",
+        value=type_counts,
+        explanation=(f"Classified {classified}/{len(matrix)} constraint(s) by keyword."),
+        data={"matrix": matrix, "total": len(matrix), "classified": classified},
+    )
+
+
+__all__ = ["CONSTRAINT_TYPE_KEYWORDS", "classify_constraints"]

lp2graph/metrics/flags.py

@@ -0,0 +1,122 @@
+"""Presence flags computed directly from the canonical model.
+
+Each flag is a boolean property of the formulation. They are cheap,
+exact, and do not require any view derivation.
+
+Adapted from joernmht/raiLPminerExperimentation
+(railpminer/analysis/milp_detection.py), MIT License.
+"""
+
+from __future__ import annotations
+
+from lp2graph.core.model import Formulation
+from lp2graph.metrics.result import MetricResult
+
+
+def has_big_m(f: Formulation) -> MetricResult:
+    """True if any parameter has kind ``big_m`` or any constraint has kind ``big_m``."""
+    by_param = any(p.kind == "big_m" for p in f.parameters)
+    by_const = any(c.kind == "big_m" for c in f.constraints)
+    return MetricResult(
+        name="has_big_m",
+        value=by_param or by_const,
+        explanation="A big-M parameter or big-M constraint is present.",
+        data={"by_parameter": by_param, "by_constraint": by_const},
+    )
+
+
+def has_integer_vars(f: Formulation) -> MetricResult:
+    """True if any variable template is integer or binary."""
+    v = any(v.domain in ("integer", "binary") for v in f.variables)
+    return MetricResult(
+        name="has_integer_vars",
+        value=v,
+        explanation="At least one integer or binary variable.",
+    )
+
+
+def has_modulo_offset(f: Formulation) -> MetricResult:
+    """True if any term binding declares a modulo wrap.
+
+    Indicates a PESP-style cyclic formulation. Cyclic indices alone do
+    not trigger this flag — the binding has to use the modulo.
+    """
+    for c in f.constraints:
+        for term in (*c.lhs, *c.rhs):
+            if any(b.modulo for b in term.bindings):
+                return MetricResult(
+                    name="has_modulo_offset",
+                    value=True,
+                    explanation="At least one term binding wraps modulo an index.",
+                )
+    if f.objective is not None:
+        for term in f.objective.terms:
+            if any(b.modulo for b in term.bindings):
+                return MetricResult(
+                    name="has_modulo_offset",
+                    value=True,
+                    explanation="Objective term binding wraps modulo an index.",
+                )
+    return MetricResult(name="has_modulo_offset", value=False, explanation="No modulo bindings.")
+
+
+def has_soft_slack(f: Formulation) -> MetricResult:
+    """True if any variable has role ``slack`` or any term has role ``slack``."""
+    by_var = any(v.role == "slack" for v in f.variables)
+    by_term = any(any(t.role == "slack" for t in (*c.lhs, *c.rhs)) for c in f.constraints)
+    by_obj = bool(f.objective) and any(t.role == "slack" for t in f.objective.terms)  # type: ignore[union-attr]
+    return MetricResult(
+        name="has_soft_slack",
+        value=by_var or by_term or by_obj,
+        explanation="Slack variable or slack-role term is present.",
+        data={"by_variable": by_var, "by_term": by_term, "by_objective": by_obj},
+    )
+
+
+def has_aggregation_operator(f: Formulation) -> MetricResult:
+    """True if any term uses an operator (sum/max/min/abs/indicator/modulo)."""
+    for c in f.constraints:
+        for term in (*c.lhs, *c.rhs):
+            if term.operator != "none":
+                return MetricResult(
+                    name="has_aggregation_operator",
+                    value=True,
+                    explanation=f"Operator {term.operator!r} present in {c.name!r}.",
+                )
+    if f.objective is not None:
+        for term in f.objective.terms:
+            if term.operator != "none":
+                return MetricResult(
+                    name="has_aggregation_operator",
+                    value=True,
+                    explanation=f"Operator {term.operator!r} present in objective.",
+                )
+    return MetricResult(
+        name="has_aggregation_operator",
+        value=False,
+        explanation="No aggregation operators.",
+    )
+
+
+def presence_flags(f: Formulation) -> dict[str, MetricResult]:
+    """Compute every presence flag in a single pass."""
+    return {
+        m.name: m
+        for m in (
+            has_big_m(f),
+            has_integer_vars(f),
+            has_modulo_offset(f),
+            has_soft_slack(f),
+            has_aggregation_operator(f),
+        )
+    }
+
+
+__all__ = [
+    "has_aggregation_operator",
+    "has_big_m",
+    "has_integer_vars",
+    "has_modulo_offset",
+    "has_soft_slack",
+    "presence_flags",
+]