lernen 0.1.0 → 0.3.0

data/sig/generated/lernen/automaton/transition_system.rbs

@@ -0,0 +1,108 @@
+# Generated from lib/lernen/automaton/transition_system.rb with RBS::Inline
+
+module Lernen
+  module Automaton
+    # TransitionSystem represents a labelled transition system.
+    #
+    # We assume that this transition system is *deterministic* and *complete*;
+    # thus, the transition function should be defined for all states and input
+    # characters, and the destination configuration of a transition should be one.
+    #
+    # Also, this transition system has an output value for each transition. From
+    # this point of view, this definition is much like Mealy machines. However,
+    # this class is more generic. Actually, this is a superclass of Moore machines,
+    # DFA, etc.
+    #
+    # Note that this class is *abstract*. We should implement the following method:
+    #
+    # - `#type`
+    # - `#initial_conf`
+    # - `#step(conf, input)`
+    # - `#to_graph`
+    #
+    # @rbs generic Conf -- Type for a configuration of this automaton
+    # @rbs generic In   -- Type for input alphabet
+    # @rbs generic Out  -- Type for output values
+    class TransitionSystem[Conf, In, Out]
+      # Returns the automaton type.
+      #
+      # This is an abstract method.
+      #
+      # : () -> transition_system_type
+      def type: () -> transition_system_type
+
+      # Returns the initial configuration.
+      #
+      # This is an abstract method.
+      #
+      # : () -> Conf
+      def initial_conf: () -> Conf
+
+      # Runs a transition from the given configuration with the given input.
+      #
+      # It returns a pair of the output value and the next configuration of
+      # this transition.
+      #
+      # This is an abstract method.
+      #
+      # : (Conf conf, In input) -> [Out, Conf]
+      def step: (Conf conf, In input) -> [ Out, Conf ]
+
+      # Returns a graph of this transition system.
+      #
+      # This is an abstract method.
+      #
+      # : () -> Graph
+      def to_graph: () -> Graph
+
+      # Runs transitions from the initial configuration with the given word.
+      #
+      # It returns a pair of the output values and the final configuration of
+      # the transitions.
+      #
+      # : (Array[In] word) -> [Array[Out], Conf]
+      def run: (Array[In] word) -> [ Array[Out], Conf ]
+
+      # Returns a [Mermaid](https://mermaid.js.org) diagram of this transition system.
+      #
+      # : (?direction: Graph::mermaid_direction) -> String
+      def to_mermaid: (?direction: Graph::mermaid_direction) -> String
+
+      # Returns a [GraphViz](https://graphviz.org) DOT diagram of this transition system.
+      #
+      # : () -> String
+      def to_dot: () -> String
+
+      # Finds a separating word between `automaton1` and `automaton2`.
+      #
+      # : [Conf, In, Out] (
+      #    Array[In] alphabet,
+      #    TransitionSystem[Conf, In, Out] automaton1,
+      #    TransitionSystem[Conf, In, Out] automaton2
+      #  ) -> (Array[In] | nil)
+      def self.find_separating_word: [Conf, In, Out] (Array[In] alphabet, TransitionSystem[Conf, In, Out] automaton1, TransitionSystem[Conf, In, Out] automaton2) -> (Array[In] | nil)
+
+      # Generates a transition function randomly.
+      #
+      # To make a transition function connected, this method generates
+      # a transition function in the following mannar.
+      #
+      # 1. Decide a number of states within `min_state_size..max_state_size` randomly.
+      # 2. Divides the states into `num_reachable_paths` partitions.
+      # 3. Generate a path from the initial state for each paratition.
+      # 4. Generate transition for all `state` and `input`.
+      #
+      # This method returns a pair of a transition function and an array of reachable paths.
+      # The initial state of the result transition function is `0`.
+      #
+      # : [In] (
+      #    alphabet: Array[In],
+      #    ?min_state_size: Integer,
+      #    ?max_state_size: Integer,
+      #    ?num_reachable_paths: Integer,
+      #    ?random: Random,
+      #  ) -> [Hash[[Integer, In], Integer], Array[Array[Integer]]]
+      def self.random_transition_function: [In] (alphabet: Array[In], ?min_state_size: Integer, ?max_state_size: Integer, ?num_reachable_paths: Integer, ?random: Random) -> [ Hash[[ Integer, In ], Integer], Array[Array[Integer]] ]
+    end
+  end
+end

data/sig/generated/lernen/automaton/vpa.rbs

