lernen 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c925ae55bb57b20dc2ef637e751882ec493d565b7f0b7a8348c858593ef0d5f4
-  data.tar.gz: dbfae4d012e582aeb909460eea27c30945a62e6586cd8ae7f9be48ac2c6dac6c
+  metadata.gz: f98907d83d61890848e0425254b717d3c080ea4a9b596fc6d015bc03b6de71fa
+  data.tar.gz: a6231a390522b67f4da4290ce385b043043e172d7045f13ede5398f8dff6131c
 SHA512:
-  metadata.gz: c0621a919ee2cebdc932f9aec31aac52ca7cfc528cd8f8f24ff4519e2d39769c4a6c2c5f9eeecad1394339afbe1625a89fb3acb418aa02e452eef2b78eb2a111
-  data.tar.gz: e88d2feb2c44e766e348c62c05ea15cc5eddcb816077e33db40071957047f31b7eccfeb2f9d8b1679c1907f6a57e116042dac009180b5cef2a4453da1c05f7d1
+  metadata.gz: 3d6fbeb6eb3f8e05d34d229201e02304418d182e3804ac33269d00d8c515497906ca7f815711a0efce29a1aaae673b3d80ef4d018e9b7abcb60e44c25d66f366
+  data.tar.gz: 8f92777c0fce29e40b1cca5158c7b7bf911eca481ad00084fe1e22b6615c51492f5edd66dfdfb1a823d5ff8a79898d50246ced7dacfb177b688ad2ca77aed56c

data/.rubocop.yml

@@ -32,3 +32,6 @@ Metrics/ParameterLists:
 
 Metrics/PerceivedComplexity:
   Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false

data/README.md

@@ -1,42 +1,59 @@
 # Lernen
 
-> a simple automata learning library.
+> a simple automata learning library written in Ruby.
 
 ## Usage
 
 ```ruby
 require "lernen"
 
-alphabet = %w[0 1]
-sul = Lernen::SUL.from_block { |inputs| inputs.count { _1 == "1" } % 4 == 3 }
-oracle = Lernen::BreadthFirstExplorationOracle.new(alphabet, sul)
-
-dfa = Lernen::LStar.learn(alphabet, sul, oracle, automaton_type: :dfa)
-# => Lernen::DFA.new(
-#      0,
-#      Set[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
-#      }
-#    )
+automaton = Lernen.learn(alphabet: %w[0 1]) do |inputs|
+  inputs.count("0") % 4 == 3
+end
+
+puts automaton.to_mermaid
+# => flowchart TD
+#      0((0))
+#      1((1))
+#      2((2))
+#      3(((3)))
+#    
+#      0 -- 0 --> 1
+#      0 -- 1 --> 0
+#      1 -- 0 --> 2
+#      1 -- 1 --> 1
+#      2 -- 0 --> 3
+#      2 -- 1 --> 2
+#      3 -- 0 --> 0
+#      3 -- 1 --> 3
+```
+
+```mermaid
+flowchart TD
+  0((0))
+  1((1))
+  2((2))
+  3(((3)))
+
+  0 -- 0 --> 1
+  0 -- 1 --> 0
+  1 -- 0 --> 2
+  1 -- 1 --> 1
+  2 -- 0 --> 3
+  2 -- 1 --> 2
+  3 -- 0 --> 0
+  3 -- 1 --> 3
 ```
 
 ## Algorithms
 
 Learnen supports these automata learning algorithms.
 
-| Algorithm        | Supported `automaton_type` |
-|:----------------:|:--------------------------:|
-| `LStar`          | `:dfa`, `:moore`, `:mealy` |
-| `KearnsVazirani` | `:dfa`, `:moore`, `:mealy` |
-| `LSharp`         | `:dfa`, `:moore`, `:mealy` |
+| Algorithm        | Supported `automaton_type`         |
+|:----------------:|:----------------------------------:|
+| `LStar`          | `:dfa`, `:moore`, `:mealy`         |
+| `KearnsVazirani` | `:dfa`, `:moore`, `:mealy`, `:vpa` |
+| `LSharp`         | `:dfa`, `:moore`, `:mealy`         |
 
 ## License
 

data/Rakefile

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "minitest/test_task"
 require "yard"
+require "rake/testtask"
 require "rubocop/rake_task"
 require "syntax_tree/rake_tasks"
 
-Minitest::TestTask.create
+Rake::TestTask.new(:test) do |t|
+  t.verbose = true
+  t.pattern = "test/**/*_test.rb"
+end
 
 YARD::Rake::YardocTask.new do |t|
   t.files = ["lib/**/*.rb"]

data/lib/lernen/automaton.rb

@@ -5,6 +5,8 @@ module Lernen
   #
   # Note that this class is *abstract*. You should implement the following method:
   #
+  # - `#type`
+  # - `#initial`
   # - `#step(state, input)`
   class Automaton
     # Computes a transition for the given `input` from the current `state`.
@@ -17,7 +19,7 @@ module Lernen
     # Runs this automaton with the given input string and returns an output sequence
     # and a state after running.
     def run(inputs)
-      state = @initial_state
+      state = initial
       outputs = []
       inputs.each do |input|
         output, state = step(state, input)
@@ -25,6 +27,40 @@ module Lernen
       end
       [outputs, state]
     end
