lernen 0.2.0 → 0.3.0

data/lib/lernen/lstar.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module Lernen
-  # ObservationTable is an observation table implementation.
-  class ObservationTable
-    def initialize(alphabet, sul, automaton_type:)
-      @alphabet = alphabet
-      @sul = sul
-      @automaton_type = automaton_type
-
-      @prefixes = [[]]
-      @suffixes = []
-      @table = {}
-
-      case @automaton_type
-      in :dfa | :moore
-        @suffixes << []
-      in :mealy
-        @alphabet.each { |a| @suffixes << [a] }
-      end
-
-      update_table
-    end
-
-    attr_reader :prefixes, :suffixes
-
-    # Finds new prefixes to close.
-    def find_prefixes_to_close
-      prefixes_to_close = []
-      unclosed_rows = Set.new
-
-      prefix_rows = @prefixes.to_set { @table[_1] }
-
-      extended_prefixes = @prefixes.flat_map { |q| @alphabet.map { |a| q + [a] } }
-      extended_prefixes.each do |qa|
-        row = @table[qa]
-        unless prefix_rows.include?(row) || unclosed_rows.include?(row)
-          prefixes_to_close << qa
-          unclosed_rows << row
-        end
-      end
-
-      return if prefixes_to_close.empty?
-
-      prefixes_to_close.sort_by!(&:size).reverse!
-    end
-
-    # Checks consistency and returns a new suffix to add if this observation table
-    # is inconsistent.
-    def check_consistency
-      @prefixes.combination(2) do |(q1, q2)|
-        next unless @table[q1] == @table[q2]
-
-        @alphabet.each do |a|
-          q1a = q1 + [a]
-          q2a = q2 + [a]
-          next if @table[q1a] == @table[q2a]
-
-          @suffixes.each_with_index do |e, i|
-            next if @table[q1a][i] == @table[q2a][i]
-
-            return [a] + e
-          end
-        end
-      end
-
-      nil
-    end
-
-    # Update observation table entries.
-    def update_table
-      extended_prefixes = @prefixes.flat_map { |q| [q] + @alphabet.map { |a| q + [a] } }
-
-      extended_prefixes.each do |qa|
-        @table[qa] ||= []
-        next if @table[qa].size == @suffixes.size
-        @suffixes.each_with_index do |e, i|
-          next if i < @table[qa].size
-          inputs = qa + e
-          outputs = inputs.empty? ? [@sul.query_empty] : @sul.query(inputs)
-          @table[qa] += [outputs.last]
-        end
-      end
-    end
-
-    # Constructs a hypothesis automaton from this observation table.
-    def to_hypothesis
-      state_to_prefix = @prefixes.each_with_index.to_h { |q, i| [i, q] }
-      row_to_state = @prefixes.each_with_index.to_h { |q, i| [@table[q], i] }
-
-      transitions = {}
-      @prefixes.each_with_index do |q, i|
-        @alphabet.each_with_index do |a, j|
-          case @automaton_type
-          in :moore | :dfa
-            transitions[[i, a]] = row_to_state[@table[q + [a]]]
-          in :mealy
-            transitions[[i, a]] = [@table[q][j], row_to_state[@table[q + [a]]]]
-          end
-        end
-      end
-
-      automaton =
-        case @automaton_type
-        in :dfa
-          accept_states = state_to_prefix.to_a.filter { |(_, q)| @table[q][0] }.to_set { |(i, _)| i }
-          DFA.new(0, accept_states, transitions)
-        in :moore
-          outputs = state_to_prefix.transform_values { |q| @table[q][0] }
-          Moore.new(0, outputs, transitions)
-        in :mealy
-          Mealy.new(0, transitions)
-        end
-
-      [automaton, state_to_prefix]
-    end
-  end
-
-  # LStar is an implementation of Angluin's L* algorithm.
-  module LStar
-    # Runs Angluin's L* algoritghm and returns an inferred automaton.
-    def self.learn(alphabet, sul, oracle, automaton_type:, cex_processing: :binary, max_learning_rounds: nil)
-      observation_table = ObservationTable.new(alphabet, sul, automaton_type:)
-      learning_rounds = 0
-
-      loop do
-        break if max_learning_rounds && learning_rounds == max_learning_rounds
-        learning_rounds += 1
-
-        if cex_processing.nil?
-          new_suffix = observation_table.check_consistency
-          until new_suffix.nil?
-            observation_table.suffixes << new_suffix
-            observation_table.update_table
-            new_suffix = observation_table.check_consistency
-          end
-        end
-
-        new_prefixes = observation_table.find_prefixes_to_close
-        until new_prefixes.nil?
-          observation_table.prefixes.push(*new_prefixes)
-          observation_table.update_table
-          new_prefixes = observation_table.find_prefixes_to_close
-        end
-
-        hypothesis, state_to_prefix = observation_table.to_hypothesis
-        cex = oracle.find_cex(hypothesis)
-        break if cex.nil?
-
-        if cex_processing.nil?
-          all_prefixes = (0..cex.size).map { |n| cex[0...n] }
-          all_prefixes.each do |prefix|
-            observation_table.prefixes << prefix unless observation_table.prefixes.include?(prefix)
-          end
-        else
-          old_prefix, new_input, new_suffix =
-            CexProcessor.process(sul, hypothesis, cex, state_to_prefix, cex_processing:)
-          _, 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
-        observation_table.update_table
-      end
-
-      hypothesis, = observation_table.to_hypothesis
-      hypothesis
-    end
-  end
-end