@@ -0,0 +1,109 @@
+# Generated from lib/lernen/automaton/vpa.rb with RBS::Inline
+
+module Lernen
+  module Automaton
+    # VPA represents a [visily pushdown automaton](https://en.wikipedia.org/wiki/Nested_word#Visibly_pushdown_automaton).
+    #
+    # Especially, this definition represents 1-SEVPA (1-module single-entry visibly pushdown automaton).
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    class VPA[In, Call, Return] < MooreLike[VPA::Conf[Call] | nil, In | Call | Return, bool]
+      class Conf[Call] < Data
+        attr_reader state: Integer
+        attr_reader stack: Array[[ Integer, Call ]]
+        def self.[]: [Call] (Integer state, Array[[ Integer, Call ]] stack) -> Conf[Call]
+      end
+
+      @return_transition_function: Hash[[ Integer, Return ], Hash[[ Integer, Call ], Integer]]
+
+      @transition_function: Hash[[ Integer, In ], Integer]
+
+      @accept_state_set: Set[Integer]
+
+      @initial_state: Integer
+
+      # : (
+      #     Integer initial_state,
+      #     Set[Integer] accept_state_set,
+      #     Hash[[Integer, In], Integer] transition_function.
+      #     Hash[[Integer, Return], Hash[[Integer, Call], Integer]] return_transition_function
+      #   ) -> void
+      def initialize: (untyped initial_state, untyped accept_state_set, untyped transition_function, untyped return_transition_function) -> untyped
+
+      attr_reader initial_state: Integer
+
+      attr_reader accept_state_set: Set[Integer]
+
+      attr_reader transition_function: Hash[[ Integer, In ], Integer]
+
+      attr_reader return_transition_function: Hash[[ Integer, Return ], Hash[[ Integer, Call ], Integer]]
+
+      # @rbs return: :vpa
+      def type: () -> :vpa
+
+      # @rbs override
+      def initial_conf: ...
+
+      # @rbs override
+      def step_conf: ...
+
+      # @rbs override
+      def output: ...
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      # : (untyped other) -> bool
+      def ==: (untyped other) -> bool
+
+      # Returns the array of states of this VPA.
+      #
+      # The result array is sorted.
+      #
+      # : () -> Array[Integer]
+      def states: () -> Array[Integer]
+
+      # Returns the error state of this VPA.
+      #
+      # An error state is:
+      #
+      # - neither a initial state nor accepting states, and
+      # - only having self-loops for all `input`.
+      #
+      # If an error state is not found, it returns `nil`.
+      #
+      # : () -> (Integer | nil)
+      def error_state: () -> (Integer | nil)
+
+      # Returns a graph of this VPA.
+      #
+      # (?shows_error_state: bool) -> Graph
+      def to_graph: (?shows_error_state: untyped) -> untyped
+
+      # Finds a separating word between `vpa1` and `vpa2`.
+      #
+      # : [In, Call, Return] (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    Array[Return] return_alphabet,
+      #    VPA[In, Call, Return] vpa1,
+      #    VPA[In, Call, Return] vpa2
+      #  ) -> (Array[In | Call | Return] | nil)
+      def self.find_separating_word: [In, Call, Return] (Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet, VPA[In, Call, Return] vpa1, VPA[In, Call, Return] vpa2) -> (Array[In | Call | Return] | nil)
+
+      # Generates a VPA randomly.
+      #
+      # : [In, Call, Return] (
+      #    alphabet: Array[In],
+      #    call_alphabet: Array[Call],
+      #    return_alphabet: Array[Return],
+      #    ?min_state_size: Integer,
+      #    ?max_state_size: Integer,
+      #    ?accept_state_size: Integer,
+      #    ?random: Random,
+      #  ) -> VPA[In, Call, Return]
+      def self.random: [In, Call, Return] (alphabet: Array[In], call_alphabet: Array[Call], return_alphabet: Array[Return], ?min_state_size: Integer, ?max_state_size: Integer, ?accept_state_size: Integer, ?random: Random) -> VPA[In, Call, Return]
+    end
+  end
+end

data/sig/generated/lernen/automaton.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/lernen/automaton.rb with RBS::Inline
+
+module Lernen
+  # This is a namespace for types of automata (transition systems).
+  #
+  # In this library, the following transition systems are supported.
+  #
+  # - `DFA` (deterministic finite-state automaton) ([Wikipedia](https://en.wikipedia.org/wiki/Deterministic_finite_automaton))
+  # - `Mealy` machine ([Wikipedia](https://en.wikipedia.org/wiki/Mealy_machine))
+  # - `Moore` machine ([Wikipedia](https://en.wikipedia.org/wiki/Moore_machine))
+  # - `VPA` (visibly pushdown automaton) ([Wikipedia](https://en.wikipedia.org/wiki/Nested_word#Visibly_pushdown_automaton))
+  module Automaton
+    type transition_system_type = :dfa | :moore | :mealy | :vpa | :spa
+  end
+end