+
+    # Checks equivalence between `self` and `other` on the given `alphabet`.
+    #
+    # It returns `nil` if they are equivalence, or it returns a counterexample string.
+    def check_equivalence(alphabet, other)
+      raise ArgumentError, "Cannot check equivalence between different automata" unless instance_of?(other.class)
+
+      case self
+      when DFA
+        return [] unless accept_states.include?(initial_state) == other.accept_states.include?(other.initial_state)
+      when Moore
+        return [] unless outputs[initial_state] == other.outputs[other.initial_state]
+      end
+
+      queue = []
+      visited = Set.new
+      queue << [[], initial, other.initial]
+      visited << [initial, other.initial]
+      until queue.empty?
+        path, self_state, other_state = queue.shift
+        alphabet.each do |input|
+          self_output, self_next_state = step(self_state, input)
+          other_output, other_next_state = other.step(other_state, input)
+          return path + [input] if self_output != other_output
+          next_pair = [self_next_state, other_next_state]
+          unless visited.include?(next_pair)
+            queue << [path + [input], *next_pair]
+            visited << next_pair
+          end
+        end
+      end
+
+      nil
+    end
   end
 
   # DFA is a deterministic finite-state automaton.
@@ -38,6 +74,12 @@ module Lernen
     end
 
     attr_reader :initial_state, :accept_states, :transitions
+    alias initial initial_state
+
+    # Returns the type of this automaton.
+    def type
+      :dfa
+    end
 
     # Computes a transition for the given `input` from the current `state`.
     def step(state, input)
@@ -50,6 +92,75 @@ module Lernen
     def ==(other)
       initial_state == other.initial_state && accept_states == other.accept_states && transitions == other.transitions
     end
+
+    # Returns a mermaid diagram.
+    def to_mermaid
+      mmd = +""
+
+      mmd << "flowchart TD\n"
+
+      states = [initial_state] + accept_states.to_a + transitions.keys.map { |(q, _)| q } + transitions.values
+      states.uniq!
+
+      states.sort.each { |q| mmd << (accept_states.include?(q) ? "  #{q}(((#{q})))\n" : "  #{q}((#{q}))\n") }
+      mmd << "\n"
+
+      transitions.each { |(q1, i), q2| mmd << "  #{q1} -- \"'#{i}'\" --> #{q2}\n" }
+
+      mmd.dup
+    end
+
+    # Returns a random DFA.
+    #
+    # The result DFA is complete, and all states in the result DFA are reachable
+    # to some accepting states or the sink state. However, the result DFA may be
+    # non-minimal.
+    def self.random(
+      alphabet:,
+      max_state_size:,
+      max_accept_state_ratio: 0.5,
+      min_state_size: 1,
+      sink_state_prob: 0.4,
+      random: Random
+    )
+      state_size = random.rand(min_state_size..max_state_size)
+      accept_state_ratio = [max_accept_state_ratio * random.rand, 0.01].max
+      accept_state_size = [state_size, (state_size * accept_state_ratio).ceil].min
+
+      initial_state = 0
+      non_accepting_states = (0...state_size).to_a
+      non_accepting_states.shuffle!(random:)
+      accept_states = non_accepting_states.pop(accept_state_size).to_set
+
+      sink_state = random.rand < sink_state_prob ? non_accepting_states.pop : nil
+
+      transitions = {}
+      accept_states.each_with_index do |accept_state, i|
+        next if accept_state == initial_state
+        n = i + 1 == accept_state_size ? non_accepting_states.size : random.rand(non_accepting_states.size)
+        state = initial_state
+        non_accepting_states
+          .pop(n)
+          .each do |next_state|
+            next if next_state == initial_state
+            input = alphabet.sample(random:)
+            transitions[[state, input]] = next_state
+            state = next_state
+          end
+        input = alphabet.sample(random:)
+        transitions[[state, input]] = accept_state
+      end
+
+      state_size.times do |state|
+        alphabet.each do |input|
+          next if transitions[[state, input]]
+          next_state = state == sink_state ? sink_state : random.rand(state_size)
+          transitions[[state, input]] = next_state
+        end
+      end
+
+      new(initial_state, accept_states, transitions)
+    end
   end
 
   # Moore is a deterministic Moore machine.
@@ -63,6 +174,12 @@ module Lernen
     end
 
     attr_reader :initial_state, :outputs, :transitions
+    alias initial initial_state
+
+    # Returns the type of this automaton.
+    def type
+      :moore
+    end
 
     # Computes a transition for the given `input` from the current `state`.
     def step(state, input)
@@ -75,6 +192,74 @@ module Lernen
     def ==(other)
       initial_state == other.initial_state && outputs == other.outputs && transitions == other.transitions
     end
