generalize Det{Suffix,}OutputAutomaton concepts to transition systems

Author: mtf90

CHANGELOG.md

@@ -24,6 +24,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * The following class hierarchies have been made `sealed`:
   * `CommonAttrs`
   * `CommonStyles`
+* The `compute{State,Suffix,}Output` concepts from `Det{Suffix,}OutputAutomaton` have been lifted to infinite-state transition systems. As part of this refactoring, some inconsistencies have been addressed. Previously, for `Word`-output systems, `computeSuffixOutput` threw an `UndefinedPropertyAccessException` if the prefix traversed an undefined transition but not if the suffix did (here, the output would only be cut short). Now, both methods simply early-exit output computation. Furthermore, these changes also include the following renamings:
+  * `DetOutputAutomaton` -> `DeterministicOutputAutomaton`
+  * `DetSuffixOutputAutomaton` -> `DeterministicSuffixOutputAutomaton`
+  * `DeterministicOutputTS` -> `DeterministicTraceableTS`
 * `ProcessUtil#invokeProcess` now handles consumers for stdout and stderr separately.
 
 ### Removed

api/src/main/java/module-info.java

@@ -65,6 +65,7 @@
     exports net.automatalib.symbol.time;
     exports net.automatalib.ts;
     exports net.automatalib.ts.acceptor;
+    exports net.automatalib.ts.concept;
     exports net.automatalib.ts.modal;
     exports net.automatalib.ts.modal.transition;
     exports net.automatalib.ts.output;

api/src/main/java/net/automatalib/automaton/concept/DetSuffixOutputAutomaton.java

@@ -16,18 +16,20 @@
 package net.automatalib.automaton.concept;
 
 import net.automatalib.automaton.DeterministicAutomaton;
+import net.automatalib.ts.concept.DeterministicOutputTS;
 
 /**
- * An automaton which deterministically produces an output for an input word. Here, output refers to the <i>complete</i>
- * output that is made when an input word is read, not a single symbol.
+ * A deterministic output automaton is a {@link DeterministicAutomaton deterministic automaton} that can produce
+ * {@link OutputAutomaton outputs}.
  *
  * @param <S>
- *         state class
+ *         state type
  * @param <I>
- *         input symbol class
+ *         input symbol type
  * @param <T>
- *         transition class
+ *         transition type
  * @param <D>
- *         output domain class
+ *         output domain type
  */
-public interface DetOutputAutomaton<S, I, T, D> extends OutputAutomaton<S, I, T, D>, DeterministicAutomaton<S, I, T> {}
+public interface DeterministicOutputAutomaton<S, I, T, D>
+        extends OutputAutomaton<S, I, T, D>, DeterministicAutomaton<S, I, T>, DeterministicOutputTS<S, I, T, D> {}

…utomaton/concept/DetOutputAutomaton.java …oncept/DeterministicOutputAutomaton.javaapi/src/main/java/net/automatalib/automaton/concept/DetOutputAutomaton.java renamed to api/src/main/java/net/automatalib/automaton/concept/DeterministicOutputAutomaton.java api/src/main/java/net/automatalib/automaton/concept/DetOutputAutomaton.java renamed to api/src/main/java/net/automatalib/automaton/concept/DeterministicOutputAutomaton.java

@@ -0,0 +1,34 @@
+/* Copyright (C) 2013-2025 TU Dortmund University
+ * This file is part of AutomataLib <https://automatalib.net>.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.automatalib.automaton.concept;
+
+import net.automatalib.ts.concept.DeterministicSuffixOutputTS;
+
+/**
+ * A deterministic suffix output automaton is a {@link DeterministicOutputAutomaton deterministic output automaton} that
+ * can produce {@link DeterministicSuffixOutputTS suffix outputs}.
+ *
+ * @param <S>
+ *         state type
+ * @param <I>
+ *         input symbol type
+ * @param <T>
+ *         transition type
+ * @param <D>
+ *         output domain type
+ */
+public interface DeterministicSuffixOutputAutomaton<S, I, T, D>
+        extends DeterministicOutputAutomaton<S, I, T, D>, DeterministicSuffixOutputTS<S, I, T, D> {}