data/sig/generated/lernen/equiv/combined_oracle.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/lernen/equiv/combined_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # CombinedOracle provides an implementation of equivalence query
+    # that find a counterexample by combining multiple oracles.
+    #
+    # This takes two oracle. If the first oracle finds a counterexample, then
+    # this oracle returns it. Otherwise, it tries the second and other oracles.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class CombinedOracle[In, Out] < Oracle[In, Out]
+      @oracles: Array[Oracle[In, Out]]
+
+      def initialize: (untyped oracles) -> untyped
+
+      attr_reader oracles: Array[Oracle[In, Out]]
+
+      # @rbs override
+      def find_cex: ...
+
+      # @rbs override
+      def stats: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/exhaustive_search_oracle.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/lernen/equiv/exhaustive_search_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # ExhaustiveSearchOracle provides an implementation of equivalence query
+    # that finds a counterexample by using exhaustive search to `depth` products
+    # of input alphabet characters.
+    #
+    # For example, with `alphabet = %w[0 1]` and `depth = 3`, this oracle queries
+    # the following 14 words for finding a counterexample.
+    #
+    # ```ruby
+    # 0, 1,
+    # 00, 01, 10, 11,
+    # 000, 001, 010, 011, 100, 101, 110, 111
+    # ```
+    #
+    # As the strategy, this oracle is extremingly slow and we do not recommend to use
+    # this oracle for non-testing purposes.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class ExhaustiveSearchOracle[In, Out] < Oracle[In, Out]
+      @alphabet: Array[In]
+
+      @depth: Integer
+
+      # @rbs alphabet: Array[In]
+      # @rbs sul: System::SUL[In, Out]
+      # @rbs depth: Integer
+      # @rbs return: void
+      def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, ?depth: Integer) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/moore_like_simulator_oracle.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/lernen/equiv/moore_like_simulator_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # MooreLikeSimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the moore-like transition system.
+    #
+    # @rbs generic Conf -- Type for a configuration of this automaton
+    # @rbs generic In   -- Type for input alphabet
+    # @rbs generic Out  -- Type for output values
+    class MooreLikeSimulatorOracle[Conf, In, Out] < Oracle[In, Out]
+      @alphabet: Array[In]
+
+      @automaton: Automaton::MooreLike[Conf, In, Out]
+
+      # : (
+      #     Array[In] alphabet,
+      #     Automaton::MooreLike[Conf, In, Out] spa,
+      #     System::SUL[In, Out] sul
+      #   ) -> void
+      def initialize: (Array[In] alphabet, Automaton::MooreLike[Conf, In, Out] spa, System::SUL[In, Out] sul) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/oracle.rbs

@@ -0,0 +1,75 @@
+# Generated from lib/lernen/equiv/oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # Oracle is an oracle for answering a equivalence query.
+    #
+    # On running equivalence queries, this records the statistics information.
+    # We can obtain this information by `Oracle#stats`.
+    #
+    # Note that this class is *abstract*. You should implement the following method:
+    #
+    # - `#find_cex(hypothesis)`
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class Oracle[In, Out]
+      @sul: System::SUL[In, Out]
+
+      @num_calls: Integer
+
+      @num_queries: Integer
+
+      @num_steps: Integer
+
+      @current_conf: untyped
+
+      # : (System::SUL[In, Out] sul) -> void
+      def initialize: (System::SUL[In, Out] sul) -> void
+
+      attr_reader sul: System::SUL[In, Out]
+
+      # Finds a conterexample against the given `hypothesis` automaton.
+      # If it is found, it returns the counterexample word, or it returns `nil` otherwise.
+      #
+      # A counterexample means that it separates a sul and a hypothesis automaton on an output
+      # value, i.e., `hypothesis.run(cex)[0].last != sul.query_last(cex)`. We also assume
+      # a counterexample is minimal; that is, there is no `n` (where `0 <= n < cex.size`)
+      # such that `hypothesis.run(cex[0...n])[0].last != sul.query_last(cex[0...n])`.
+      #
+      # : [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis) -> (Array[In] | nil)
+      def find_cex: [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis) -> (Array[In] | nil)
+
+      # Returns the statistics information as a `Hash` object.
+      #
+      # The result hash contains the following values.
+      #
+      # - `num_calls`: The number of calls of `find_cex`.
+      # - `num_queries`: The number of queries.
+      # - `num_steps`: The total number of steps.
+      #
+      # : () -> Hash[Symbol, Integer]
+      def stats: () -> Hash[Symbol, Integer]
+
+      # Combines two oracles.
+      #
+      # : (Oracle[In, Out] other) -> CombinedOracle[In, Out]
+      def +: (Oracle[In, Out] other) -> CombinedOracle[In, Out]
+
+      private
+
+      # Resets the internal states of this oracle.
+      #
+      # : [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis) -> void
+      def reset_internal: [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis) -> void
+
+      # Runs a transition of both a hypothesis and a SUL.
+      #
+      # : [Conf] (
+      #    Automaton::TransitionSystem[Conf, In, Out] hypothesis,
+      #    In input
+      #  ) -> [Out, Out]
+      def step_internal: [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis, In input) -> [ Out, Out ]
+    end
+  end
+end