+
+    # Returns a mermaid diagram.
+    def to_mermaid
+      mmd = +""
+
+      mmd << "flowchart TD\n"
+
+      states = [initial_state] + transitions.keys.map { |(q, _)| q } + transitions.values
+      states.uniq!
+
+      states.sort.each { |q| mmd << "  #{q}((\"#{q}|'#{outputs[q]}'\"))\n" }
+      mmd << "\n"
+
+      transitions.each { |(q1, i), q2| mmd << "  #{q1} -- \"'#{i}'\" --> #{q2}\n" }
+
+      mmd.dup
+    end
+
+    # Returns a random Moore machine.
+    def self.random(
+      alphabet:,
+      output_alphabet:,
+      max_state_size:,
+      max_arc_ratio: 0.5,
+      min_state_size: 1,
+      sink_state_prob: 0.4,
+      random: Random
+    )
+      state_size = random.rand(min_state_size..max_state_size)
+      arc_ratio = [max_arc_ratio * random.rand, 0.01].max
+      arc_state_size = [state_size, (state_size * arc_ratio).ceil].min
+
+      initial_state = 0
+      non_arc_states = (0...state_size).to_a
+      non_arc_states.shuffle!(random:)
+      arc_states = non_arc_states.pop(arc_state_size).to_set
+
+      sink_state = random.rand < sink_state_prob ? non_arc_states.pop : nil
+
+      transitions = {}
+      arc_states.each_with_index do |arc_state, i|
+        next if arc_state == initial_state
+        n = i + 1 == arc_state_size ? non_arc_states.size : random.rand(non_arc_states.size)
+        state = initial_state
+        non_arc_states
+          .pop(n)
+          .each do |next_state|
+            next if next_state == initial_state
+            input = alphabet.sample(random:)
+            transitions[[state, input]] = next_state
+            state = next_state
+          end
+        input = alphabet.sample(random:)
+        transitions[[state, input]] = arc_state
+      end
+
+      outputs = {}
+      state_size.times do |state|
+        outputs[state] = output_alphabet.sample(random:)
+        alphabet.each do |input|
+          next if transitions[[state, input]]
+          next_state = state == sink_state ? sink_state : random.rand(state_size)
+          transitions[[state, input]] = next_state
+        end
+      end
+
+      new(initial_state, outputs, transitions)
+    end
   end
 
   # Mealy is a deterministic Mealy machine.
@@ -87,6 +272,12 @@ module Lernen
     end
 
     attr_reader :initial_state, :transitions
+    alias initial initial_state
+
+    # Returns the type of this automaton.
+    def type
+      :mealy
+    end
 
     # Computes a transition for the given `input` from the current `state`.
     def step(state, input)
@@ -97,5 +288,215 @@ module Lernen
     def ==(other)
       initial_state == other.initial_state && transitions == other.transitions
     end
+
+    # Returns a mermaid diagram.
+    def to_mermaid
+      mmd = +""
+
+      mmd << "flowchart TD\n"
+
+      states = [initial_state] + transitions.keys.map { |(q, _)| q } + transitions.values.map { |(_, q)| q }
+      states.uniq!
+
+      states.sort.each { |q| mmd << "  #{q}((#{q}))\n" }
+      mmd << "\n"
+
+      transitions.each { |(q1, i), (o, q2)| mmd << "  #{q1} -- \"'#{i}'|'#{o}'\" --> #{q2}\n" }
+
+      mmd.dup
+    end
+
+    # Returns a random Mealy machine.
+    def self.random(
+      alphabet:,
+      output_alphabet:,
+      max_state_size:,
+      max_arc_ratio: 0.5,
+      min_state_size: 1,
+      sink_state_prob: 0.4,
+      random: Random
+    )
+      state_size = random.rand(min_state_size..max_state_size)
+      arc_ratio = [max_arc_ratio * random.rand, 0.01].max
+      arc_state_size = [state_size, (state_size * arc_ratio).ceil].min
+
+      initial_state = 0
+      non_arc_states = (0...state_size).to_a
+      non_arc_states.shuffle!(random:)
+      arc_states = non_arc_states.pop(arc_state_size).to_set
+
+      sink_state = random.rand < sink_state_prob ? non_arc_states.pop : nil
+
+      transitions = {}
+      arc_states.each_with_index do |arc_state, i|
+        next if arc_state == initial_state
+        n = i + 1 == arc_state_size ? non_arc_states.size : random.rand(non_arc_states.size)
+        state = initial_state
+        non_arc_states
+          .pop(n)
+          .each do |next_state|
+            next if next_state == initial_state
+            input = alphabet.sample(random:)
+            output = output_alphabet.sample(random:)
+            transitions[[state, input]] = [output, next_state]
+            state = next_state
+          end
+        input = alphabet.sample(random:)
+        output = output_alphabet.sample(random:)
+        transitions[[state, input]] = [output, arc_state]
+      end
+
+      state_size.times do |state|
+        alphabet.each do |input|
+          next if transitions[[state, input]]
+          output = output_alphabet.sample(random:)
+          next_state = state == sink_state ? sink_state : random.rand(state_size)
+          transitions[[state, input]] = [output, next_state]
+        end
+      end
+
+      new(initial_state, transitions)
+    end
+  end
+
+  # VPA is a 1-module single-entry visibly pushdown automaton (1-SEVPA).
+  class VPA < Automaton
+    # Conf is a configuration on VPAs.
+    Conf = Data.define(:state, :stack)
+
+    # StateToPrefixMapping is a mapping from states to prefix strings.
+    #
+    # It can transform a configuration to an access string.
+    class StateToPrefixMapping
+      def initialize(mapping)
+        @mapping = mapping
+      end
+
+      # Transforms a configuration to an access string.
+      def [](conf)
+        return @mapping[nil] unless conf
+        result = []
+
+        conf.stack.each do |state, call_input|
+          result.concat(@mapping[state])
+          result << call_input
+        end
+        result.concat(@mapping[conf.state])
+
+        result
+      end
+
+      # Returns a prefix string of `state`.
+      def state_prefix(state)
+        @mapping[state]
+      end
+    end
+
+    def initialize(initial_state, accept_states, transitions, returns)
+      super()
+
+      @initial_state = initial_state
+      @accept_states = accept_states
+      @transitions = transitions
+      @returns = returns
+    end
+
+    attr_reader :initial_state, :accept_states, :transitions, :returns
+
+    # Returns the type of this automaton.
+    def type
+      :vpa
+    end
+
+    # Returns the initial configuration.
+    def initial
+      Conf[initial_state, []]
+    end
+
+    # Computes a transition for the given `input` from the current `state`.
+    def step(conf, input)
+      next_conf = step_conf(conf, input)
+      output = !next_conf.nil? && accept_states.include?(next_conf.state) && next_conf.stack.empty?
+      [output, next_conf]
+    end
+
+    # Returns a mermaid diagram.
+    def to_mermaid(remove_error_state: true)
+      error_state = error_state() if remove_error_state
+      mmd = +""
+
+      mmd << "flowchart TD\n"
+
+      states =
+        [initial_state] + transitions.keys.map { |(q, _)| q } + transitions.values + returns.keys.map { |(q, _)| q } +
+          returns.values.flat_map { |rt| rt.flat_map { |(q1, _), q2| [q1, q2] } }
+      states.uniq!
+      states.delete(error_state)
+
+      states.sort.each { |q| mmd << (accept_states.include?(q) ? "  #{q}(((#{q})))\n" : "  #{q}((#{q}))\n") }
+      mmd << "\n"
+
+      transitions.each do |(q1, i), q2|
+        next if q1 == error_state || q2 == error_state
+        mmd << "  #{q1} -- \"'#{i}'\" --> #{q2}\n"
+      end
+      mmd << "\n"
+
+      returns.each do |(q1, r), rt|
+        next if q1 == error_state
+        rt.each do |(q2, c), q3|
+          next if q2 == error_state || q3 == error_state
+          mmd << "  #{q1} -- \"'#{r}'/(#{q2},'#{c}')\" --> #{q3}\n"
+        end
+      end
+
+      mmd.dup
+    end
+
+    # Returns an error state in this VPA.
+    def error_state
+      t =
+        transitions
+          .group_by { |(state, _), _| state }
+          .transform_values { _1.to_h { |(_, input), next_state| [input, next_state] } }
+
+      t.each do |state, d|
+        # The initial state and accepting states are not an error state.
+        next if state == initial_state || accept_states.include?(state)
+
+        # An error state should only have self-loops.
+        next unless d.all? { |_, next_state| state == next_state }
+        all_returns_are_self_loops =
+          returns.all? do |_, rt|
+            rt.filter { |(call_state, _), _| call_state == state }.all? { |_, next_state| state == next_state }
+          end
+        next unless all_returns_are_self_loops
+
+        return state
+      end
+
+      nil
+    end
+
+    private
+
+    def step_conf(conf, input)
+      # `nil` means the error state.
+      return nil unless conf
+
+      next_state = @transitions[[conf.state, input]]
+      return Conf[next_state, conf.stack] if next_state
+
+      return_transitions = @returns[[conf.state, input]]
+      if return_transitions
+        return nil if conf.stack.empty?
+        next_state = return_transitions[conf.stack.last]
+        return Conf[next_state, conf.stack[0...-1]]
+      end
+
+      # When there is no usual transition and no return tansition for `input`,
+      # then we assume that `input` is a call alphabet.
+      Conf[initial_state, conf.stack + [[conf.state, input]]]
+    end
   end
 end

