lernen 0.1.0 → 0.3.0

data/lib/lernen/algorithm/procedural/procedural_sul.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Algorithm
+    module Procedural
+      # ProceduralSUL is a wrapper of SUL for procedural learning.
+      #
+      # @rbs generic In     -- Type for input alphabet
+      # @rbs generic Call   -- Type for call alphabet
+      # @rbs generic Return -- Type for return alphabet
+      class ProceduralSUL < System::MooreLikeSUL #[In | Call, bool]
+        # @rbs @proc: Call
+        # @rbs @sul: System::SUL[In | Call | Return, bool]
+        # @rbs @manager: ATRManager[In, Call, Return]
+
+        #: (
+        #    Call proc,
+        #    System::SUL[In | Call | Return, bool] sul,
+        #    ATRManager[In, Call, Return] manager
+        #  ) -> void
+        def initialize(proc, sul, manager)
+          super(cache: false)
+
+          @proc = proc
+          @sul = sul
+          @manager = manager
+        end
+
+        # @rbs override
+        def query_empty
+          @sul.query_last(@manager.embed(@proc, []))
+        end
+
+        # @rbs override
+        def query(word)
+          @sul.query(@manager.embed(@proc, word))
+        end
+
+        # @rbs override
+        def step(_input)
+          raise TypeError, "ProceduralSUL does not support `step`"
+        end
+      end
+    end
+  end
+end

data/lib/lernen/algorithm/procedural/return_indices_acex.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Algorithm
+    module Procedural
+      # ReturnIndicesAcex is an acex implementation for finding the return index in procedural learning.
+      #
+      # @rbs generic In     -- Type for input alphabet
+      # @rbs generic Call   -- Type for call alphabet
+      # @rbs generic Return -- Type for return alphabet
+      class ReturnIndicesAcex < CexProcessor::Acex
+        # @rbs @cex: Array[In | Call | Return]
+        # @rbs @return_indices: Array[Integer]
+        # @rbs @query: ^(Array[In | Call | Return]) -> bool
+        # @rbs @manager: ATRManager[In, Call, Return]
+
+        #: (
+        #    Array[In | Call | Return] cex,
+        #    Array[Integer] return_indices,
+        #    ^(Array[In | Call | Return]) -> bool query,
+        #    ATRManager[In, Call, Return] manager
+        #  ) -> void
+        def initialize(cex, return_indices, query, manager)
+          super(return_indices.size + 1)
+
+          @cex = cex
+          @return_indices = return_indices
+          @query = query
+          @manager = manager
+
+          @cache[0] = false
+          @cache[return_indices.size] = true
+        end
+
+        # @rbs override
+        def compute_effect(idx)
+          word_stack = []
+          index = @return_indices[idx]
+
+          while index > 0
+            call_index = @manager.find_call_index(@cex, index)
+            proc = @cex[call_index]
+            normalized_word = @manager.expand(@manager.project(@cex[call_index + 1...index])) # steep:ignore
+            word_stack << [proc, *normalized_word]
+            index = call_index
+          end
+
+          word = []
+          word_stack.reverse_each { word.concat(_1) }
+          word.concat(@cex[@return_indices[idx]...]) # steep:ignore
+
+          @query.call(word)
+        end
+      end
+    end
+  end
+end

