lernen 0.1.0 → 0.3.0

data/sig/generated/lernen/equiv.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/lernen/equiv.rb with RBS::Inline
+
+module Lernen
+  # This is a namespace for equivalence query oracles.
+  #
+  # A equivalence query check the given hypothesis automaton is equivalence
+  # to a SUL. If that is not, it returns a counterexample, which leads
+  # different output values between the hypothesis and the SUL.
+  module Equiv
+  end
+end

data/sig/generated/lernen/graph.rbs

@@ -0,0 +1,80 @@
+# Generated from lib/lernen/graph.rb with RBS::Inline
+
+module Lernen
+  # Graph represents a labelled directed graph.
+  #
+  # This is an intermediate data structure for rendering Mermaid and Graphviz diagrams.
+  class Graph
+    type node_shape = :circle | :doublecircle
+
+    type mermaid_direction = "TD" | "DT" | "LR" | "RL"
+
+    class Node < Data
+      attr_reader label: String
+      attr_reader shape: node_shape
+      def self.[]: (String label, node_shape shape) -> Node
+    end
+
+    class Edge < Data
+      attr_reader from: Integer
+      attr_reader label: String
+      attr_reader to: Integer
+      def self.[]: (Integer from, String label, Integer to) -> Edge
+    end
+
+    class SubGraph < Data
+      attr_reader label: String
+      attr_reader graph: Graph
+      def self.[]: (String label, Graph graph) -> SubGraph
+    end
+
+    # Returns the escaped string for Mermaid diagrams.
+    #
+    # See https://mermaid.js.org/syntax/flowchart.html#entity-codes-to-escape-characters.
+    #
+    # : (String label) -> String
+    def self.mermaid_escape: (String label) -> String
+
+    # Returns the escaped string for GraphViz DOTs.
+    #
+    # See https://graphviz.org/docs/attr-types/escString/.
+    #
+    # : (String label) -> String
+    def self.dot_escape: (String label) -> String
+
+    @subgraphs: Array[SubGraph]
+
+    @edges: Array[Edge]
+
+    @nodes: Hash[Integer, Node]
+
+    # : (
+    #     Hash[Integer, Node] nodes,
+    #     Array[Edge] edges,
+    #     ?Array[SubGraph] subgraphs
+    #   ) -> void
+    def initialize: (Hash[Integer, Node] nodes, Array[Edge] edges, ?Array[SubGraph] subgraphs) -> void
+
+    attr_reader nodes: Hash[Integer, Node]
+
+    attr_reader edges: Array[Edge]
+
+    attr_reader subgraphs: Array[SubGraph]
+
+    # Returns a [Mermaid](https://mermaid.js.org) diagram of this graph.
+    #
+    # : (?direction: mermaid_direction) -> String
+    def to_mermaid: (?direction: mermaid_direction) -> String
+
+    # Returns a [GraphViz](https://graphviz.org) DOT diagram of this graph.
+    #
+    # : () -> String
+    def to_dot: () -> String
+
+    # : (?String id_prefix) -> String
+    def to_mermaid_internal: (?String id_prefix) -> String
+
+    # : (?String id_prefix) -> String
+    def to_dot_internal: (?String id_prefix) -> String
+  end
+end

data/sig/generated/lernen/system/block_sul.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/lernen/system/block_sul.rb with RBS::Inline
+
+module Lernen
+  module System
+    # BlockSUL is a system under learning (SUL) constructed from a block.
+    #
+    # A block is expected to behave like a membership query.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class BlockSUL[In, Out] < MooreLikeSUL[In, Out]
+      @block: ^(Array[In]) -> Out
+
+      @word: Array[In]
+
+      # : (?cache: bool) { (Array[In]) -> Out } -> void
+      def initialize: (?cache: bool) { (Array[In]) -> Out } -> void
+
+      # @rbs override
+      def setup: ...
+
+      # @rbs override
+      def step: ...
+
+      # @rbs override
+      def query_empty: ...
+    end
+  end
+end