data/lib/lernen/cex_processor.rb

@@ -10,6 +10,8 @@ module Lernen
         process_linear(sul, hypothesis, cex, state_to_prefix)
       in :binary
         process_binary(sul, hypothesis, cex, state_to_prefix)
+      in :exponential
+        process_exponential(sul, hypothesis, cex, state_to_prefix)
       end
     end
 
@@ -17,13 +19,13 @@ module Lernen
     def self.process_linear(sul, hypothesis, cex, state_to_prefix)
       expected_output = sul.query(cex).last
 
-      current_state = hypothesis.initial_state
-      cex.each_with_index do |a, i|
-        _, next_state = hypothesis.step(current_state, a)
+      current_state = hypothesis.initial
+      cex.each_with_index do |input, i|
+        _, next_state = hypothesis.step(current_state, input)
 
         prefix = state_to_prefix[next_state]
         suffix = cex[i + 1...]
-        return state_to_prefix[current_state], a, suffix if expected_output != sul.query(prefix + suffix).last
+        return cex[0...i], input, suffix if expected_output != sul.query(prefix + suffix).last
 
         current_state = next_state
       end
@@ -32,11 +34,10 @@ module Lernen
     # Processes a given `cex` by binary search.
     #
     # It is known as the Rivest-Schapire (RS) technique.
-    def self.process_binary(sul, hypothesis, cex, state_to_prefix)
+    def self.process_binary(sul, hypothesis, cex, state_to_prefix, low: 0)
       expected_output = sul.query(cex).last
 
-      low = 0
-      high = cex.size
+      high = cex.size - 1
 
       while high - low > 1
         mid = (low + high) / 2
@@ -53,9 +54,39 @@ module Lernen
 
       prefix = cex[0...low]
       suffix = cex[high...]
+      [prefix, cex[low], suffix]
+    end
+
+    # Processes a given `cex` by exponential seatch.
+    #
+    # This idea is described in this paper.
+    #
+    # Isberner, Malte, and Bernhard Steffen. "An abstract framework for counterexample
+    # analysis in active automata learning." International Conference on Grammatical
+    # Inference. PMLR, 2014.
+    def self.process_exponential(sul, hypothesis, cex, state_to_prefix)
+      expected_output = sul.query(cex).last
+
+      prev_bp = 0
+      bp = 1
+
+      loop do
+        if bp >= cex.size
+          bp = cex.size
+          break
+        end
+
+        prefix = cex[0...bp]
+        suffix = cex[bp...]
+
+        _, prefix_state = hypothesis.run(prefix)
+        break if expected_output != sul.query(state_to_prefix[prefix_state] + suffix).last
+
+        prev_bp = bp
+        bp *= 2
+      end
 
