lernen 0.2.0 → 0.3.0

data/lib/lernen.rb

@@ -1,79 +1,329 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require "set"
 
-module Lernen
-  # Error is an error class for this library.
-  class Error < StandardError
-  end
-end
-
-require_relative "lernen/automaton"
-require_relative "lernen/cex_processor"
-require_relative "lernen/oracle"
-require_relative "lernen/sul"
-require_relative "lernen/version"
+require "lernen/version"
+require "lernen/graph"
+require "lernen/automaton"
+require "lernen/system"
+require "lernen/equiv"
+require "lernen/algorithm"
 
-require_relative "lernen/lstar"
-require_relative "lernen/kearns_vazirani"
-require_relative "lernen/lsharp"
-
-# Lernen is a simple automata learning library.
+# 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
-  # Learn an automaton.
+  # @rbs!
+  #   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(
     alphabet:,
     call_alphabet: nil,
     return_alphabet: nil,
+    return_input: nil,
     sul: nil,
-    oracle: :random_walk,
+    oracle: nil,
     oracle_params: {},
-    algorithm: :kearns_vazirani,
+    algorithm: nil,
     automaton_type: nil,
     params: {},
     random: Random,
     &sul_block
   )
-    automaton_type ||= call_alphabet ? :vpa : :dfa
+    automaton = nil
 
     case sul
-    when SUL
+    when System::SUL
       # Do nothing
-    when Automaton
-      automaton_type = sul.type
-      sul = SUL.from_automaton(sul)
+    when Automaton::TransitionSystem
+      automaton = sul
+      oracle ||= :simulator
+      automaton_type ||= sul.type
+      sul = System.from_automaton(sul) # steep:ignore
     when nil
-      sul = SUL.from_block(&sul_block)
+      sul = System.from_block(&sul_block) # steep:ignore
     else
       raise ArgumentError, "Unsupported SUL: #{sul}"
     end
 
-    full_alphabet =
+    automaton_type ||=
+      if call_alphabet
+        return_input ? :spa : :vpa
+      else
+        :dfa
+      end
+
+    merged_alphabet =
       case automaton_type
       in :dfa | :moore | :mealy
         alphabet
-      in :vpa
+      in :vpa | :spa
+        return_alphabet ||= [return_input]
         alphabet + call_alphabet + return_alphabet
       end
 
+    oracle ||= %i[vpa spa].include?(automaton_type) ? :random_well_matched_word : :random_word
+
     case oracle
-    when Oracle
+    when Equiv::Oracle
       # Do nothing
-    when :breadth_first_exploration
-      oracle = BreadthFirstExplorationOracle.new(full_alphabet, sul, **oracle_params)
+    when :exhaustive_search
+      oracle = Equiv::ExhaustiveSearchOracle.new(merged_alphabet, sul, **oracle_params)
     when :random_walk
-      oracle = RandomWalkOracle.new(full_alphabet, sul, random:, **oracle_params)
+      oracle = Equiv::RandomWalkOracle.new(merged_alphabet, sul, random:, **oracle_params)
+    when :random_word
+      oracle = Equiv::RandomWordOracle.new(merged_alphabet, sul, random:, **oracle_params)
+    when :random_well_matched_word
+      oracle =
+        Equiv::RandomWellMatchedWordOracle.new(
+          alphabet,
+          call_alphabet, # steep:ignore
+          return_alphabet, # steep:ignore
+          sul,
+          random:,
+          **oracle_params
+        )
+    when :simulator
+      oracle =
+        case automaton
+        when Automaton::Mealy
+          Equiv::TransitionSystemSimulatorOracle.new(alphabet, automaton, sul)
+        when Automaton::DFA, Automaton::Moore
+          Equiv::MooreLikeSimulatorOracle.new(alphabet, automaton, sul)
+        when Automaton::VPA
+          Equiv::VPASimulatorOracle.new(alphabet, call_alphabet, return_alphabet, automaton, sul) # steep:ignore
+        when Automaton::SPA
+          Equiv::SPASimulatorOracle.new(alphabet, call_alphabet, automaton, sul) # steep:ignore
+        else
+          raise ArgumentError, "Cannot simulate automaton: #{automaton}"
+        end
     else
       raise ArgumentError, "Unsupported oracle: #{oracle}"
     end
 