data/sig/generated/lernen/system/moore_like_simulator.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/lernen/system/moore_like_simulator.rb with RBS::Inline
+
+module Lernen
+  module System
+    # MooreLikeSimulator is a system under learning (SUL) using a Moore-like machine simulation.
+    #
+    # @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 MooreLikeSimulator[Conf, In, Out] < MooreLikeSUL[In, Out]
+      @automaton: Automaton::MooreLike[Conf, In, Out]
+
+      @current_conf: Conf | nil
+
+      # : (Automaton::MooreLike[Conf, In, Out] automaton, ?cache: bool) -> void
+      def initialize: (Automaton::MooreLike[Conf, In, Out] automaton, ?cache: bool) -> void
+
+      # @rbs override
+      def setup: ...
+
+      # @rbs override
+      def shutdown: ...
+
+      # @rbs override
+      def step: ...
+
+      # @rbs override
+      def query_empty: ...
+    end
+  end
+end

data/sig/generated/lernen/system/moore_like_sul.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/lernen/system/moore_like_sul.rb with RBS::Inline
+
+module Lernen
+  module System
+    # MooreLikeSUL is a system under learning (SUL) for a system much like Moore machine.
+    #
+    # By contrast to `SUL`, this accepts a query with the empty string additionally.
+    #
+    # Note that this class is *abstract*. You should implement the following method:
+    #
+    # - `#step(input)`
+    # - `#query_empty`
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class MooreLikeSUL[In, Out] < SUL[In, Out]
+      # : (?cache: bool) -> void
+      def initialize: (?cache: bool) -> void
+
+      # Runs a membership query with the empty input.
+      #
+      # This is an abstract method.
+      #
+      # : () -> Out
+      def query_empty: () -> Out
+    end
+  end
+end

data/sig/generated/lernen/system/sul.rbs

@@ -0,0 +1,87 @@
+# Generated from lib/lernen/system/sul.rb with RBS::Inline
+
+module Lernen
+  module System
+    # SUL represents a system under learning.
+    #
+    # It is an abtraction of a system under learning (SUL) which accepts an operation
+    # called "membership query"; it takes an input string (word) and returns a sequence
+    # of outputs corresponding to the input string.
+    #
+    # This SUL assumes the system is much like Mealy machine; that is, a transition puts
+    # an output, and query does not accept the empty string due to no outputs.
+    #
+    # This SUL also implements cache mechanism. The cache mechanism is enabled by the default,
+    # and it can be disabled by specifying `cache: false`.
+    #
+    # On running a SUL, this SUL records the statistics information. We can obtain this
+    # information by `SUL#stats`.
+    #
+    # Note that this class is *abstract*. You should implement the following method:
+    #
+    # - `#step(input)`
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class SUL[In, Out]
+      @cache: Hash[Array[In], Array[Out]] | nil
+
+      @num_cached_queries: Integer
+
+      @num_queries: Integer
+
+      @num_steps: Integer
+
+      # : (?cache: bool) -> void
+      def initialize: (?cache: bool) -> void
+
+      # Returns the statistics information as a `Hash` object.
+      #
+      # The result hash contains the following values.
+      #
+      # - `num_cache`: The number of cached queries.
+      # - `num_cached_queries`: The number of queries uses the cache.
+      # - `num_queries`: The number of (non-cached) queries.
+      # - `num_steps`: The total number of steps.
+      #
+      # : () -> Hash[Symbol, Integer]
+      def stats: () -> Hash[Symbol, Integer]
+
+      # Runs a membership query with the given word.
+      #
+      # Note that this method does not accept the empty string due to no outpus.
+      # If you need to call `query` with the empty string, you should use `MooreSUL#query_empty` instead.
+      #
+      # : (Array[In] word) -> Array[Out]
+      def query: (Array[In] word) -> Array[Out]
+
+      # Runs a membership query with the given word, and returns the last output.
+      #
+      # It is the same as `query(word).last`.
+      #
+      # : (Array[In] word) -> Out
+      def query_last: (Array[In] word) -> Out
+
+      # It is a setup procedure of this SUL.
+      #
+      # Note that it does nothing by default.
+      #
+      # : () -> void
+      def setup: () -> void
+
+      # It is a shutdown procedure of this SUL.
+      #
+      # Note that it does nothing by default.
+      #
+      # : () -> void
+      def shutdown: () -> void
+
+      # Consumes the given `input` and returns the correspoding output.
+      #
+      # This is an abstract method.
+      #
+      # : (In input) -> Out
+      def step: (In input) -> Out
+    end
+  end
+end