-      _, prefix_state = hypothesis.run(prefix)
-      [state_to_prefix[prefix_state], cex[low], suffix]
+      process_binary(sul, hypothesis, cex, state_to_prefix, low: prev_bp)
     end
   end
 end

data/lib/lernen/kearns_vazirani.rb

@@ -8,11 +8,13 @@ module Lernen
 
     private_constant :Node, :Leaf
 
-    def initialize(alphabet, sul, cex:, automaton_type:, cex_processing:)
+    def initialize(alphabet, sul, cex:, automaton_type:, cex_processing:, call_alphabet:, return_alphabet:)
       @alphabet = alphabet
       @sul = sul
       @automaton_type = automaton_type
       @cex_processing = cex_processing
+      @call_alphabet = call_alphabet
+      @return_alphabet = return_alphabet
 
       @paths = {}
 
@@ -28,6 +30,7 @@ module Lernen
         @root.edges[cex_out] = Leaf[cex]
         @paths[cex] = [cex_out]
       in :mealy
+        prefix = cex[0...-1]
         suffix = [cex.last]
         @root = Node[suffix, {}]
 
@@ -35,6 +38,16 @@ module Lernen
         @root.edges[suffix_out] = Leaf[[]]
         @paths[[]] = [suffix_out]
 
+        cex_out = sul.query(cex).last
+        @root.edges[cex_out] = Leaf[prefix]
+        @paths[prefix] = [cex_out]
+      in :vpa
+        @root = Node[[[], []], {}]
+
+        empty_out = sul.query_empty
+        @root.edges[empty_out] = Leaf[[]]
+        @paths[[]] = [empty_out]
+
         cex_out = sul.query(cex).last
         @root.edges[cex_out] = Leaf[cex]
         @paths[cex] = [cex_out]
@@ -47,7 +60,15 @@ module Lernen
       path = []
 
       until node.is_a?(Leaf)
-        inputs = word + node.suffix
+        inputs =
+          case @automaton_type
+          in :vpa
+            access, suffix = node.suffix
+            access + word + suffix
+          in :dfa | :moore | :mealy
+            word + node.suffix
+          end
+
         out = @sul.query(inputs).last
         path << out
 
@@ -65,12 +86,15 @@ module Lernen
     # Constructs a hypothesis automaton from this classification tree.
     def to_hypothesis
       transitions = {}
+      returns = {}
 
       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
@@ -80,22 +104,63 @@ module Lernen
           next_prefix = sift(word)
 
           unless prefix_to_state.include?(next_prefix)
-            prefix_to_state[next_prefix] = prefix_to_state.size
             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
+          in :dfa | :moore | :vpa
             transitions[[state, input]] = next_state
           in :mealy
             output = @sul.query(word).last
             transitions[[state, input]] = [output, next_state]
           end
         end
+
+        next unless @automaton_type == :vpa
+
+        found_states = prefix_to_state.values
+
+        returns.each do |(return_state, return_input), return_transitions|
+          return_prefix = state_to_prefix[return_state]
+          @call_alphabet.each do |call_input|
+            word = prefix + [call_input] + return_prefix + [return_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]
+            return_transitions[[state, call_input]] = next_state
+          end
+        end
+
+        @return_alphabet.each do |return_input|
+          return_transitions = returns[[state, return_input]] = {}
+          found_states.each do |call_state|
+            call_prefix = state_to_prefix[call_state]
+            @call_alphabet.each do |call_input|
+              word = call_prefix + [call_input] + prefix + [return_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]
+              return_transitions[[call_state, call_input]] = next_state
+            end
+          end
+        end
       end
 
-      state_to_prefix = prefix_to_state.to_h { |q, i| [i, q] }
       automaton =
         case @automaton_type
         in :dfa
@@ -106,6 +171,11 @@ module Lernen
           Moore.new(0, outputs, transitions)
         in :mealy
           Mealy.new(0, transitions)
+        in :vpa
+          accept_states = state_to_prefix.to_a.filter { |(_, q)| @paths[q][0] }.to_set { |(i, _)| i }
+          state_to_prefix[nil] = [@return_alphabet.first] unless @return_alphabet.empty?
+          state_to_prefix = VPA::StateToPrefixMapping.new(state_to_prefix)
+          VPA.new(0, accept_states, transitions, returns)
         end
 
       [automaton, state_to_prefix]
@@ -116,42 +186,72 @@ module Lernen
       old_prefix, new_input, new_suffix =
         CexProcessor.process(@sul, hypothesis, cex, state_to_prefix, cex_processing: @cex_processing)
 
-      _, old_prefix_state = hypothesis.run(old_prefix)
-      new_prefix = state_to_prefix[old_prefix_state] + [new_input]
-      new_prefix_out = @sul.query(new_prefix + new_suffix).last
+      _, old_state = hypothesis.run(old_prefix)
+      _, replace_state = hypothesis.step(old_state, new_input)
 