+    algorithm ||=
+      case automaton_type
+      in :dfa | :moore | :mealy
+        :kearns_vazirani
+      in :vpa
+        :kearns_vazirani_vpa
+      in :spa
+        :procedural
+      end
+
     case algorithm
     in :lstar
-      LStar.learn(alphabet, sul, oracle, automaton_type:, **params)
+      Algorithm::LStar.learn(alphabet, sul, oracle, automaton_type:, **params)
     in :kearns_vazirani
-      KearnsVazirani.learn(alphabet, sul, oracle, automaton_type:, call_alphabet:, return_alphabet:, **params)
+      Algorithm::KearnsVazirani.learn(alphabet, sul, oracle, automaton_type:, **params)
+    in :kearns_vazirani_vpa
+      Algorithm::KearnsVaziraniVPA.learn(alphabet, call_alphabet, return_alphabet, sul, oracle, **params)
     in :lsharp
-      LSharp.learn(alphabet, sul, oracle, automaton_type:, **params)
+      Algorithm::LSharp.learn(alphabet, sul, oracle, automaton_type:, **params)
+    in :procedural
+      Algorithm::Procedural.learn(alphabet, call_alphabet, return_input, sul, oracle, **params)
     end
   end
 end

data/rbs_collection.lock.yaml

@@ -0,0 +1,16 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: prism
+  version: 1.0.0
+  source:
+    type: rubygems
+- name: simplecov
+  version: '0.22'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 4f55d83688a772342f0d96966cd51d06af03c2c8
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,14 @@
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+path: .gem_rbs_collection
+
+gems:
+  - name: prism
+    ignore: false
+  - name: simplecov
+    ignore: false

data/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

data/sig/generated/lernen/algorithm/cex_processor/acex.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/lernen/algorithm/cex_processor/acex.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module CexProcessor
+      # Acex represents an abstract counterexample.
+      #
+      # Note that this class is *abstract*. We should implement the following method:
+      #
+      # - `#compute_effect(index)`
+      class Acex
+        @cache: Array[bool | nil]
+
+        # : (Integer size) -> void
+        def initialize: (Integer size) -> void
+
+        # : () -> Integer
+        def size: () -> Integer
+
+        # : (Integer index) -> bool
+        def effect: (Integer index) -> bool
+
+        private
+
+        # : (Integer index) -> bool
+        def compute_effect: (Integer index) -> bool
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/cex_processor/prefix_transformer_acex.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/lernen/algorithm/cex_processor/prefix_transformer_acex.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module CexProcessor
+      # PrefixTransformerAcex is an implementation of `Acex` for classic prefix transformers.
+      #
+      # @rbs generic Conf
+      # @rbs generic In
+      # @rbs generic Out
+      class PrefixTransformerAcex[Conf, In, Out] < Acex
+        # : (
+        #     Array[In] cex,
+        #     System::SUL[In, Out] sul,
+        #     Automaton::TransitionSystem[Conf, In, Out] hypothesis,
+        #     ^(Conf) -> Array[In] conf_to_prefix
+        #   ) -> void
+        def initialize: (Array[In] cex, System::SUL[In, Out] sul, Automaton::TransitionSystem[Conf, In, Out] hypothesis, ^(Conf) -> Array[In] conf_to_prefix) -> void
+
+        private
+
+        # @rbs override
+        def compute_effect: ...
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/cex_processor.rbs