data/lib/lernen/algorithm/procedural.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "lernen/algorithm/procedural/atr_manager"
+require "lernen/algorithm/procedural/procedural_sul"
+require "lernen/algorithm/procedural/return_indices_acex"
+require "lernen/algorithm/procedural/procedural_learner"
+
+module Lernen
+  module Algorithm
+    # Procedural provides an implementation of the learning algorithm for SPA.
+    #
+    # This algorithm is described in [Frohme & Seffen (2021) "Compositional
+    # Learning of Mutually Recursive Procedural Systems"](https://link.springer.com/article/10.1007/s10009-021-00634-y).
+    module Procedural
+      # Runs the procedural algorithm and returns an inferred SPA.
+      #
+      #: [In, Call, Return] (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    Return return_input,
+      #    System::SUL[In | Call | Return, bool] sul,
+      #    Equiv::Oracle[In | Call | Return, bool] oracle,
+      #    ?algorithm: :lstar | :kearns_vazirani | :lsharp,
+      #    ?algorithm_params: Hash[Symbol, untyped],
+      #    ?cex_processing: cex_processing_method,
+      #    ?scan_procs: bool,
+      #    ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::SPA[In, Call, Return]
+      def self.learn( # steep:ignore
+        alphabet,
+        call_alphabet,
+        return_input,
+        sul,
+        oracle,
+        algorithm: :kearns_vazirani,
+        algorithm_params: {},
+        cex_processing: :binary,
+        scan_procs: true,
+        max_learning_rounds: nil
+      )
+        learner =
+          ProceduralLearner.new(
+            alphabet,
+            call_alphabet,
+            return_input,
+            sul,
+            algorithm:,
+            algorithm_params:,
+            cex_processing:,
+            scan_procs:
+          )
+        learner.learn(oracle, max_learning_rounds:)
+      end
+    end
+  end
+end

data/lib/lernen/algorithm.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  # This is a namespace for learning algorithm implementations.
+  #
+  # This namespace also contains data structures and utilities for
+  # learning algorithms.
+  module Algorithm
+  end
+end
+
+require "lernen/algorithm/cex_processor"
+require "lernen/algorithm/learner"
+require "lernen/algorithm/lstar"
+require "lernen/algorithm/kearns_vazirani"
+require "lernen/algorithm/lsharp"
+require "lernen/algorithm/kearns_vazirani_vpa"
+require "lernen/algorithm/procedural"