-      _, old_node_state = hypothesis.run(old_prefix + [new_input])
-      old_node_prefix = state_to_prefix[old_node_state]
-      old_node_out = @sul.query(old_node_prefix + new_suffix).last
+      case @automaton_type
+      in :dfa | :moore | :mealy
+        new_prefix = state_to_prefix[old_state] + [new_input]
+        new_out = @sul.query(new_prefix + new_suffix).last
+
+        replace_prefix = state_to_prefix[replace_state]
+        replace_out = @sul.query(replace_prefix + new_suffix).last
+      in :vpa
+        new_suffix = [state_to_prefix[VPA::Conf[hypothesis.initial_state, replace_state.stack]], new_suffix]
+
+        old_state_prefix = state_to_prefix.state_prefix(old_state.state)
+        if @alphabet.include?(new_input)
+          new_prefix = old_state_prefix + [new_input]
+        else
+          call_state, call_input = old_state.stack[-1]
+          call_prefix = state_to_prefix.state_prefix(call_state)
+          new_prefix = call_prefix + [call_input] + old_state_prefix + [new_input]
+        end
+        # new_out = @sul.query(cex).last
+        new_out = @sul.query(new_suffix[0] + new_prefix + new_suffix[1]).last
+
+        replace_prefix = state_to_prefix.state_prefix(replace_state.state)
+        replace_out = @sul.query(new_suffix[0] + replace_prefix + new_suffix[1]).last
+      end
 
-      old_node_path = @paths[old_node_prefix]
-      parent = @root
-      old_node = @root.edges[old_node_path.first]
-      old_node_path[1..].each do |out|
-        parent = old_node
-        old_node = old_node.edges[out]
+      replace_node_path = @paths[replace_prefix]
+      replace_node_parent = @root
+      replace_node = @root.edges[replace_node_path.first]
+      replace_node_path[1..].each do |out|
+        replace_node_parent = replace_node
+        replace_node = replace_node.edges[out]
       end
 
       new_node = Node[new_suffix, {}]
-      parent.edges[old_node_path.last] = new_node
+      replace_node_parent.edges[replace_node_path.last] = new_node
 
-      new_node.edges[new_prefix_out] = Leaf[new_prefix]
-      @paths[new_prefix] = old_node_path + [new_prefix_out]
+      new_node.edges[new_out] = Leaf[new_prefix]
+      @paths[new_prefix] = replace_node_path + [new_out]
 
-      new_node.edges[old_node_out] = Leaf[old_node_prefix]
-      @paths[old_node_prefix] = old_node_path + [old_node_out]
+      new_node.edges[replace_out] = Leaf[replace_prefix]
+      @paths[replace_prefix] = replace_node_path + [replace_out]
     end
   end
 
   # KearnsVazirani is an implementation of the Kearns-Vazirani automata learning algorithm.
   module KearnsVazirani
     # Runs the Kearns-Vazirani algoritghm and returns an inferred automaton.
-    def self.learn(alphabet, sul, oracle, automaton_type:, cex_processing: :binary, max_learning_rounds: nil)
-      hypothesis = construct_first_hypothesis(alphabet, sul, automaton_type)
+    def self.learn(
+      alphabet,
+      sul,
+      oracle,
+      automaton_type:,
+      cex_processing: :binary,
+      max_learning_rounds: nil,
+      call_alphabet: nil,
+      return_alphabet: nil
+    )
+      hypothesis = construct_first_hypothesis(alphabet, sul, automaton_type, call_alphabet:, return_alphabet:)
       cex = oracle.find_cex(hypothesis)
       return hypothesis if cex.nil?
 
-      classification_tree = ClassificationTree.new(alphabet, sul, cex:, automaton_type:, cex_processing:)
+      classification_tree =
+        ClassificationTree.new(alphabet, sul, cex:, automaton_type:, cex_processing:, call_alphabet:, return_alphabet:)
       learning_rounds = 0
 
       loop do
@@ -170,15 +270,15 @@ module Lernen
     end
 
     # Constructs the first hypothesis automaton.
-    def self.construct_first_hypothesis(alphabet, sul, automaton_type)
+    def self.construct_first_hypothesis(alphabet, sul, automaton_type, call_alphabet:, return_alphabet:)
       transitions = {}
-      alphabet.each do |a|
+      alphabet.each do |input|
         case automaton_type
-        in :dfa | :moore
-          transitions[[0, a]] = 0
+        in :dfa | :moore | :vpa
+          transitions[[0, input]] = 0
         in :mealy
-          out = sul.query([a]).last
-          transitions[[0, a]] = [out, 0]
+          out = sul.query([input]).last
+          transitions[[0, input]] = [out, 0]
         end
       end
 
@@ -191,6 +291,17 @@ module Lernen
         Moore.new(0, outputs, transitions)
       in :mealy
         Mealy.new(0, transitions)
+      in :vpa
+        raise ArgumentError, "Learning 1-SEVPA needs call and return alphabet." unless call_alphabet && return_alphabet
+
+        returns = {}
+        return_alphabet.each do |return_input|
+          return_transitions = returns[[0, return_input]] = {}
+          call_alphabet.each { |call_input| return_transitions[[0, call_input]] = 0 }
+        end
+
+        accept_states = sul.query_empty ? Set[0] : Set.new
+        VPA.new(0, accept_states, transitions, returns)
       end
     end
 

data/lib/lernen/lsharp.rb

@@ -85,15 +85,15 @@ module Lernen
 
       @basis = []
       @frontier = {}
+
+      @incomplete_basis = []
     end
 
     # Runs the L# algoritghm and returns an inferred automaton.
     def learn
-      @basis << []
+      add_basis([])
 
       loop do
-        update_frontier
-
         next if promotion || completion || identification
 
         hypothesis = check_hypothesis
@@ -140,6 +140,7 @@ module Lernen
 
     def add_basis(prefix)
       @basis << prefix
+      @incomplete_basis << prefix
       prefix_node = @observation_tree[prefix]
       @frontier.each do |border, eq_prefixes|
         border_node = @observation_tree[border]