data/sig/generated/lernen/equiv/random_walk_oracle.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/lernen/equiv/random_walk_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # RandomWalkOracle provides an implementation of equivalence query
+    # that finds a counterexample by using random walk.
+    #
+    # This takes two important parameters:
+    #
+    # - `max_steps` (default: `1500`): It is a limit of steps of a random walk.
+    #     If a random walk is tried up to this value and no counterexample is found,
+    #     it returns `nil` finally.
+    # - `reset_prob` (default: `0.09`): It is a probability to reset a random walk.
+    #     On resetting a random walk, it resets a word, but it does not reset
+    #     a step counter.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class RandomWalkOracle[In, Out] < Oracle[In, Out]
+      @alphabet: Array[In]
+
+      @max_steps: Integer
+
+      @reset_prob: Float
+
+      @random: Random
+
+      # : (
+      #     Array[In] alphabet,
+      #     System::SUL[In, Out] sul,
+      #     ?max_steps: Integer,
+      #     ?reset_prob: Float,
+      #     ?random: Random
+      #   ) -> void
+      def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, ?max_steps: Integer, ?reset_prob: Float, ?random: Random) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/random_well_matched_word_oracle.rbs

@@ -0,0 +1,70 @@
+# Generated from lib/lernen/equiv/random_well_matched_word_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # RandomWellMatchedWordOracle provides an implementation of equivalence query
+    # that finds a counterexample by using random well-matched word generation.
+    #
+    # This takes three important parameters:
+    #
+    # - `max_words` (default: `100`): It is a limit of number of random words.
+    #     If random words is generated and tried up to this value and no counterexample
+    #     is found, it returns `nil` finally.
+    # - `min_word_size` (default: `2`): It is the minimal size of randomly generated word.
+    #     It should be greater than `0`.
+    # - `max_word_size` (default: `30`): It is the maximal size of randomly generated word.
+    #     It should be greater than or equal to `min_word_size`.
+    # - `call_prob` (default: `0.1`): It is a probability to generate call and return subwords.
+    # - `initial_proc` (default `nil`): It is the initial proc character.
+    #     If it is specified, the generated words must be started with it.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    # @rbs generic Out    -- Type for output values
+    class RandomWellMatchedWordOracle[In, Call, Return, Out] < Oracle[In | Call | Return, Out]
+      @alphabet: Array[In]
+
+      @call_alphabet: Array[Call]
+
+      @return_alphabet: Array[Return]
+
+      @max_words: Integer
+
+      @min_word_size: Integer
+
+      @max_word_size: Integer
+
+      @call_prob: Float
+
+      @initial_proc: Call | nil
+
+      @random: Random
+
+      # : (
+      #     Array[In] alphabet,
+      #     Array[Call] call_alphabet,
+      #     Array[Return] return_alphabet,
+      #     System::SUL[In | Call | Return, Out] sul,
+      #     ?max_words: Integer,
+      #     ?min_word_size: Integer,
+      #     ?max_word_size: Integer,
+      #     ?call_prob: Float,
+      #     ?initial_proc: Call | nil,
+      #     ?random: Random
+      #   ) -> void
+      def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet, System::SUL[In | Call | Return, Out] sul, ?max_words: Integer, ?min_word_size: Integer, ?max_word_size: Integer, ?call_prob: Float, ?initial_proc: Call | nil, ?random: Random) -> void
+
+      # @rbs override
+      def find_cex: ...
+
+      private
+
+      # : () -> Array[In | Call | Return]
+      def generate_word: () -> Array[In | Call | Return]
+
+      # : (Array[In | Call | Return] word, Integer word_size) -> void
+      def generate_word_internal: (Array[In | Call | Return] word, Integer word_size) -> void
+    end
+  end
+end

