lernen 0.1.0 → 0.3.0

data/examples/ripper_prism.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "lernen"
+require "prism"
+require "ripper"
+
+shows_mermaid_diagram = false
+
+# For reproducibility, we use a PRNG with a fixed seed.
+seed = 41
+random = Random.new(seed)
+
+# `alphabet`, `call_alphabet`, and `return_alphabet` are arrays of pieces of words.
+# The `alphabet` characters cause neither push nor pop,
+# the `call_alphabet` characters cause push onto a stack, and
+# the `return_alphabet` characters cause pop onto a stack.
+alphabet = %w["a" :] # rubocop:disable Lint/PercentStringArray
+call_alphabet = %w[(]
+return_alphabet = %w[)]
+
+# `oracle` specifies a kind of an equivalence oracle using on learning,
+# and `oracle_params` is a paremeter object to it.
+oracle = :random_well_matched_word
+oracle_params = { max_words: 2000 }.freeze
+
+# When `call_alphabet` and `return_alphabet` are specified to `Lernen.learn`,
+# it infers a VPA instead of a automaton.
+
+# Ripper VPA:
+puts "Infer Ripper VPA..."
+ripper_vpa = Lernen.learn(alphabet:, call_alphabet:, return_alphabet:, oracle:, oracle_params:, random:) do |word|
+  !Ripper.sexp(word.join).nil?
+end
+
+# Prism VPA:
+puts "Infer Prism VPA..."
+prism_vpa = Lernen.learn(alphabet:, call_alphabet:, return_alphabet:, oracle:, oracle_params:, random:) do |word|
+  Prism.parse(word.join).success?
+end
+
+if shows_mermaid_diagram
+  puts
+  puts "=== Ripper VPA... ==="
+  puts ripper_vpa.to_mermaid
+  puts "====================="
+  puts
+  puts "=== Prism VPA... ===="
+  puts prism_vpa.to_mermaid
+  puts "======================"
+  puts
+end
+
+puts "Check equivalence between Prism and Ripper VPAs..."
+sep_word = Lernen::Automaton::VPA.find_separating_word(alphabet, call_alphabet, return_alphabet, ripper_vpa, prism_vpa)
+
+if sep_word
+  sep_str = sep_word.join
+  puts "#{sep_str.inspect} is the separating word between Prism and Ripper VPAs."
+  puts "  !Ripper.parse(#{sep_str.inspect}).nil? = #{!Ripper.parse(sep_str).nil?}"
+  puts "Prism.parse(#{sep_str.inspect}).success? = #{Prism.parse(sep_str).success?}"
+else
+  puts "No separating word is found, so two VPAs are equivalent."
+end

