Cost Function as a DFA¶

def add_edge(self, parent: int, child: int, condition: Formula):
    """Disables edge modification after wrapping.

    Raises:
      RuntimeError: Always raised. Build the DFA fully before wrapping it as
        a cost function to avoid unintended side effects.
    """
    raise RuntimeError(
        "Please build the DFA before wrapping it as a cost function to avoid unintended side effects"
    )

def reset(self):
    """Resets the internal DFA state.

    Notes:
      This delegates to the wrapped DFA's :meth:`DFA.reset`.
    """
    self.dfa.reset()

def step(self, labels: Iterable[str]) -> Tuple[bool, int]:
    """Disables stepping via the DFA interface.

    Raises:
      RuntimeError: Always raised. Use :meth:`__call__` to advance the
        internal DFA and return the cost signal.
    """
    raise RuntimeError(
        "Please do not modify the the internal dfa state here, use DFACostFn.__call__ instead for correct functionality"
    )

def cost(self, state: int, labels: Iterable[str]) -> float:
    """Computes the one-step cost from an explicit DFA state without mutation.

    Args:
      state: The DFA state to evaluate from (does not need to equal the
        internal automaton state).
      labels: Iterable of atomic proposition names for the current step.

    Returns:
      ``1.0`` iff the next state reached from ``state`` under ``labels`` is
      accepting; otherwise ``0.0``.

    Notes:
      This is intended for counterfactual evaluation and does not change the
      wrapped DFA's internal state.
    """
    return float(self.dfa.transition(state, labels) in self.dfa.accepting)

def __call__(self, labels: Iterable[str]):
    """Advances the internal DFA by one step and returns the cost.

    Args:
      labels: Iterable of atomic proposition names for the current step.

    Returns:
      ``1.0`` if the internal DFA transitions into an accepting state on
      this step, else ``0.0``.
    """
    accepting, _ = self.dfa.step(labels)
    return float(accepting)