api/src/main/java/net/automatalib/automaton/concept/DeterministicSuffixOutputAutomaton.java

@@ -17,11 +17,13 @@
 
 import java.util.Collection;
 
+import net.automatalib.exception.UndefinedPropertyAccessException;
 import net.automatalib.word.Word;
 import net.automatalib.word.WordBuilder;
 
 /**
- * Feature for automata that compute an output.
+ * Feature for transition systems that compute an output. Here, output refers to the <i>complete</i> output that is made
+ * when an input word is read, not a single symbol.
  *
  * @param <I>
  *         input symbol type
@@ -31,13 +33,53 @@
 @FunctionalInterface
 public interface Output<I, D> {
 
+    /**
+     * Computes the output for the given sequence of input symbols.
+     *
+     * @param input
+     *         the sequence of input symbols
+     *
+     * @return the computed output
+     *
+     * @throws UndefinedPropertyAccessException
+     *         if the computation encountered undefined transitions that would have been required for computing the
+     *         output
+     */
     D computeOutput(Iterable<? extends I> input);
 
+    /**
+     * Convenience method for {@link #getBuilderFor(Iterable, int)} which uses {@code 0} for
+     * {@code additionalElements}.
+     *
+     * @param iterable
+     *         the sequence of input symbols
+     * @param <T>
+     *         symbol type
+     *
+     * @return a pre-sized builder (may use the default size if no information could be extracted from the iterable)
+     */
     static <T> WordBuilder<T> getBuilderFor(Iterable<?> iterable) {
+        return getBuilderFor(iterable, 0);
+    }
+
+    /**
+     * Utility method for constructing a pre-sized builder (if possible) for storing responses generated when applying
+     * the provided sequence of input symbols.
+     *
+     * @param iterable
+     *         the sequence of input symbols
+     * @param additionalElements
+     *         number of elements that is added to the size of the iterable
+     * @param <T>
+     *         symbol type
+     *
+     * @return a pre-sized builder (may use the default size if no information could be extracted from the iterable)
+     */
+    static <T> WordBuilder<T> getBuilderFor(Iterable<?> iterable, int additionalElements) {
         if (iterable instanceof Word<?> w) {
-            return new WordBuilder<>(w.length());
+            return new WordBuilder<>(w.length() + additionalElements);
         } else if (iterable instanceof Collection<?> c) {
-            return new WordBuilder<>(c.size());
+            return new WordBuilder<>(c.size() + additionalElements);
         } else {
             return new WordBuilder<>();
         }

api/src/main/java/net/automatalib/automaton/concept/Output.java

@@ -16,5 +16,18 @@
 package net.automatalib.automaton.concept;
 
 import net.automatalib.automaton.Automaton;
+import net.automatalib.ts.concept.OutputTS;
 
-public interface OutputAutomaton<S, I, T, D> extends Automaton<S, I, T>, Output<I, D> {}
+/**
+ * An output automaton is a {@link Automaton finite state} {@link OutputTS output transition system}.
+ *
+ * @param <S>
+ *         state type
+ * @param <I>
+ *         input symbol type
+ * @param <T>
+ *         transition type
+ * @param <D>
+ *         output domain type
+ */
+public interface OutputAutomaton<S, I, T, D> extends Automaton<S, I, T>, OutputTS<S, I, T, D> {}

api/src/main/java/net/automatalib/automaton/concept/OutputAutomaton.java

@@ -15,14 +15,15 @@
  */
 package net.automatalib.automaton.concept;
 
+import net.automatalib.exception.UndefinedPropertyAccessException;
 import net.automatalib.word.Word;
 
 /**
- * Feature for automata that compute a <i>suffix-observable</i> output function, i.e., they compute an output containing
- * a part that can be attributed to a suffix of the input.
+ * Feature for transition systems that compute a <i>suffix-observable</i> output function, i.e., they compute an output
+ * containing a part that can be attributed to a suffix of the input.
  * <p>
  * Note that this is a special case of the {@link Output} feature, as
- * {@code computeOutput(input) = computeSuffixOutput(epsilon, input)}.
+ * {@code computeOutput(input) = computeSuffixOutput(ε, input)}.
  *
  * @param <I>
  *         input symbol type
@@ -37,5 +38,19 @@ default D computeOutput(Iterable<? extends I> input) {
         return computeSuffixOutput(Word.epsilon(), input);
     }
 
+    /**
+     * Computes the output for the given suffix from the state reached by the given prefix.
+     *
+     * @param prefix
+     *         the sequence of input symbols for reaching the state from which the output computation should start
+     * @param suffix
+     *         the sequence of input symbols that should be considered for computing the output
+     *
+     * @return the computed output
+     *
+     * @throws UndefinedPropertyAccessException
+     *         if the computation encountered undefined transitions that would have been required for computing the
+     *         output
+     */
     D computeSuffixOutput(Iterable<? extends I> prefix, Iterable<? extends I> suffix);
 }