data/sig/generated/lernen/equiv/random_word_oracle.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/lernen/equiv/random_word_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # RandomWordOracle provides an implementation of equivalence query
+    # that finds a counterexample by using random word generation.
+    #
+    # This takes three important parameters:
+    #
+    # - `max_words` (default: `100`): It is a limit of number of random words.
+    #     If random words is generated and tried up to this value and no counterexample
+    #     is found, it returns `nil` finally.
+    # - `min_word_size` (default: `1`): It is the minimal size of randomly generated word.
+    #     It should be greater than `0`.
+    # - `max_word_size` (default: `30`): It is the maximal size of randomly generated word.
+    #     It should be greater than or equal to `min_word_size`.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class RandomWordOracle[In, Out] < Oracle[In, Out]
+      @alphabet: Array[In]
+
+      @max_word: Integer
+
+      @min_word_size: Integer
+
+      @max_word_size: Integer
+
+      @random: Random
+
+      # : (
+      #     Array[In] alphabet,
+      #     System::SUL[In, Out] sul,
+      #     ?max_words: Integer,
+      #     ?min_word_size: Integer,
+      #     ?max_word_size: Integer,
+      #     ?random: Random,
+      #   ) -> void
+      def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, ?max_words: Integer, ?min_word_size: Integer, ?max_word_size: Integer, ?random: Random) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/spa_simulator_oracle.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/lernen/equiv/spa_simulator_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # SPASimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the SPA.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    class SPASimulatorOracle[In, Call, Return] < Oracle[In | Call | Return, bool]
+      @alphabet: Array[In]
+
+      @call_alphabet: Array[Call]
+
+      @spa: Automaton::SPA[In, Call, Return]
+
+      # : (
+      #     Array[In] alphabet,
+      #     Array[Call] call_alphabet,
+      #     Automaton::SPA[In, Call, Return] spa,
+      #     System::SUL[In | Call | Return, bool] sul
+      #   ) -> void
+      def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Automaton::SPA[In, Call, Return] spa, System::SUL[In | Call | Return, bool] sul) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/test_words_oracle.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/lernen/equiv/test_words_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # TestWordsOracle provides an implementation of equivalence query
+    # that find a counterexample from the given words.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class TestWordsOracle[In, Out] < Oracle[In, Out]
+      @words: Array[Array[In]]
+
+      # : (Array[Array[In]] words, System::SUL[In, Out] sul) -> void
+      def initialize: (Array[Array[In]] words, System::SUL[In, Out] sul) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/transition_system_simulator_oracle.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/lernen/equiv/transition_system_simulator_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # TransitionSystemSimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the transition system.
+    #
+    # @rbs generic Conf -- Type for a configuration of this automaton
+    # @rbs generic In   -- Type for input alphabet
+    # @rbs generic Out  -- Type for output values
+    class TransitionSystemSimulatorOracle[Conf, In, Out] < Oracle[In, Out]
+      @alphabet: Array[In]
+
+      @automaton: Automaton::TransitionSystem[Conf, In, Out]
+
+      # : (
+      #     Array[In] alphabet,
+      #     Automaton::TransitionSystem[Conf, In, Out] spa,
+      #     System::SUL[In, Out] sul
+      #   ) -> void
+      def initialize: (Array[In] alphabet, Automaton::TransitionSystem[Conf, In, Out] spa, System::SUL[In, Out] sul) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end

data/sig/generated/lernen/equiv/vpa_simulator_oracle.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/lernen/equiv/vpa_simulator_oracle.rb with RBS::Inline
+
+module Lernen
+  module Equiv
+    # VPASimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the VPA.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    class VPASimulatorOracle[In, Call, Return] < Oracle[In | Call | Return, bool]
+      @alphabet: Array[In]
+
+      @call_alphabet: Array[Call]
+
+      @return_alphabet: Array[Return]
+
+      @spa: Automaton::VPA[In, Call, Return]
+
+      # : (
+      #     Array[In] alphabet,
+      #     Array[Call] call_alphabet,
+      #     Array[Return] return_alphabet,
+      #     Automaton::VPA[In, Call, Return] vpa,
+      #     System::SUL[In | Call | Return, bool] sul
+      #   ) -> void
+      def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet, Automaton::VPA[In, Call, Return] vpa, System::SUL[In | Call | Return, bool] sul) -> void
+
+      # @rbs override
+      def find_cex: ...
+    end
+  end
+end