@@ -158,7 +159,7 @@ module Lernen
     def update_frontier
       @frontier.each do |border, eq_prefixes|
         border_node = @observation_tree[border]
-        @frontier[border] = eq_prefixes.filter do |prefix|
+        eq_prefixes.filter! do |prefix|
           prefix_node = @observation_tree[prefix]
           check_apartness(prefix_node, border_node).nil?
         end
@@ -213,7 +214,7 @@ module Lernen
 
     def check_consistency(hypothesis, state_to_prefix)
       queue = []
-      queue << [[], hypothesis.initial_state, @observation_tree.root]
+      queue << [[], hypothesis.initial, @observation_tree.root]
 
       until queue.empty?
         prefix, state, node = queue.shift
@@ -232,46 +233,53 @@ module Lernen
     end
 
     def promotion
-      isolated_borders = @frontier.to_a.filter { |(_, eq_prefixes)| eq_prefixes.empty? }.map { |(border, _)| border }
+      @frontier.each do |new_prefix, eq_prefixes|
+        next unless eq_prefixes.empty?
 
-      return false if isolated_borders.empty?
+        @frontier.delete(new_prefix)
+        add_basis(new_prefix)
 
-      new_prefix = isolated_borders.first
-      @frontier.delete(new_prefix)
-      add_basis(new_prefix)
+        return true
+      end
 
-      true
+      false
     end
 
     def completion
-      incomplete_borders =
-        @basis
-          .flat_map { |prefix| @alphabet.map { |a| prefix + [a] } }
-          .filter do |border|
-            @observation_tree[border].nil? || (!@basis.include?(border) && !@frontier.include?(border))
-          end
+      updated = false
+
+      until @incomplete_basis.empty?
+        prefix = @incomplete_basis.pop
+        prefix_tree = @observation_tree[prefix]
 
-      return false if incomplete_borders.empty?
+        @alphabet.each do |input|
+          border = prefix + [input]
+          next if prefix_tree.edges[input] && (@basis.include?(border) || @frontier.include?(border))
+
+          @observation_tree.query(border)
+          add_frontier(border)
 
-      incomplete_borders.each do |border|
-        @observation_tree.query(border)
-        add_frontier(border)
+          updated = true
+        end
       end
 
-      true
+      updated
     end
 
     def identification
-      unidentified_borders = @frontier.keys.filter { @frontier[_1].size >= 2 }
+      @frontier.each do |border, eq_prefixes|
+        next unless eq_prefixes.size >= 2
 
-      return false if unidentified_borders.empty?
+        prefix1 = eq_prefixes[0]
+        prefix2 = eq_prefixes[1]
+        witness = compute_witness(prefix1, prefix2)
+        @observation_tree.query(border + witness)
+        update_frontier
 
-      border = unidentified_borders.first
-      prefix1, prefix2 = @frontier[border][0...2]
-      witness = compute_witness(prefix1, prefix2)
-      @observation_tree.query(border + witness)
+        return true
+      end
 
-      true
+      false
     end
 
     def check_hypothesis
@@ -300,6 +308,7 @@ module Lernen
       return hypothesis if cex.nil?
 
       process_cex(hypothesis, state_to_prefix, cex)
+      update_frontier
 
       nil
     end

data/lib/lernen/lstar.rb

@@ -155,7 +155,8 @@ module Lernen
         else
           old_prefix, new_input, new_suffix =
             CexProcessor.process(sul, hypothesis, cex, state_to_prefix, cex_processing:)
-          new_prefix = old_prefix + [new_input]
+          _, old_state = hypothesis.run(old_prefix)
+          new_prefix = state_to_prefix[old_state] + [new_input]
           observation_table.prefixes << new_prefix unless observation_table.prefixes.include?(new_prefix)
           observation_table.suffixes << new_suffix unless observation_table.suffixes.include?(new_suffix)
         end

data/lib/lernen/oracle.rb

@@ -32,7 +32,7 @@ module Lernen
 
     # Resets the internal states of this oracle.
     def reset_internal(hypothesis)
-      @current_state = hypothesis.initial_state
+      @current_state = hypothesis.initial
 
       @sul.shutdown
       @sul.setup
@@ -69,17 +69,19 @@ module Lernen
         end
       end
 
+      @sul.shutdown
       nil
     end
   end
 
   # This equivalence oracles uses random-walk exploration for equivalence checking.
   class RandomWalkOracle < Oracle
-    def initialize(alphabet, sul, step_limit: 500, reset_prob: 0.09)
+    def initialize(alphabet, sul, step_limit: 3000, reset_prob: 0.09, random: Random)
       super(alphabet, sul)
 
       @step_limit = step_limit
       @reset_prob = reset_prob
+      @random = random
     end
 
     # Finds a conterexample against the given `hypothesis` automaton.
@@ -93,12 +95,12 @@ module Lernen
       while random_steps_done < @step_limit
         random_steps_done += 1
 
-        if rand < @reset_prob
+        if @random.rand < @reset_prob
           inputs = []
           reset_internal(hypothesis)
         end
 
-        inputs << @alphabet.sample
+        inputs << @alphabet.sample(random: @random)
 
         @num_steps += 1
         h_out, @current_state = hypothesis.step(@current_state, inputs.last)
@@ -110,6 +112,7 @@ module Lernen
         end
       end
 
+      @sul.shutdown
       nil
     end
   end

data/lib/lernen/sul.rb

@@ -17,6 +17,17 @@ module Lernen
     # Creates a SUL from the given block as an implementation of a membership query.
     def self.from_block(cache: true, &) = BlockSUL.new(cache:, &)
 