data/sig/generated/lernen/system/transition_system_simulator.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/lernen/system/transition_system_simulator.rb with RBS::Inline
+
+module Lernen
+  module System
+    # TransitionSystemSimulator is a system under learning (SUL) using a transition system simulation.
+    #
+    # @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 TransitionSystemSimulator[Conf, In, Out] < SUL[In, Out]
+      @automaton: Automaton::TransitionSystem[Conf, In, Out]
+
+      @current_conf: Conf | nil
+
+      # : (Automaton::TransitionSystem[Conf, In, Out] automaton, ?cache: bool) -> void
+      def initialize: (Automaton::TransitionSystem[Conf, In, Out] automaton, ?cache: bool) -> void
+
+      # @rbs override
+      def setup: ...
+
+      # @rbs override
+      def shutdown: ...
+
+      # @rbs override
+      def step: ...
+    end
+  end
+end

data/sig/generated/lernen/system.rbs

@@ -0,0 +1,62 @@
+# Generated from lib/lernen/system.rb with RBS::Inline
+
+module Lernen
+  # This is a namespace for systems under learning (SULs).
+  #
+  # `SUL` is an implementation of membership (or output) query.
+  #
+  # There are two base abstract classes of SULs: `SUL` and `MooreLikeSUL`
+  # `SUL` is the most base abstract class of SULs and it cannot answer a query
+  # with the empty string. `MooreLikeSUL` is subclass of `SUL` and it can answer
+  # the empty string query.
+  #
+  # In this library, we provide two easy ways to create a SUL. The first way is
+  # `System.from_block`. This method takes a block, and the block is used as
+  # a membership query implementation.
+  #
+  # ```ruby
+  # sul = Lernen::System.from_block do |word|
+  #   word.count("1") % 4 == 3
+  # end
+  # ```
+  #
+  # The another way is `System.from_automaton`. This method takes an automaton
+  # (a transition system), and the result SUL simulates this automaton.
+  #
+  # ```ruby
+  # dfa = Lernen::Automaton::DFA.new(
+  #   0,
+  #   Set[1],
+  #   {
+  #     [0, '0'] => 0,
+  #     [0, '1'] => 1,
+  #     [1, '0'] => 1,
+  #     [1, '1'] => 1,
+  #   }
+  # )
+  #
+  # sul = Lernen::System.from_automaton(dfa)
+  # ```
+  module System
+    # Creates a SUL from the given block as an implementation of a membership query.
+    #
+    # : [In, Out] (?cache: bool) { (Array[In]) -> Out } -> MooreLikeSUL[In, Out]
+    def self.from_block: [In, Out] (?cache: bool) { (Array[In]) -> Out } -> MooreLikeSUL[In, Out]
+
+    # Creates a SUL from the given automaton as an implementation.
+    #
+    # This method chooses a suitable SUL implementation, which is one of `TransitionSystemSimulator`
+    # or `MooreLikeSimulator`, for the given automaton.
+    #
+    # : [In] (Automaton::DFA[In] automaton, ?cache: bool) -> SUL[In, bool]
+    # : [In, Out] (Automaton::Mealy[In, Out] automaton, ?cache: bool) -> SUL[In, Out]
+    # : [In, Out] (Automaton::Moore[In, Out] automaton, ?cache: bool) -> SUL[In, Out]
+    # : [In, Call, Return] (Automaton::VPA[In, Call, Return] automaton, ?cache: bool) -> SUL[In | Call | Return, bool]
+    # : [In, Call, Return] (Automaton::SPA[In, Call, Return] automaton, ?cache: bool) -> SUL[In | Call | Return, bool]
+    def self.from_automaton: [In] (Automaton::DFA[In] automaton, ?cache: bool) -> SUL[In, bool]
+                           | [In, Out] (Automaton::Mealy[In, Out] automaton, ?cache: bool) -> SUL[In, Out]
+                           | [In, Out] (Automaton::Moore[In, Out] automaton, ?cache: bool) -> SUL[In, Out]
+                           | [In, Call, Return] (Automaton::VPA[In, Call, Return] automaton, ?cache: bool) -> SUL[In | Call | Return, bool]
+                           | [In, Call, Return] (Automaton::SPA[In, Call, Return] automaton, ?cache: bool) -> SUL[In | Call | Return, bool]
+  end
+end