api/src/main/java/net/automatalib/automaton/concept/SuffixOutput.java

@@ -18,34 +18,17 @@
 import java.util.Collection;
 
 import net.automatalib.automaton.UniversalDeterministicAutomaton;
-import net.automatalib.automaton.concept.DetSuffixOutputAutomaton;
+import net.automatalib.automaton.concept.DeterministicSuffixOutputAutomaton;
 import net.automatalib.ts.acceptor.DeterministicAcceptorTS;
 
 /**
  * Deterministic finite state acceptor.
  */
 public interface DFA<S, I> extends UniversalDeterministicAutomaton<S, I, S, Boolean, Void>,
                                    DeterministicAcceptorTS<S, I>,
-                                   DetSuffixOutputAutomaton<S, I, S, Boolean>,
+                                   DeterministicSuffixOutputAutomaton<S, I, S, Boolean>,
                                    NFA<S, I> {
 
-    @Override
-    default Boolean computeSuffixOutput(Iterable<? extends I> prefix, Iterable<? extends I> suffix) {
-        S tgt = getState(prefix);
-        return tgt != null && computeStateOutput(tgt, suffix);
-    }
-
-    @Override
-    default Boolean computeStateOutput(S state, Iterable<? extends I> input) {
-        S tgt = getSuccessor(state, input);
-        return tgt != null && isAccepting(tgt);
-    }
-
-    @Override
-    default Boolean computeOutput(Iterable<? extends I> input) {
-        return accepts(input);
-    }
-
     @Override
     default boolean isAccepting(Collection<? extends S> states) {
         return DeterministicAcceptorTS.super.isAccepting(states);

api/src/main/java/net/automatalib/automaton/fsa/DFA.java

@@ -26,7 +26,6 @@
 import net.automatalib.automaton.graph.TransitionEdge;
 import net.automatalib.automaton.graph.UniversalAutomatonGraphView;
 import net.automatalib.automaton.visualization.FSAVisualizationHelper;
-import net.automatalib.common.util.collection.IterableUtil;
 import net.automatalib.graph.UniversalGraph;
 import net.automatalib.ts.acceptor.AcceptorTS;
 import net.automatalib.visualization.VisualizationHelper;
@@ -42,17 +41,6 @@ public interface FiniteStateAcceptor<S, I> extends AcceptorTS<S, I>,
     List<Boolean> STATE_PROPERTIES = Arrays.asList(Boolean.FALSE, Boolean.TRUE);
     List<Void> TRANSITION_PROPERTIES = Collections.singletonList(null);
 
-    @Override
-    default Boolean computeSuffixOutput(Iterable<? extends I> prefix, Iterable<? extends I> suffix) {
-        Iterable<I> input = IterableUtil.concat(prefix, suffix);
-        return computeOutput(input);
-    }
-
-    @Override
-    default Boolean computeOutput(Iterable<? extends I> input) {
-        return accepts(input);
-    }
-
     @Override
     default UniversalGraph<S, TransitionEdge<I, S>, Boolean, TransitionEdge.Property<I, Void>> transitionGraphView(
             Collection<? extends I> inputs) {