+    # Creates a SUL from the given automaton as an implementation.
+    def self.from_automaton(automaton, cache: true) =
+      case automaton
+      when DFA
+        DFASimulatorSUL.new(automaton, cache:)
+      when Mealy
+        MealySimulatorSUL.new(automaton, cache:)
+      when Moore
+        MooreSimulatorSUL.new(automaton, cache:)
+      end
+
     def initialize(cache: true)
       @cache = cache ? {} : nil
       @num_cached_queries = 0
@@ -58,7 +69,7 @@ module Lernen
       @num_queries += 1
       @num_steps += inputs.size
 
-      @cache[inputs] = outputs
+      @cache[inputs] = outputs if @cache
 
       outputs
     end
@@ -96,7 +107,7 @@ module Lernen
       super
     end
 
-    # Runs a membership query with the given inputs.
+    # Runs a membership query with the empty input.
     #
     # This is *abstract*.
     def query_empty
@@ -104,6 +115,71 @@ module Lernen
     end
   end
 
+  # BaseSimulatorSUL is a base implementation of SUL on automaton simulators.
+  module BaseSimulatorSUL
+    # It is a setup procedure of this SUL.
+    def setup
+      @state = @automaton.initial
+    end
+
+    # It is a shutdown procedure of this SUL.
+    def shutdown
+      @state = nil
+    end
+
+    # Runs a membership query with the given inputs.
+    def step(input)
+      output, @state = @automaton.step(@state, input)
+      output
+    end
+  end
+
+  # DFASimulatorSUL is a SUL on a DFA simuator.
+  class DFASimulatorSUL < MooreSUL
+    include BaseSimulatorSUL
+
+    def initialize(automaton, cache: true)
+      super(cache:)
+
+      @automaton = automaton
+      @state = nil
+    end
+
+    # Runs a membership query with the empty input.
+    def query_empty
+      @automaton.accept_states.include?(@automaton.initial_state)
+    end
+  end
+
+  # MealySimulatorSUL is a SUL on a Mealy simuator.
+  class MealySimulatorSUL < SUL
+    include BaseSimulatorSUL
+
+    def initialize(automaton, cache: true)
+      super(cache:)
+
+      @automaton = automaton
+      @state = nil
+    end
+  end
+
+  # MooreSimulatorSUL is a SUL on a Moore simuator.
+  class MooreSimulatorSUL < MooreSUL
+    include BaseSimulatorSUL
+
+    def initialize(automaton, cache: true)
+      super(cache:)
+
+      @automaton = automaton
+      @state = nil
+    end
+
+    # Runs a membership query with the empty input.
+    def query_empty
+      @automaton.outputs[@automaton.initial_state]
+    end
+  end
+
   # BlockSUL is a System Under Learning (SUL) constructed from a block.
   #
   # A block is expected to behave like a membership query.
@@ -126,7 +202,7 @@ module Lernen
       @block.call(@inputs)
     end
 
-    # Runs a membership query with the given inputs.
+    # Runs a membership query with the empty input.
     def query_empty
       @block.call([])
     end

data/lib/lernen/version.rb

@@ -2,5 +2,5 @@
 
 module Lernen
   # The version string.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/lernen.rb

@@ -2,7 +2,6 @@
 
 require "set"
 
-# Lernen is a simple automata learning library.
 module Lernen
   # Error is an error class for this library.
   class Error < StandardError
@@ -18,3 +17,63 @@ require_relative "lernen/version"
 require_relative "lernen/lstar"
 require_relative "lernen/kearns_vazirani"
 require_relative "lernen/lsharp"
+
+# Lernen is a simple automata learning library.
+module Lernen
+  # Learn an automaton.
+  def self.learn(
+    alphabet:,
+    call_alphabet: nil,
+    return_alphabet: nil,
+    sul: nil,
+    oracle: :random_walk,
+    oracle_params: {},
+    algorithm: :kearns_vazirani,
+    automaton_type: nil,
+    params: {},
+    random: Random,
+    &sul_block
+  )
+    automaton_type ||= call_alphabet ? :vpa : :dfa
+
+    case sul
+    when SUL
+      # Do nothing
+    when Automaton
+      automaton_type = sul.type
+      sul = SUL.from_automaton(sul)
+    when nil
+      sul = SUL.from_block(&sul_block)
+    else
+      raise ArgumentError, "Unsupported SUL: #{sul}"
+    end
+
+    full_alphabet =
+      case automaton_type
+      in :dfa | :moore | :mealy
+        alphabet
+      in :vpa
+        alphabet + call_alphabet + return_alphabet
+      end
+
+    case oracle
+    when Oracle
+      # Do nothing
+    when :breadth_first_exploration
+      oracle = BreadthFirstExplorationOracle.new(full_alphabet, sul, **oracle_params)
+    when :random_walk
+      oracle = RandomWalkOracle.new(full_alphabet, sul, random:, **oracle_params)
+    else
+      raise ArgumentError, "Unsupported oracle: #{oracle}"
+    end
+
+    case algorithm
+    in :lstar
+      LStar.learn(alphabet, sul, oracle, automaton_type:, **params)
+    in :kearns_vazirani
+      KearnsVazirani.learn(alphabet, sul, oracle, automaton_type:, call_alphabet:, return_alphabet:, **params)
+    in :lsharp
+      LSharp.learn(alphabet, sul, oracle, automaton_type:, **params)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lernen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - TSUYUSATO Kitsune
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: set