@@ -0,0 +1,59 @@
+# Generated from lib/lernen/algorithm/cex_processor.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    type cex_processing_method = :linear | :binary | :exponential
+
+    # CexProcessor contains implementations of counterexample processing functions.
+    #
+    # A counterexample is a word that leads to the different result between
+    # a hypothesis automaton and a SUL (i.e., `hypothesis.run(cex)[0].last != sul.query_last(cex)`).
+    # Where `h[n] = conf_to_prefix[hypothesis.run(cex[0...n])[1]]`, there
+    # are some `n` (where `0 <= n < cex.size`) such that
+    # `sul.query_last(h[n] + cex[n...]) != sul.query_last(h[n + 1] + cex[n + 1...])`
+    # because `sul.query_last(cex) == sul.query_last(h[0] + cex[n...])` and
+    # `sul.query_last(h[cex.size] + cex[cex.size...]) == hypothesis.run(cex)[0].last`.
+    # Finding such a position `n` from `cex` is called "counterexample processing".
+    #
+    # The result `n` of counterexample processing has a good property for automata
+    # learning. Because `sul.query_last(h[n] + cex[n...]) != sul.query_last(h[n + 1] + cex[n + 1...])`,
+    # a prefix `h[n] + cex[n]` leads a different state than a state of `h[n + 1]`
+    # with a suffix `cex[n + 1...]`.
+    #
+    # For counterexample processing, we can use some searching approach such like
+    # linear or binrary search. Using binary search for counterexample processing,
+    # it is known as the Rivest-Schapire (RS) optimization typically. For the more
+    # detailed information, please refer [Isberner and Steffen (2014) "An Abstract
+    # Framework for Counterexample Analysis in Active Automata Learning"](https://proceedings.mlr.press/v34/isberner14a).
+    module CexProcessor
+      # Processes a given counterexample in the `cex_processing` way.
+      #
+      # It returns `n` such that `acex.effect(n) != acex.effect(n + 1)`.
+      #
+      # : (
+      #    Acex acex,
+      #    ?cex_processing: cex_processing_method
+      #  ) -> Integer
+      def self.process: (Acex acex, ?cex_processing: cex_processing_method) -> Integer
+
+      private
+
+      # Processes a given counterexample by linear search.
+      #
+      # : (Acex acex, low: Integer, high: Integer) -> Integer
+      def self.process_linear: (Acex acex, low: Integer, high: Integer) -> Integer
+
+      # Processes a given counterexample by binary search.
+      #
+      # It is known as the Rivest-Schapire (RS) optimization.
+      #
+      # : (Acex acex, low: Integer, high: Integer) -> Integer
+      def self.process_binary: (Acex acex, low: Integer, high: Integer) -> Integer
+
+      # Processes a given counterexample by exponential seatch.
+      #
+      # : (Acex acex, low: Integer, high: Integer) -> Integer
+      def self.process_exponential: (Acex acex, low: Integer, high: Integer) -> Integer
+    end
+  end
+end

data/sig/generated/lernen/algorithm/kearns_vazirani/discrimination_tree.rbs