data/lib/lernen/automaton/dfa.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # DFA represents a [deterministic finite-state automaton](https://en.wikipedia.org/wiki/Deterministic_finite_automaton).
+    #
+    # @rbs generic In -- Type for input alphabet
+    class DFA < MooreLike #[Integer, In, bool]
+      # @rbs @initial_state: Integer
+      # @rbs @accept_state_set: Set[Integer]
+      # @rbs @transition_function: Hash[[Integer, In], Integer]
+
+      #: (
+      #    Integer initial_state,
+      #    Set[Integer] accept_state_set,
+      #    Hash[[Integer, In], Integer] transition_function
+      #  ) -> void
+      def initialize(initial_state, accept_state_set, transition_function)
+        super()
+
+        @initial_state = initial_state
+        @accept_state_set = accept_state_set
+        @transition_function = transition_function
+      end
+
+      attr_reader :initial_state #: Integer
+      attr_reader :accept_state_set #: Set[Integer]
+      attr_reader :transition_function #: Hash[[Integer, In], Integer]
+
+      #: () -> :dfa
+      def type = :dfa
+
+      # @rbs override
+      def initial_conf = initial_state
+
+      # @rbs override
+      def step_conf(conf, input) = transition_function[[conf, input]]
+
+      # @rbs override
+      def output(conf) = accept_state_set.include?(conf)
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      #: (untyped other) -> bool
+      def ==(other)
+        other.is_a?(DFA) && initial_state == other.initial_state && accept_state_set == other.accept_state_set &&
+          transition_function == other.transition_function
+      end
+
+      # Returns the array of states of this DFA.
+      #
+      # The result array is sorted.
+      #
+      #: () -> Array[Integer]
+      def states
+        state_set = Set.new
+        state_set << initial_state
+        accept_state_set.each { |state| state_set << state }
+        transition_function.each do |(state, _), next_state|
+          state_set << state
+          state_set << next_state
+        end
+        state_set.to_a.sort!
+      end
+
+      # Returns the error state of this DFA.
+      #
+      # An error state is:
+      #
+      # - neither a initial state nor accepting states, and
+      # - only having self-loops for all `input`.
+      #
+      # If an error state is not found, it returns `nil`.
+      #
+      #: () -> (Integer | nil)
+      def error_state
+        transition_function
+          .group_by { |(state, _), _| state }
+          .transform_values { _1.to_h { |(_, input), next_state| [input, next_state] } }
+          .each do |state, transition_hash|
+            # The initial state and accepting states are not an error state.
+            next if state == initial_state || accept_state_set.include?(state)
+
+            # An error state should only have self-loops.
+            next unless transition_hash.all? { |_, next_state| state == next_state }
+
+            return state
+          end
+
+        nil
+      end
+
+      # Returns the shortest word accepted by this DFA.
+      #
+      # If it is not found, it returns `nil`.
+      #
+      #: (Array[In] alphabet) -> (Array[In] | nil)
+      def shortest_accept_word(alphabet)
+        return [] if accept_state_set.include?(initial_state)
+
+        visited = Set.new
+        queue = []
+
+        visited << initial_state
+        queue << [initial_state, []]
+
+        until queue.empty?
+          state, word = queue.shift
+          alphabet.each do |input|
+            next_state = transition_function[[state, input]]
+            return word + [input] if accept_state_set.include?(next_state)
+            unless visited.include?(next_state)
+              visited << next_state
+              queue << [next_state, word + [input]]
+            end
+          end
+        end
+
+        nil
+      end
+
+      # Computes the shortest paths between states.
+      #
+      #: (Array[In] alphabet) -> Hash[[Integer, Integer], Array[In]]
+      def compute_shortest_words(alphabet)
+        states = states()
+
+        shortest_words = {}
+
+        states.each do |state|
+          alphabet.each do |input|
+            next_state = transition_function[[state, input]]
+            shortest_words[[state, next_state]] = [input]
+          end
+
+          shortest_words[[state, state]] = []
+        end
+
+        states.each do |state2|
+          states.each do |state1|
+            states.each do |state3|
+              word12 = shortest_words[[state1, state2]]
+              word23 = shortest_words[[state2, state3]]
+              word13 = shortest_words[[state1, state3]]
+              next unless word12 && word23
+
+              shortest_words[[state1, state3]] = word12 + word23 if !word13 || word12.size + word23.size < word13.size
+            end
+          end
+        end
+
+        shortest_words
+      end
+
+      # Returns a graph of this DFA.
+      #
+      # (?shows_error_state: bool) -> Graph
+      def to_graph(shows_error_state: false)
+        error_state = error_state() unless shows_error_state
+
+        nodes =
+          states
+            .filter_map do |state|
+              next if state == error_state
+              shape = accept_state_set.include?(state) ? :doublecircle : :circle #: Graph::node_shape
+              [state, Graph::Node[state.to_s, shape]]
+            end
+            .to_h
+
+        edges =
+          transition_function.filter_map do |(state, input), next_state|
+            next if state == error_state || next_state == error_state
+            Graph::Edge[state, input.inspect, next_state] # steep:ignore
+          end
+
+        Graph.new(nodes, edges)
+      end
+
+      # Generates a DFA randomly.
+      #
+      #: [In] (
+      #    alphabet: Array[In],
+      #    ?min_state_size: Integer,
+      #    ?max_state_size: Integer,
+      #    ?accept_state_size: Integer,
+      #    ?random: Random,
+      #  ) -> DFA[In]
+      def self.random(alphabet:, min_state_size: 5, max_state_size: 10, accept_state_size: 2, random: Random)
+        transition_function, reachable_paths =
+          TransitionSystem.random_transition_function(
+            alphabet:,
+            min_state_size:,
+            max_state_size:,
+            num_reachable_paths: accept_state_size,
+            random:
+          )
+        accept_state_set = reachable_paths.to_set(&:last) #: Set[Integer]
+
+        new(0, accept_state_set, transition_function)
+      end
+    end
+  end
+end