data/sig/generated/lernen/version.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/lernen/version.rb with RBS::Inline
+
+module Lernen
+  # The version string.
+  VERSION: ::String
+end

data/sig/generated/lernen.rbs

@@ -0,0 +1,214 @@
+# Generated from lib/lernen.rb with RBS::Inline
+
+# Lernen is an automata learning library written in Ruby.
+#
+# **Automata learning** (active automata learning) is a known technique to infer an automaton
+# from a teacher program; here, a teacher is an abstraction of a system (or a program) that
+# can answer two kinds of queries. One kind of queries is **membership** query, which takes
+# an input word and returns a boolean value whether the word is accepted or rejected by the system.
+# Another kind of queries is **equivalence** query, which takes a hypothesis (under-learning) automaton
+# and returns `true` if the hypothesis is equivalent to the system, or returns a counterexample
+# word if it is not equivalent. Automata learning algorithms use these queries to gather
+# information about the black-box system and infer an automaton which is equivalent to the system.
+#
+# This library implements some automata learning algorithms.
+#
+# - L* (also known as Angluin's L*) is a common and classic algorithm for automata learning, introduced
+#   by [Angluin (1987) "Learning Regular Sets from Queries and Counterexamples"](https://dl.acm.org/doi/10.1016/0890-5401%2887%2990052-6).
+#   This algorithm uses an observation table for collecting query results and inferring an automaton.
+#   Our implementation also accepts the Rivest-Schapire counterexample processing optimization described by
+#   [Rivest & Schapire (1993) "Inference of Finite Automata Using Homing Sequences"](https://www.sciencedirect.com/science/article/pii/S0890540183710217).
+# - Kearns-Vazirani is also a common and classic algorithm, introduced by
+#   [Kearns & Vazirani (1994) "An Introduction to Computational Learning Theory"](https://direct.mit.edu/books/monograph/2604/An-Introduction-to-Computational-Learning-Theory).
+#   This algorithm uses a discrimination tree for learning an automaton instead of an observation
+#   tree. Also, our implementation is extended to infer a VPA (visibly pushdown automaton) that is
+#   an extension of DFA which can recognize some non-regular languages (nested words).
+#   It is the default algorithm in this library.
+# - L# is a modern algorithm for automata learning, introduced by
+#   [Vaandrager et al. (2022) "A New Approach for Active Automata Learning Based on Apartness"](https://link.springer.com/chapter/10.1007/978-3-030-99524-9_12).
+#   This algorithm uses apartness relation and an observation tree for learning an automaton.
+#   In many cases, it reduces the numbers of queries, but the data structure and algorithm have
+#   some overheads. If a query is slow (e.g., forking a process), this algorithm may be a good option.
+#
+# ## Example
+#
+# This library provides `Lernen.learn` method as a good frontend for learning an automaton.
+#
+# In the most simple way to use it, we need to give `alphabet` and a block to infer a program
+# to `Lernen.learn`. See the below example. This example is a program to learn a prediction on
+# the binary language as a DFA and print it as a [mermaid](https://mermaid.js.org) diagram.
+#
+# ```ruby
+# dfa = Lernen.learn(alphabet: %w[0 1]) do |word|
+#   word.count("1") % 4 == 3
+# end
+# puts dfa.to_mermaid
+#
+# # Output:
+# # flowchart TD
+# #   0((0))
+# #   1((1))
+# #   2((2))
+# #   3(((3)))
+# #
+# #   0 -- "'0'" --> 0
+# #   0 -- "'1'" --> 1
+# #   1 -- "'0'" --> 1
+# #   1 -- "'1'" --> 2
+# #   2 -- "'0'" --> 2
+# #   2 -- "'1'" --> 3
+# #   3 -- "'0'" --> 3
+# #   3 -- "'1'" --> 0
+# ```
+#
+# Of course, we can specify more parameters to `Lernen.learn` for learning other kinds of automata
+# such as Moore or Mealy machines. Please refer the `Lernen.learn` doc.
+module Lernen
+  type oracle_type = :exhaustive_search | :random_walk | :random_word | :random_well_matched_word | :simulator
+
+  type algorithm_name = :lstar | :kearns_vazirani | :lsharp
+
+  # Learn an automaton by using the given parameters.
+  #
+  # This method is a frontend of the learning algorithms. Actual implementations are placed under
+  # the `Lernen::Algorithm` namespace.
+  #
+  # ## Parameters
+  #
+  # This method takes a lot of parameters, but almost of parameters are optional. To start learning,
+  # we need to give `alphabet` and a block of a program to infer an automaton.
+  #
+  # - `alphabet`: An input alphabet. This must be given as an `Array` object.
+  # - `call_alphabet`: A call input alphabet of VPA. If this is specified, `automaton_type` is specified
+  #   as `:vpa` automatically.
+  # - `return_alphabet`: A return input alphabet of VPA.
+  # - `sul`: A system under learning. If an automaton instance is given, it is converted it to a simulator
+  #   and use it as a SUL. Or, if it is not specified, we use a block as a SUL.
+  # - `oracle`: An equivalence oracle. It is one of `:exhaustive_search`, `:random_walk`, `:random_word`, or
+  #   an actual instance of `Equiv::Oracle`. If the value is a symbol, an `Equiv::Oracle` instance of the specified
+  #   kind is created with `oracle_params`. The default value is `:random_word` if `automaton_type` is one of `:dfa`,
+  #   `:moore`, and `:mealy`, or the default value is `:random_well_matched_word` if `automaton_type` is either `:spa`
+  #   or `:vpa`.
+  # - `oracle_params`: A hash of parameters for equivalence oracle. The default value is `{}`.
+  # - `algorithm`: An algorithm name to use. It is one of `:lstar`, `:kearns_vazirani`, or `:lsharp`. The default value
+  #   is `:kearns_vazirani` (if `automaton_type` is one of `:dfa`, `:moore`, and `:mealy`), or `:kearns_vazirani_vpa`
+  #   (if `automaton_type` is `vpa`), or `:procedural` (if `automaton_type` is `spa`).
+  # - `automaton_type`: A type of automaton to infer. It is one of `:dfa`, `:mealy`, `:moore`, `:vpa`, and `:spa`.
+  #   The default value is `:dfa`, but it becomes `:vpa` or `:spa` if `call_alphabet` or `return_input` is specified.
+  # - `params`: A hash of parameter to pass a learning algorithm. The default value is `{}`.
+  # - `random`: A PRNG instance. It is used by an equivalence oracle.
+  #
+  # : [In] (
+  #    alphabet: Array[In],
+  #    sul: Automaton::DFA[In] | System::MooreLikeSUL[In, bool],
+  #    ?oracle: oracle_type | Equiv::Oracle[In, bool],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: algorithm_name,
+  #    ?automaton_type: :dfa,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) -> Automaton::DFA[In]
+  # : [In] (
+  #    alphabet: Array[In],
+  #    ?oracle: oracle_type | Equiv::Oracle[In, bool],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: algorithm_name,
+  #    ?automaton_type: :dfa,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) { (Array[In]) -> bool } -> Automaton::DFA[In]
+  # : [In, Out] (
+  #    alphabet: Array[In],
+  #    sul: Automaton::Mealy[In, Out] | System::SUL[In, Out],
+  #    ?oracle: oracle_type | Equiv::Oracle[In, Out],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: algorithm_name,
+  #    automaton_type: :mealy,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) -> Automaton::Mealy[In, Out]
+  # : [In, Out] (
+  #    alphabet: Array[In],
+  #    ?oracle: oracle_type | Equiv::Oracle[In, Out],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: algorithm_name,
+  #    automaton_type: :mealy,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) { (Array[In]) -> Out } -> Automaton::Mealy[In, Out]
+  # : [In, Out] (
+  #    alphabet: Array[In],
+  #    sul: Automaton::Moore[In, Out] | System::MooreLikeSUL[In, Out],
+  #    ?oracle: oracle_type | Equiv::Oracle[In, Out],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: algorithm_name,
+  #    automaton_type: :moore,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) -> Automaton::Moore[In, Out]
+  # : [In, Out] (
+  #    alphabet: Array[In],
+  #    ?oracle: oracle_type | Equiv::Oracle[In, Out],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: algorithm_name,
+  #    automaton_type: :moore,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) { (Array[In]) -> Out } -> Automaton::Moore[In, Out]
+  # : [In, Call, Return] (
+  #    alphabet: Array[In],
+  #    call_alphabet: Array[Call],
+  #    return_alphabet: Array[Return],
+  #    sul: Automaton::VPA[In, Call, Return] | System::MooreLikeSUL[In | Call | Return, bool],
+  #    ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: :kearns_vazirani_vpa,
+  #    ?automaton_type: :vpa,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) -> Automaton::VPA[In, Call, Return]
+  # : [In, Call, Return] (
+  #    alphabet: Array[In],
+  #    call_alphabet: Array[Call],
+  #    return_alphabet: Array[Return],
+  #    ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: :kearns_vazirani_vpa,
+  #    ?automaton_type: :vpa,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) { (Array[In | Call | Return]) -> bool } -> Automaton::VPA[In, Call, Return]
+  # : [In, Call, Return] (
+  #    alphabet: Array[In],
+  #    call_alphabet: Array[Call],
+  #    return_input: Return,
+  #    sul: Automaton::SPA[In, Call, Return] | System::MooreLikeSUL[In | Call | Return, bool],
+  #    ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: :procedural,
+  #    ?automaton_type: :spa,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) -> Automaton::SPA[In, Call, Return]
+  # : [In, Call, Return] (
+  #    alphabet: Array[In],
+  #    call_alphabet: Array[Call],
+  #    return_input: Return,
+  #    ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool],
+  #    ?oracle_params: Hash[Symbol, untyped],
+  #    ?algorithm: :procedural,
+  #    ?automaton_type: :spa,
+  #    ?params: Hash[Symbol, untyped],
+  #    ?random: Random
+  #  ) { (Array[In | Call | Return]) -> bool } -> Automaton::SPA[In, Call, Return]
+  def self.learn: [In] (alphabet: Array[In], sul: Automaton::DFA[In] | System::MooreLikeSUL[In, bool], ?oracle: oracle_type | Equiv::Oracle[In, bool], ?oracle_params: Hash[Symbol, untyped], ?algorithm: algorithm_name, ?automaton_type: :dfa, ?params: Hash[Symbol, untyped], ?random: Random) -> Automaton::DFA[In]
+                | [In] (alphabet: Array[In], ?oracle: oracle_type | Equiv::Oracle[In, bool], ?oracle_params: Hash[Symbol, untyped], ?algorithm: algorithm_name, ?automaton_type: :dfa, ?params: Hash[Symbol, untyped], ?random: Random) { (Array[In]) -> bool } -> Automaton::DFA[In]
+                | [In, Out] (alphabet: Array[In], sul: Automaton::Mealy[In, Out] | System::SUL[In, Out], automaton_type: :mealy, ?oracle: oracle_type | Equiv::Oracle[In, Out], ?oracle_params: Hash[Symbol, untyped], ?algorithm: algorithm_name, ?params: Hash[Symbol, untyped], ?random: Random) -> Automaton::Mealy[In, Out]
+                | [In, Out] (alphabet: Array[In], automaton_type: :mealy, ?oracle: oracle_type | Equiv::Oracle[In, Out], ?oracle_params: Hash[Symbol, untyped], ?algorithm: algorithm_name, ?params: Hash[Symbol, untyped], ?random: Random) { (Array[In]) -> Out } -> Automaton::Mealy[In, Out]
+                | [In, Out] (alphabet: Array[In], sul: Automaton::Moore[In, Out] | System::MooreLikeSUL[In, Out], automaton_type: :moore, ?oracle: oracle_type | Equiv::Oracle[In, Out], ?oracle_params: Hash[Symbol, untyped], ?algorithm: algorithm_name, ?params: Hash[Symbol, untyped], ?random: Random) -> Automaton::Moore[In, Out]
+                | [In, Out] (alphabet: Array[In], automaton_type: :moore, ?oracle: oracle_type | Equiv::Oracle[In, Out], ?oracle_params: Hash[Symbol, untyped], ?algorithm: algorithm_name, ?params: Hash[Symbol, untyped], ?random: Random) { (Array[In]) -> Out } -> Automaton::Moore[In, Out]
+                | [In, Call, Return] (alphabet: Array[In], call_alphabet: Array[Call], return_alphabet: Array[Return], sul: Automaton::VPA[In, Call, Return] | System::MooreLikeSUL[In | Call | Return, bool], ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool], ?oracle_params: Hash[Symbol, untyped], ?algorithm: :kearns_vazirani_vpa, ?automaton_type: :vpa, ?params: Hash[Symbol, untyped], ?random: Random) -> Automaton::VPA[In, Call, Return]
+                | [In, Call, Return] (alphabet: Array[In], call_alphabet: Array[Call], return_alphabet: Array[Return], ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool], ?oracle_params: Hash[Symbol, untyped], ?algorithm: :kearns_vazirani_vpa, ?automaton_type: :vpa, ?params: Hash[Symbol, untyped], ?random: Random) { (Array[In | Call | Return]) -> bool } -> Automaton::VPA[In, Call, Return]
+                | [In, Call, Return] (alphabet: Array[In], call_alphabet: Array[Call], return_input: Return, sul: Automaton::SPA[In, Call, Return] | System::MooreLikeSUL[In | Call | Return, bool], ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool], ?oracle_params: Hash[Symbol, untyped], ?algorithm: :procedural, ?automaton_type: :spa, ?params: Hash[Symbol, untyped], ?random: Random) -> Automaton::SPA[In, Call, Return]
+                | [In, Call, Return] (alphabet: Array[In], call_alphabet: Array[Call], return_input: Return, ?oracle: oracle_type | Equiv::Oracle[In | Call | Return, bool], ?oracle_params: Hash[Symbol, untyped], ?algorithm: :procedural, ?automaton_type: :spa, ?params: Hash[Symbol, untyped], ?random: Random) { (Array[In | Call | Return]) -> bool } -> Automaton::SPA[In, Call, Return]
+end