data/lib/lernen/oracle.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module Lernen
-  # Oracle is an equivalence oracle.
-  #
-  # Note that this class is *abstract*. You should implement the following method:
-  #
-  # - `#find_cex(hypothesis)`
-  class Oracle
-    def initialize(alphabet, sul)
-      @alphabet = alphabet
-      @sul = sul
-
-      @num_calls = 0
-      @num_queries = 0
-      @num_steps = 0
-      @current_state = nil
-    end
-
-    # Returns statistics information as a `Hash` object.
-    def stats
-      { num_calls: @num_calls, num_queries: @num_queries, num_steps: @num_steps }
-    end
-
-    # Finds a conterexample against the given `hypothesis` automaton.
-    # If it is found, it returns the counterexample inputs, or it returns `nil` otherwise.
-    #
-    # This is *abstract*.
-    def find_cex(_hypothesis)
-      raise TypeError, "abstract method: `step`"
-    end
-
-    # Resets the internal states of this oracle.
-    def reset_internal(hypothesis)
-      @current_state = hypothesis.initial
-
-      @sul.shutdown
-      @sul.setup
-
-      @num_queries += 1
-    end
-  end
-
-  # This equivalence oracles uses bradth-first exploration of all possible input
-  # combinations up to a specified depth for equivalence checking.
-  class BreadthFirstExplorationOracle < Oracle
-    def initialize(alphabet, sul, depth: 5)
-      super(alphabet, sul)
-
-      @depth = depth
-    end
-
-    # Finds a conterexample against the given `hypothesis` automaton.
-    def find_cex(hypothesis)
-      @num_calls += 1
-
-      @alphabet.product(*[@alphabet] * (@depth - 1)) do |inputs|
-        reset_internal(hypothesis)
-
-        inputs.each_with_index do |input, i|
-          @num_steps += 1
-          h_out, @current_state = hypothesis.step(@current_state, input)
-          s_out = @sul.step(input)
-
-          if h_out != s_out
-            @sul.shutdown
-            return inputs[0..i]
-          end
-        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: 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.
-    def find_cex(hypothesis)
-      @num_calls += 1
-
-      random_steps_done = 0
-      inputs = []
-      reset_internal(hypothesis)
-
-      while random_steps_done < @step_limit
-        random_steps_done += 1
-
-        if @random.rand < @reset_prob
-          inputs = []
-          reset_internal(hypothesis)
-        end
-
-        inputs << @alphabet.sample(random: @random)
-
-        @num_steps += 1
-        h_out, @current_state = hypothesis.step(@current_state, inputs.last)
-        s_out = @sul.step(inputs.last)
-
-        if h_out != s_out
-          @sul.shutdown
-          return inputs
-        end
-      end
-
-      @sul.shutdown
-      nil
-    end
-  end
-end

data/lib/lernen/sul.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module Lernen
-  # SUL is a System Under Learning.
-  #
-  # It is an abtraction of a system under learning (SUL) which accepts an operation
-  # called "membership query"; it takes an input string (word) and returns a sequence
-  # of outputs corresponding to the input string.
-  #
-  # This SUL assumes the system is much like Mealy machine; that is, a transition puts
-  # an output, and query does not accept the empty string due to no outputs.
-  #
-  # Note that this class is *abstract*. You should implement the following method:
-  #
-  # - `#step(input)`
-  class SUL
-    # 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
-      @num_queries = 0
-      @num_steps = 0
-    end
-
-    # Returns statistics information as a `Hash` object.
-    def stats
-      {
-        num_cache: @cache&.size || 0,
-        num_cached_queries: @num_cached_queries,
-        num_queries: @num_queries,
-        num_steps: @num_steps
-      }
-    end
-
-    # Runs a membership query with the given inputs.
-    #
-    # Note that this method does not accept the empty string due to no outpus.
-    # If you need to call `query` with the empty string, you should use `MooreSUL#query_empty` instead.
-    def query(inputs)
-      cached = @cache && @cache[inputs]
-      if cached
-        @num_cached_queries += 1
-        return cached
-      end
-
-      if inputs.empty?
-        raise ArgumentError, "`query` does not accept the empty string. Please use `query_empty` instead."
-      end
-
-      setup
-
-      outputs = inputs.map { |input| step(input) }
-
-      shutdown
-
-      @num_queries += 1
-      @num_steps += inputs.size
-
-      @cache[inputs] = outputs if @cache
-
-      outputs
-    end
-
-    # It is a setup procedure of this SUL.
-    #
-    # Note that it does nothing by default.
-    def setup
-    end
-
-    # It is a shutdown procedure of this SUL.
-    #
-    # Note that it does nothing by default.
-    def shutdown
-    end
-
-    # Consumes the given `input` and returns the correspoding output.
-    #
-    # This is *abstract*.
-    def step(_input)
-      raise TypeError, "abstract method: `step`"
-    end
-  end
-
-  # MooreSUL is a System Under Learning (SUL) for a system much like Moore machine.
-  #
-  # By contrast to `SUL`, this accepts a query with the empty string additionally.
-  #
-  # Note that this class is *abstract*. You should implement the following method:
-  #
-  # - `#step(input)`
-  # - `#query_empty`
-  class MooreSUL < SUL
-    def initialize(cache: true)
-      super
-    end
-
-    # Runs a membership query with the empty input.
-    #
-    # This is *abstract*.
-    def query_empty
-      raise TypeError, "abstract method: `query_empty`"
-    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.
-  class BlockSUL < MooreSUL
-    def initialize(cache: true, &block)
-      super(cache:)
-
-      @block = block
-      @inputs = []
-    end
-
-    # It is a setup procedure of this SUL.
-    def setup
-      @inputs = []
-    end
-
-    # Runs a membership query with the given inputs.
-    def step(input)
-      @inputs << input
-      @block.call(@inputs)
-    end
-
-    # Runs a membership query with the empty input.
-    def query_empty
-      @block.call([])
-    end
-  end
-end