data/lib/lernen/automaton/mealy.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # Mealy represents a [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine).
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class Mealy < TransitionSystem #[Integer, In, Out]
+      # @rbs @initial_state: Integer
+      # @rbs @transition_function: Hash[[Integer, In], [Out, Integer]]
+
+      #: (
+      #    Integer initial_state,
+      #    Hash[[Integer, In], [Out, Integer]] transition_function
+      #  ) -> void
+      def initialize(initial_state, transition_function)
+        super()
+
+        @initial_state = initial_state
+        @transition_function = transition_function
+      end
+
+      attr_reader :initial_state #: Integer
+      attr_reader :transition_function #: Hash[[Integer, In], [Out, Integer]]
+
+      #: () -> :mealy
+      def type = :mealy
+
+      # @rbs override
+      def initial_conf = initial_state
+
+      # @rbs override
+      def step(conf, input) = transition_function[[conf, input]]
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      #: (untyped other) -> bool
+      def ==(other)
+        other.is_a?(Mealy) && initial_state == other.initial_state && transition_function == other.transition_function
+      end
+
+      # Returns the array of states of this Mealy machine.
+      #
+      # The result array is sorted.
+      #
+      #: () -> Array[Integer]
+      def states
+        state_set = Set.new
+        state_set << initial_state
+        transition_function.each do |(state, _), (_, next_state)|
+          state_set << state
+          state_set << next_state
+        end
+        state_set.to_a.sort!
+      end
+
+      # @rbs override
+      def to_graph
+        nodes = states.to_h { |state| [state, Graph::Node[state.to_s, :circle]] }
+
+        edges =
+          transition_function.map do |(state, input), (output, next_state)|
+            Graph::Edge[state, "#{input.inspect} | #{output.inspect}", next_state] # steep:ignore
+          end
+
+        Graph.new(nodes, edges)
+      end
+
+      # Generates a Mealy machine randomly.
+      #
+      #: [In, Out] (
+      #    alphabet: Array[In],
+      #    output_alphabet: Array[Out],
+      #    ?min_state_size: Integer,
+      #    ?max_state_size: Integer,
+      #    ?num_reachable_paths: Integer,
+      #    ?random: Random,
+      #  ) -> Mealy[In, Out]
+      def self.random(
+        alphabet:,
+        output_alphabet:,
+        min_state_size: 5,
+        max_state_size: 10,
+        num_reachable_paths: 2,
+        random: Random
+      )
+        raw_transition_function, =
+          TransitionSystem.random_transition_function(
+            alphabet:,
+            min_state_size:,
+            max_state_size:,
+            num_reachable_paths:,
+            random:
+          )
+
+        transition_function = {}
+        raw_transition_function.each do |(state, input), next_state|
+          output = output_alphabet.sample(random:)
+          transition_function[[state, input]] = [output, next_state]
+        end
+
+        new(0, transition_function)
+      end
+    end
+  end
+end

data/lib/lernen/automaton/moore.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # Moore represents a [Moore machine](https://en.wikipedia.org/wiki/Moore_machine).
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class Moore < MooreLike #[Integer, In, Out]
+      # @rbs @initial_state: Integer
+      # @rbs @output_function: Hash[Integer, Out]
+      # @rbs @transition_function: Hash[[Integer, In], Integer]
+
+      #: (
+      #    Integer initial_state,
+      #    Hash[Integer, Out] output_function,
+      #    Hash[[Integer, In], Integer] transition_function,
+      #  ) -> void
+      def initialize(initial_state, output_function, transition_function)
+        super()
+
+        @initial_state = initial_state
+        @output_function = output_function
+        @transition_function = transition_function
+      end
+
+      attr_reader :initial_state #: Integer
+      attr_reader :output_function #: Hash[Integer, Out]
+      attr_reader :transition_function #: Hash[[Integer, In], Integer]
+
+      #: () -> :moore
+      def type = :moore
+
+      # @rbs override
+      def initial_conf = initial_state
+
+      # @rbs override
+      def step_conf(conf, input) = transition_function[[conf, input]]
+
+      # @rbs override
+      def output(conf) = output_function[conf]
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      #: (untyped other) -> bool
+      def ==(other)
+        other.is_a?(Moore) && initial_state == other.initial_state && output_function == other.output_function &&
+          transition_function == other.transition_function
+      end
+
+      # Returns the array of states of this Moore machine.
+      #
+      # The result array is sorted.
+      #
+      #: () -> Array[Integer]
+      def states
+        state_set = Set.new
+        state_set << initial_state
+        output_function.each_key { |state| state_set << state }
+        transition_function.each do |(state, _), next_state|
+          state_set << state
+          state_set << next_state
+        end
+        state_set.to_a.sort!
+      end
+
+      # @rbs override
+      def to_graph
+        nodes =
+          states.to_h do |state|
+            [state, Graph::Node["#{state} | #{output_function[state].inspect}", :circle]] # steep:ignore
+          end
+
+        edges =
+          transition_function.map do |(state, input), next_state|
+            Graph::Edge[state, input.inspect, next_state] # steep:ignore
+          end
+
+        Graph.new(nodes, edges)
+      end
+
+      # Generates a Moore machine randomly.
+      #
+      #: [In, Out] (
+      #    alphabet: Array[In],
+      #    output_alphabet: Array[Out],
+      #    ?min_state_size: Integer,
+      #    ?max_state_size: Integer,
+      #    ?num_reachable_paths: Integer,
+      #    ?random: Random,
+      #  ) -> Moore[In, Out]
+      def self.random(
+        alphabet:,
+        output_alphabet:,
+        min_state_size: 5,
+        max_state_size: 10,
+        num_reachable_paths: 2,
+        random: Random
+      )
+        transition_function, =
+          TransitionSystem.random_transition_function(
+            alphabet:,
+            min_state_size:,
+            max_state_size:,
+            num_reachable_paths:,
+            random:
+          )
+
+        output_function = {}
+        transition_function.each do |(state, _), next_state|
+          [state, next_state].each do |state|
+            next if output_function[state]
+            output_function[state] = output_alphabet.sample(random:)
+          end
+        end
+
+        new(0, output_function, transition_function)
+      end
+    end
+  end
+end