@@ -0,0 +1,68 @@
+# Generated from lib/lernen/algorithm/kearns_vazirani/discrimination_tree.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module KearnsVazirani
+      # DiscriminationTree is an implementation of discrimination tree data structure.
+      #
+      # This data structure is used for Kearns-Vazirani algorithm.
+      #
+      # @rbs generic In  -- Type for input alphabet
+      # @rbs generic Out -- Type for output values
+      class DiscriminationTree[In, Out]
+        type tree[In, Out] = Node[In, Out] | Leaf[In]
+
+        class Node[In, Out] < Data
+          attr_reader suffix: Array[In]
+          attr_reader branch: Hash[Out, tree[In, Out]]
+          def self.[]: [In, Out] (Array[In] suffix, Hash[Out, tree[In, Out]] branch) -> Node[In, Out]
+        end
+
+        class Leaf[In] < Data
+          attr_reader prefix: Array[In]
+          def self.[]: [In] (Array[In] prefix) -> Leaf[In]
+        end
+
+        @alphabet: Array[In]
+
+        @sul: System::SUL[In, Out]
+
+        @automaton_type: :dfa | :mealy | :moore
+
+        @cex_processing: cex_processing_method
+
+        @path_hash: Hash[Array[In], Array[Out]]
+
+        @root: Node[In, Out]
+
+        # : (
+        #     Array[In] alphabet,
+        #     System::SUL[In, Out] sul,
+        #     cex: Array[In],
+        #     automaton_type: :dfa | :mealy | :moore,
+        #     cex_processing: cex_processing_method
+        #   ) -> void
+        def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, cex: Array[In], automaton_type: :dfa | :mealy | :moore, cex_processing: cex_processing_method) -> void
+
+        # Returns a prefix discriminated by `word`.
+        #
+        # : (Array[In] word) -> Array[In]
+        def sift: (Array[In] word) -> Array[In]
+
+        # Constructs a hypothesis automaton from this discrimination tree.
+        #
+        # : () -> [Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]]]
+        def build_hypothesis: () -> [ Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]] ]
+
+        # Update this classification tree by the given `cex`.
+        #
+        # : (
+        #    Array[In] cex,
+        #    Automaton::TransitionSystem[Integer, In, Out] hypothesis,
+        #    Hash[Integer, Array[In]] state_to_prefix
+        #  ) -> void
+        def refine_hypothesis: (Array[In] cex, Automaton::TransitionSystem[Integer, In, Out] hypothesis, Hash[Integer, Array[In]] state_to_prefix) -> void
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/kearns_vazirani/kearns_vazirani_learner.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/lernen/algorithm/kearns_vazirani/kearns_vazirani_learner.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module KearnsVazirani
+      # KearnzVaziraniLearner is an implementation of Kearnz-Vazirani algorithm.
+      #
+      # Kearns-Vazirani is introduced by [Kearns & Vazirani (1994) "An Introduction to
+      # Computational Learning Theory"](https://direct.mit.edu/books/monograph/2604/An-Introduction-to-Computational-Learning-Theory).
+      #
+      # @rbs generic In  -- Type for input alphabet
+      # @rbs generic Out -- Type for output values
+      class KearnsVaziraniLearner[In, Out] < Learner[In, Out]
+        @alphabet: Array[In]
+
+        @sul: System::SUL[In, Out]
+
+        @oracle: Equiv::Oracle[In, Out]
+
+        @automaton_type: :dfa | :moore | :mealy
+
+        @cex_processing: cex_processing_method
+
+        @tree: DiscriminationTree[In, Out] | nil
+
+        # : (
+        #     Array[In] alphabet, System::SUL[In, Out] sul,
+        #     automaton_type: :dfa | :moore | :mealy,
+        #     ?cex_processing: cex_processing_method
+        #   ) -> void
+        def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, automaton_type: :dfa | :moore | :mealy, ?cex_processing: cex_processing_method) -> void
+
+        # @rbs override
+        def add_alphabet: ...
+
+        # @rbs override
+        def build_hypothesis: ...
+
+        # @rbs override
+        def refine_hypothesis: ...
+
+        private
+
+        # Constructs the first hypothesis automaton.
+        #
+        # : () -> Automaton::TransitionSystem[Integer, In, Out]
+        def build_first_hypothesis: () -> Automaton::TransitionSystem[Integer, In, Out]
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/kearns_vazirani.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/lernen/algorithm/kearns_vazirani.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    # KearnzVazirani provides an implementation of Kearnz-Vazirani algorithm.
+    #
+    # Kearns-Vazirani is introduced by [Kearns & Vazirani (1994) "An Introduction to
+    # Computational Learning Theory"](https://direct.mit.edu/books/monograph/2604/An-Introduction-to-Computational-Learning-Theory).
+    module KearnsVazirani
+      # Runs Kearns-Vazirani algorithm and returns an inferred automaton.
+      #
+      # : [In] (
+      #    Array[In] alphabet, System::SUL[In, bool] sul, Equiv::Oracle[In, bool] oracle,
+      #    automaton_type: :dfa,
+      #    ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::DFA[In]
+      # : [In, Out] (
+      #    Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle,
+      #    automaton_type: :mealy,
+      #    ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::Mealy[In, Out]
+      # : [In, Out] (
+      #    Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle,
+      #    automaton_type: :moore,
+      #    ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::Moore[In, Out]
+      def self.learn: [In] (Array[In] alphabet, System::SUL[In, bool] sul, Equiv::Oracle[In, bool] oracle, automaton_type: :dfa, ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil) -> Automaton::DFA[In]
+                    | [In, Out] (Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle, automaton_type: :mealy, ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil) -> Automaton::Mealy[In, Out]
+                    | [In, Out] (Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle, automaton_type: :moore, ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil) -> Automaton::Moore[In, Out]
+    end
+  end
+end