data/examples/uri_parse_regexp.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "lernen"
+require "uri"
+
+shows_mermaid_diagram = false
+
+# Define validations using `URI.parse` and `URI` regexp.
+
+def valid_and_http_url?(string)
+  uri = URI.parse(string)
+  uri.scheme == "http" || uri.scheme == "https"
+rescue URI::Error
+  false
+end
+
+VALID_AND_HTTP_URL_REGEXP = /\A#{URI::DEFAULT_PARSER.make_regexp(%w[http https])}\z/
+def new_valid_and_http_url?(string)
+  string.match?(VALID_AND_HTTP_URL_REGEXP)
+end
+
+# For reproducibility, we use a PRNG with a fixed seed.
+seed = 41
+random = Random.new(seed)
+
+# `alphabet` is an array of pieces of words.
+# Learning algorithm infers an automaton on this alphabet, so in this case,
+# we specify some possible subwords in URLs to `alphabet`.
+alphabet = %w[http https ftp example com foo 80 12 : / . ? = & # @ %]
+
+# `oracle` specifies a kind of an equivalence oracle using on learning,
+# and `oracle_params` is a paremeter object to it.
+oracle = :random_word
+oracle_params = { max_words: 2000 }.freeze
+
+# Infer a automaton by calling the `Lernen.learn` method with the target program.
+
+# `URI.parse` DFA:
+puts "Infer `URI.parse` DFA..."
+uri_parse_dfa = Lernen.learn(alphabet:, oracle:, oracle_params:, random:) do |word|
+  # `word.join` is necessary because `word` is an array of `alphabet` elements.
+  valid_and_http_url?(word.join)
+end
+
+# `URI` regexp DFA:
+puts "Infer `URI` regexp DFA..."
+uri_regexp_dfa = Lernen.learn(alphabet:, oracle:, oracle_params:, random:) do |word|
+  new_valid_and_http_url?(word.join)
+end
+
+if shows_mermaid_diagram
+  puts
+  puts "=== `URI.parse` DFA... ===="
+  puts uri_parse_dfa.to_mermaid
+  puts "==========================="
+  puts
+  puts "=== `URI` regexp DFA... ==="
+  puts uri_regexp_dfa.to_mermaid
+  puts "=========================="
+  puts
+end
+
+puts "Check equivalence between `URI.parse` and `URI` regexp DFAs..."
+sep_word = Lernen::Automaton::DFA.find_separating_word(alphabet, uri_parse_dfa, uri_regexp_dfa)
+
+if sep_word
+  sep_str = sep_word.join
+  puts "#{sep_str.inspect} is the separating word between `URI.parse` and `URI` regexp DFAs."
+  puts "    valid_and_http_url?(#{sep_str.inspect}) = #{valid_and_http_url?(sep_str)}"
+  puts "new_valid_and_http_url?(#{sep_str.inspect}) = #{new_valid_and_http_url?(sep_str)}"
+else
+  puts "No separating word is found, so two DFAs are equivalent."
+end

data/lib/lernen/algorithm/cex_processor/acex.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+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
+        # @rbs @cache: Array[bool | nil]
+
+        #: (Integer size) -> void
+        def initialize(size)
+          @cache = Array.new(size)
+        end
+
+        #: () -> Integer
+        def size = @cache.size
+
+        #: (Integer index) -> bool
+        def effect(index)
+          eff = @cache[index]
+          eff = @cache[index] = compute_effect(index) if eff.nil?
+          eff
+        end
+
+        private
+
+        # rubocop:disable Lint/UnusedMethodArgument
+
+        #: (Integer index) -> bool
+        def compute_effect(index)
+          raise TypeError, "abstract method: `compute_effect`"
+        end
+
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/lernen/algorithm/cex_processor/prefix_transformer_acex.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+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 < Acex
+        #: (
+        #    Array[In] cex,
+        #    System::SUL[In, Out] sul,
+        #    Automaton::TransitionSystem[Conf, In, Out] hypothesis,
+        #    ^(Conf) -> Array[In] conf_to_prefix
+        #  ) -> void
+        def initialize(cex, sul, hypothesis, conf_to_prefix)
+          super(cex.size)
+
+          @cex = cex
+          @sul = sul
+          @hypothesis = hypothesis
+          @conf_to_prefix = conf_to_prefix
+
+          @hypothesis_output = @hypothesis.run(cex)[0].last
+        end
+
+        private
+
+        # @rbs override
+        def compute_effect(index)
+          prefix = @cex[0...index]
+          suffix = @cex[index...]
+
+          _, prefix_conf = @hypothesis.run(prefix)
+          @sul.query_last(@conf_to_prefix.call(prefix_conf) + suffix) == @hypothesis_output
+        end
+      end
+    end
+  end
+end

data/lib/lernen/algorithm/cex_processor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "lernen/algorithm/cex_processor/acex"
+require "lernen/algorithm/cex_processor/prefix_transformer_acex"
+
+module Lernen
+  module Algorithm
+    # @rbs!
+    #   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, cex_processing: :binary)
+        low = 0
+        high = acex.size - 1
+        case cex_processing
+        in :linear
+          process_linear(acex, low:, high:)
+        in :binary
+          process_binary(acex, low:, high:)
+        in :exponential
+          process_exponential(acex, low:, high:)
+        end
+      end
+
+      private
+
+      # Processes a given counterexample by linear search.
+      #
+      #: (Acex acex, low: Integer, high: Integer) -> Integer
+      def self.process_linear(acex, low:, high:)
+        prev_eff = acex.effect(low)
+        index = low + 1
+        while index <= high
+          eff = acex.effect(index)
+          return index - 1 if prev_eff != eff
+          index += 1
+          prev_eff = eff
+        end
+
+        raise ArgumentError
+      end
+
+      # 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, low:, high:)
+        low_eff = acex.effect(low)
+
+        while high - low > 1
+          mid = low + ((high - low) / 2)
+          mid_eff = acex.effect(mid)
+          if low_eff == mid_eff
+            low = mid
+          else
+            high = mid
+          end
+        end
+
+        low
+      end
+
+      # Processes a given counterexample by exponential seatch.
+      #
+      #: (Acex acex, low: Integer, high: Integer) -> Integer
+      def self.process_exponential(acex, low:, high:)
+        ofs = 1
+        low_eff = acex.effect(low)
+
+        while low + ofs < high
+          index = low + ofs
+          eff = acex.effect(index)
+          break if low_eff != eff
+          low = index
+          ofs *= 2
+        end
+
+        process_binary(acex, low:, high:)
+      end
+
+      private_class_method :process_linear, :process_binary, :process_exponential
+    end
+  end
+end

data/lib/lernen/algorithm/kearns_vazirani/discrimination_tree.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+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
+        # @rbs skip
+        Node = Data.define(:suffix, :branch)
+        # @rbs skip
+        Leaf = Data.define(:prefix)
+
+        # @rbs!
+        #   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
+
+        # @rbs @alphabet: Array[In]
+        # @rbs @sul: System::SUL[In, Out]
+        # @rbs @automaton_type: :dfa | :mealy | :moore
+        # @rbs @cex_processing: cex_processing_method
+        # @rbs @path_hash: Hash[Array[In], Array[Out]]
+        # @rbs @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(alphabet, sul, cex:, automaton_type:, cex_processing:)
+          @alphabet = alphabet
+          @sul = sul
+          @automaton_type = automaton_type
+          @cex_processing = cex_processing
+
+          @path_hash = {}
+
+          case @automaton_type
+          in :dfa | :moore
+            @root = Node[[], {}]
+
+            empty_out = sul.query_empty
+            @root.branch[empty_out] = Leaf[[]]
+            @path_hash[[]] = [empty_out]
+
+            cex_out = sul.query_last(cex)
+            @root.branch[cex_out] = Leaf[cex]
+            @path_hash[cex] = [cex_out]
+          in :mealy
+            prefix = cex[0...-1]
+            suffix = [cex.last]
+            @root = Node[suffix, {}]
+
+            suffix_out = sul.query_last(suffix)
+            @root.branch[suffix_out] = Leaf[[]]
+            @path_hash[[]] = [suffix_out]
+
+            cex_out = sul.query_last(cex)
+            @root.branch[cex_out] = Leaf[prefix]
+            @path_hash[prefix] = [cex_out]
+          end
+        end
+
+        # Returns a prefix discriminated by `word`.
+        #
+        #: (Array[In] word) -> Array[In]
+        def sift(word)
+          node = @root
+          path = []
+
+          until node.is_a?(Leaf)
+            full_word = word + node.suffix
+
+            out = @sul.query_last(full_word)
+            path << out
+
+            unless node.branch.include?(out)
+              node.branch[out] = Leaf[word]
+              @path_hash[word] = path
+            end
+
+            node = node.branch[out] # steep:ignore
+          end
+
+          node.prefix # steep:ignore
+        end
+
+        # Constructs a hypothesis automaton from this discrimination tree.
+        #
+        #: () -> [Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]]]
+        def build_hypothesis
+          transition_function = {}
+
+          queue = []
+          prefix_to_state = {}
+          state_to_prefix = {}
+
+          queue << []
+          prefix_to_state[[]] = prefix_to_state.size
+          state_to_prefix[state_to_prefix.size] = []
+
+          until queue.empty?
+            prefix = queue.shift
+            state = prefix_to_state[prefix]
+            @alphabet.each do |input|
+              word = prefix + [input]
+              next_prefix = sift(word)
+
+              unless prefix_to_state.include?(next_prefix)
+                queue << next_prefix
+                prefix_to_state[next_prefix] = prefix_to_state.size
+                state_to_prefix[state_to_prefix.size] = next_prefix
+              end
+
+              next_state = prefix_to_state[next_prefix]
+              case @automaton_type
+              in :dfa | :moore
+                transition_function[[state, input]] = next_state
+              in :mealy
+                output = @sul.query_last(word)
+                transition_function[[state, input]] = [output, next_state]
+              end
+            end
+          end
+
+          automaton =
+            case @automaton_type
+            in :dfa
+              accept_states =
+                state_to_prefix.to_a.filter { |(_, prefix)| @path_hash[prefix][0] }.to_set { |(state, _)| state }
+              Automaton::DFA.new(0, accept_states, transition_function)
+            in :moore
+              outputs = state_to_prefix.transform_values { |prefix| @path_hash[prefix][0] }
+              Automaton::Moore.new(0, outputs, transition_function)
+            in :mealy
+              Automaton::Mealy.new(0, transition_function)
+            end
+
+          [automaton, state_to_prefix]
+        end
+
+        # 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(cex, hypothesis, state_to_prefix)
+          state_to_prefix_lambda = ->(state) { state_to_prefix[state] }
+          acex = CexProcessor::PrefixTransformerAcex.new(cex, @sul, hypothesis, state_to_prefix_lambda)
+
+          n = CexProcessor.process(acex, cex_processing: @cex_processing)
+          old_prefix = cex[0...n]
+          new_input = cex[n]
+          new_suffix = cex[n + 1...]
+
+          _, old_state = hypothesis.run(old_prefix) # steep:ignore
+          _, replace_state = hypothesis.step(old_state, new_input)
+
+          new_prefix = state_to_prefix[old_state] + [new_input]
+          new_out = @sul.query_last(new_prefix + new_suffix) # steep:ignore
+
+          replace_prefix = state_to_prefix[replace_state]
+          replace_out = @sul.query_last(replace_prefix + new_suffix) # steep:ignore
+
+          replace_node_path = @path_hash[replace_prefix]
+          replace_node_parent = @root
+          replace_node = @root.branch[replace_node_path.first] # steep:ignore
+          replace_node_path[1..].each do |out| # steep:ignore
+            replace_node_parent = replace_node
+            replace_node = replace_node.branch[out] # steep:ignore
+          end
+
+          new_node = Node[new_suffix, {}] # steep:ignore
+          replace_node_parent.branch[replace_node_path.last] = new_node # steep:ignore
+
+          new_node.branch[new_out] = Leaf[new_prefix]
+          @path_hash[new_prefix] = replace_node_path + [new_out] # steep:ignore
+
+          new_node.branch[replace_out] = Leaf[replace_prefix]
+          @path_hash[replace_prefix] = replace_node_path + [replace_out] # steep:ignore
+        end
+      end
+    end
+  end
+end

data/lib/lernen/algorithm/kearns_vazirani/kearns_vazirani_learner.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+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 < Learner #[In, Out]
+        # @rbs @alphabet: Array[In]
+        # @rbs @sul: System::SUL[In, Out]
+        # @rbs @oracle: Equiv::Oracle[In, Out]
+        # @rbs @automaton_type: :dfa | :moore | :mealy
+        # @rbs @cex_processing: cex_processing_method
+        # @rbs @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(alphabet, sul, automaton_type:, cex_processing: :binary)
+          super()
+
+          @alphabet = alphabet.dup
+          @sul = sul
+          @automaton_type = automaton_type
+          @cex_processing = cex_processing
+
+          @tree = nil
+        end
+
+        # @rbs override
+        def add_alphabet(input)
+          @alphabet << input
+        end
+
+        # @rbs override
+        def build_hypothesis
+          tree = @tree
+          return tree.build_hypothesis if tree
+
+          [build_first_hypothesis, { 0 => [] }]
+        end
+
+        # @rbs override
+        def refine_hypothesis(cex, hypothesis, state_to_prefix)
+          tree = @tree
+          if tree
+            tree.refine_hypothesis(cex, hypothesis, state_to_prefix)
+            return
+          end
+
+          @tree =
+            DiscriminationTree.new(
+              @alphabet,
+              @sul,
+              cex:,
+              automaton_type: @automaton_type,
+              cex_processing: @cex_processing
+            )
+        end
+
+        private
+
+        # Constructs the first hypothesis automaton.
+        #
+        #: () -> Automaton::TransitionSystem[Integer, In, Out]
+        def build_first_hypothesis
+          transition_function = {}
+          @alphabet.each do |input|
+            case @automaton_type
+            in :dfa | :moore
+              transition_function[[0, input]] = 0
+            in :mealy
+              out = @sul.query_last([input])
+              transition_function[[0, input]] = [out, 0]
+            end
+          end
+
+          case @automaton_type
+          in :dfa
+            accept_state_set = @sul.query_empty ? Set[0] : Set.new
+            Automaton::DFA.new(0, accept_state_set, transition_function)
+          in :moore
+            output_function = { 0 => @sul.query_empty }
+            Automaton::Moore.new(0, output_function, transition_function)
+          in :mealy
+            Automaton::Mealy.new(0, transition_function)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lernen/algorithm/kearns_vazirani.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "lernen/algorithm/kearns_vazirani/discrimination_tree"
+require "lernen/algorithm/kearns_vazirani/kearns_vazirani_learner"
+
+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( # steep:ignore
+        alphabet,
+        sul,
+        oracle,
+        automaton_type:,
+        cex_processing: :binary,
+        max_learning_rounds: nil
+      )
+        learner = KearnsVaziraniLearner.new(alphabet, sul, automaton_type:, cex_processing:)
+        learner.learn(oracle, max_learning_rounds:)
+      end
+    end
+  end
+end