data/lib/lernen/automaton/moore_like.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # MooreLike represents a Moore-like transition system.
+    #
+    # This transition system has an output value for each configuration (or state).
+    # Therefore, the following invariant is required for all `conf` and `input`.
+    #
+    # ```ruby
+    # step_output, next_conf = self.step(conf, input)
+    # step_output == self.output(next_conf)
+    # ```
+    #
+    # Note that in this class, the initial output of the `#run` method is lost.
+    # If it is needed, we can use `#run_empty` instead.
+    #
+    # Note that this class is *abstract*. We should implement the following method:
+    #
+    # - `#type`
+    # - `#initial_conf`
+    # - `#step_conf(conf, input)`
+    # - `#output(conf)`
+    #
+    # @rbs generic Conf -- Type for a configuration of this automaton
+    # @rbs generic In   -- Type for input alphabet
+    # @rbs generic Out  -- Type for output values
+    class MooreLike < TransitionSystem #[Conf, In, Out]
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      # Runs a transition from the given configuration with the given input.
+      # It looks like `#step`, but it does not return an output value because
+      # it can be computed by `#output` in this class.
+      #
+      # This is an abstract method.
+      #
+      #: (Conf conf, In innput) -> Conf
+      def step_conf(conf, input)
+        raise TypeError, "abstract method: `step_conf`"
+      end
+
+      # Returns the output value for the given configuration.
+      #
+      # This is an abstract method.
+      #
+      #: (Conf conf) -> Out
+      def output(conf)
+        raise TypeError, "abstract method: `output`"
+      end
+
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # @rbs override
+      def step(conf, input)
+        next_conf = step_conf(conf, input)
+        [output(next_conf), next_conf]
+      end
+
+      # Runs and returns the output value of the transitions for the empty string.
+      #
+      #: () -> Out
+      def run_empty = output(initial_conf)
+
+      # Finds a separating word between `automaton1` and `automaton2`.
+      #
+      #: [Conf, In, Out] (
+      #    Array[In] alphabet,
+      #    MooreLike[Conf, In, Out] automaton1,
+      #    MooreLike[Conf, In, Out] automaton2
+      #  ) -> (Array[In] | nil)
+      def self.find_separating_word(alphabet, automaton1, automaton2)
+        unless automaton2.is_a?(automaton1.class)
+          raise ArgumentError, "Cannot find a separating word for different type automata"
+        end
+
+        return [] if automaton1.run_empty != automaton2.run_empty # steep:ignore
+
+        super
+      end
+    end
+  end
+end