data/sig-test/generated/test/example_test.rbs

@@ -0,0 +1,14 @@
+# Generated from test/example_test.rb with RBS::Inline
+
+class ExampleTest < Minitest::Test
+  EXAMPLES_DIR: String
+
+  # : (*String cmd) -> String
+  def capture: (*String cmd) -> String
+
+  # : () -> void
+  def test_text_example_uri_parse_regexp: () -> void
+
+  # : () -> void
+  def test_text_example_ripper_prism: () -> void
+end

data/sig-test/generated/test/lernen/algorithm/kearns_vazirani_test.rbs

@@ -0,0 +1,16 @@
+# Generated from test/lernen/algorithm/kearns_vazirani_test.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    class KearnsVaziraniTest < Minitest::Test
+      # : () -> void
+      def test_learn_dfa: () -> void
+
+      # : () -> void
+      def test_learn_moore: () -> void
+
+      # : () -> void
+      def test_learn_mealy: () -> void
+    end
+  end
+end

data/sig-test/generated/test/lernen/algorithm/kearns_vazirani_vpa_test.rbs

@@ -0,0 +1,10 @@
+# Generated from test/lernen/algorithm/kearns_vazirani_vpa_test.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    class KearnsVaziraniVPATest < Minitest::Test
+      # : () -> void
+      def test_learn: () -> void
+    end
+  end
+end

data/sig-test/generated/test/lernen/algorithm/lsharp_test.rbs

@@ -0,0 +1,16 @@
+# Generated from test/lernen/algorithm/lsharp_test.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    class LSharpTest < Minitest::Test
+      # : () -> void
+      def test_learn_dfa: () -> void
+
+      # : () -> void
+      def test_learn_moore: () -> void
+
+      # : () -> void
+      def test_learn_mealy: () -> void
+    end
+  end
+end

data/sig-test/generated/test/lernen/algorithm/lstar_test.rbs

@@ -0,0 +1,16 @@
+# Generated from test/lernen/algorithm/lstar_test.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    class LStarTest < Minitest::Test
+      # : () -> void
+      def test_learn_dfa: () -> void
+
+      # : () -> void
+      def test_learn_moore: () -> void
+
+      # : () -> void
+      def test_learn_mealy: () -> void
+    end
+  end
+end

data/sig-test/generated/test/lernen/algorithm/procedural_test.rbs

@@ -0,0 +1,10 @@
+# Generated from test/lernen/algorithm/procedural_test.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    class ProceduralTest < Minitest::Test
+      # : () -> void
+      def test_learn: () -> void
+    end
+  end
+end