lernen 0.1.0 → 0.3.0

data/lib/lernen/automaton/proc_util.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # ProcUtil provides utility functions for words in `SPA`.
+    module ProcUtil
+      #: [In, Call, Return] (
+      #    Return return_input,
+      #    Array[In | Call] word,
+      #    Hash[Call, Array[In | Call | Return]] proc_to_terminating_sequence,
+      #  ) -> Array[In | Call | Return]
+      def self.expand(return_input, word, proc_to_terminating_sequence)
+        expanded_word = []
+        word.each do |input|
+          terminating_sequence = proc_to_terminating_sequence[input] # steep:ignore
+          if terminating_sequence
+            expanded_word << input
+            expanded_word.concat(terminating_sequence)
+            expanded_word << return_input
+          else
+            expanded_word << input
+          end
+        end
+        expanded_word
+      end
+
+      #: [In, Call, Return] (
+      #    Set[Call] call_alphabet_set,
+      #    Return return_input,
+      #    Array[In | Call | Return] word
+      #  ) -> Array[In | Call]
+      def self.project(call_alphabet_set, return_input, word)
+        projected_word = []
+        index = 0
+        while index < word.size
+          input = word[index]
+          projected_word << input
+          if call_alphabet_set.include?(input) # steep:ignore
+            return_index = find_return_index(call_alphabet_set, return_input, word, index + 1)
+            index = return_index if return_index
+          end
+          index += 1
+        end
+        projected_word
+      end
+
+      #: [In, Call, Return] (
+      #    Set[Call] call_alphabet_set,
+      #    Return return_input,
+      #    Array[In | Call | Return] word,
+      #    Integer index
+      #  ) -> (Integer | nil)
+      def self.find_call_index(call_alphabet_set, return_input, word, index)
+        balance = 0
+
+        (index - 1).downto(0) do |i|
+          input = word[i]
+          if input == return_input # steep:ignore
+            balance += 1
+          elsif call_alphabet_set.include?(input) # steep:ignore
+            return i if balance == 0
+            balance -= 1
+          end
+        end
+
+        nil
+      end
+
+      #: [In, Call, Return] (
+      #    Set[Call] call_alphabet_set,
+      #    Return return_input,
+      #    Array[In | Call | Return] word,
+      #    Integer index
+      #  ) -> (Integer | nil)
+      def self.find_return_index(call_alphabet_set, return_input, word, index)
+        balance = 0
+
+        (index...word.size).each do |i|
+          input = word[i]
+          if call_alphabet_set.include?(input) # steep:ignore
+            balance += 1
+          elsif input == return_input # steep:ignore
+            return i if balance == 0
+            balance -= 1
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/lernen/automaton/spa.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # SPA represents a system of procedural automata.
+    #
+    # Note that this class takes `return_input` as the return symbol because
+    # this value is necessary to run this kind of automata correctly.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    class SPA < MooreLike #[SPA::conf[Call], In | Call | Return, bool]
+      # Conf is a configuration of SPA run.
+      #
+      # @rbs skip
+      Conf = Data.define(:prev, :proc, :state)
+
+      # @rbs!
+      #   class Conf[Call] < Data
+      #     attr_reader prev: conf[Call]
+      #     attr_reader proc: Call
+      #     attr_reader state: Integer
+      #     def self.[]: [Call] (
+      #       conf[Call] prev,
+      #       Call proc,
+      #       Integer state
+      #     ) -> Conf[Call]
+      #   end
+      #
+      #   type conf[Call] = Conf[Call] | :init | :term | :sink
+
+      # @rbs @initial_proc: Call
+      # @rbs @proc_to_dfa: Hash[Call, DFA[In | Call]]
+
+      #: (
+      #    Call initial_proc,
+      #    Return return_input,
+      #    Hash[Call, DFA[In | Call]] proc_to_dfa
+      #  ) -> void
+      def initialize(initial_proc, return_input, proc_to_dfa)
+        super()
+
+        @initial_proc = initial_proc
+        @return_input = return_input
+        @proc_to_dfa = proc_to_dfa
+      end
+
+      attr_reader :initial_proc #: Call
+      attr_reader :return_input #: Return
+      attr_reader :proc_to_dfa #: Hash[Call, DFA[In | Call]]
+
+      #: () -> :spa
+      def type = :spa
+
+      # @rbs override
+      def initial_conf = :init
+
+      # @rbs override
+      def step_conf(conf, input)
+        case conf
+        in :init
+          if input == initial_proc
+            dfa = proc_to_dfa[initial_proc]
+            Conf[:term, initial_proc, dfa.initial_state]
+          else
+            :sink
+          end
+        in :term | :sink
+          :sink
+        in Conf[prev, proc, state]
+          dfa = proc_to_dfa[proc]
+
+          next_state = dfa.transition_function[[state, input]]
+          if next_state
+            next_dfa = proc_to_dfa[input]
+            if next_dfa
+              return_conf = Conf[prev, proc, next_state]
+              return Conf[return_conf, input, next_dfa.initial_state]
+            end
+
+            return Conf[prev, proc, next_state]
+          end
+
+          input == return_input && dfa.accept_state_set.include?(state) ? prev : :sink
+        end
+      end
+
+      # @rbs override
+      def output(conf) = conf == :term
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      #: (untyped other) -> bool
+      def ==(other)
+        other.is_a?(SPA) && initial_proc == other.initial_proc && return_input == other.return_input && # steep:ignore
+          proc_to_dfa == other.proc_to_dfa
+      end
+
+      # @rbs override
+      def to_graph
+        subgraphs =
+          proc_to_dfa.map do |proc, dfa|
+            Graph::SubGraph[proc.inspect, dfa.to_graph] # steep:ignore
+          end
+
+        Graph.new({}, [], subgraphs)
+      end
+
+      # Returns the mapping from procedure names to access/terminating/return sequences.
+      #
+      #: (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet
+      #  ) -> [
+      #    Hash[Call, Array[In | Call | Return]],
+      #    Hash[Call, Array[In | Call | Return]],
+      #    Hash[Call, Array[In | Call | Return]]
+      #  ]
+      def proc_to_atr_sequence(alphabet, call_alphabet)
+        proc_to_terminating_sequence = compute_proc_to_terminating_sequence(alphabet, call_alphabet)
+        proc_to_access_sequence, proc_to_return_sequence =
+          compute_proc_to_access_and_return_sequences(alphabet, call_alphabet, proc_to_terminating_sequence)
+        [proc_to_access_sequence, proc_to_terminating_sequence, proc_to_return_sequence]
+      end
+
+      # Finds a separating word between `spa1` and `spa2`.
+      #
+      # This method assume return symbols for two SPAs are the same.
+      # If they are not, this raises `ArgumentError`.
+      #
+      #: [In, Call, Return] (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    SPA[In, Call, Return] spa1,
+      #    SPA[In, Call, Return] spa2
+      #  ) -> (Array[In | Call | Return] | nil)
+      def self.find_separating_word(alphabet, call_alphabet, spa1, spa2)
+        raise ArgumentError, "Cannot find a separating word for different type automata" unless spa2.is_a?(spa1.class)
+        unless spa1.return_input == spa2.return_input # steep:ignore
+          raise ArgumentError, "Return symbols for two SPAs are different"
+        end
+
+        as1, ts1, rs1 = spa1.proc_to_atr_sequence(alphabet, call_alphabet)
+        as2, ts2, rs2 = spa2.proc_to_atr_sequence(alphabet, call_alphabet)
+
+        local_alphabet = alphabet.dup
+        local_alphabet.concat((ts1.keys.to_set & ts2.keys.to_set).to_a) # steep:ignore
+
+        call_alphabet.each do |proc|
+          dfa1 = spa1.proc_to_dfa[proc]
+          dfa2 = spa2.proc_to_dfa[proc]
+          next if !dfa1 && !dfa2
+
+          a1 = as1[proc]
+          t1 = ts1[proc]
+          r1 = rs1[proc]
+
+          a2 = as2[proc]
+          t2 = ts2[proc]
+          r2 = rs2[proc]
+
+          case
+          when dfa1 && !dfa2
+            return a1 + t1 + r1 if a1 && t1 && r1
+            next
+          when !dfa1 && dfa2
+            return a2 + t2 + r2 if a2 && t2 && r2
+            next
+          end
+
+          # Then, `dfa1 && dfa2` holds.
+          next unless a1 && t1 && r1 && a2 && t2 && r2
+
+          sep_word = DFA.find_separating_word(local_alphabet, dfa1, dfa2)
+          next unless sep_word
+
+          as, ts, rs = dfa1.output(dfa1.run(sep_word)[1]) ? [as1, ts1, rs1] : [as2, ts2, rs2]
+          sep_word = ProcUtil.expand(spa1.return_input, sep_word, ts)
+          return as[proc] + sep_word + rs[proc]
+        end
+
+        nil
+      end
+
+      # Generates a SPA randomly.
+      #
+      #: [In, Call, Return] (
+      #    alphabet: Array[In],
+      #    call_alphabet: Array[Call],
+      #    return_input: Return,
+      #    ?min_proc_size: Integer,
+      #    ?max_proc_size: Integer,
+      #    ?dfa_min_state_size: Integer,
+      #    ?dfa_max_state_size: Integer,
+      #    ?dfa_accept_state_size: Integer,
+      #    ?random: Random,
+      #  ) -> SPA[In, Call, Return]
+      def self.random(
+        alphabet:,
+        call_alphabet:,
+        return_input:,
+        min_proc_size: 1,
+        max_proc_size: call_alphabet.size,
+        dfa_min_state_size: 5,
+        dfa_max_state_size: 10,
+        dfa_accept_state_size: 2,
+        random: Random
+      )
+        proc_size = random.rand(min_proc_size..max_proc_size)
+        procs = call_alphabet.dup.shuffle!(random:)[0...proc_size]
+
+        initial_proc = procs[0] # steep:ignore
+        proc_to_dfa = {}
+        procs.each do |proc| # steep:ignore
+          proc_to_dfa[proc] = DFA.random(
+            alphabet: alphabet + procs, # steep:ignore
+            random:,
+            min_state_size: dfa_min_state_size,
+            max_state_size: dfa_max_state_size,
+            accept_state_size: dfa_accept_state_size
+          )
+        end
+
+        new(initial_proc, return_input, proc_to_dfa)
+      end
+
+      private
+
+      # Returns the mapping from procedure names to terminating sequences.
+      #
+      #: (Array[In] alphabet, Array[Call] call_alphabet) -> Hash[Call, Array[In | Call | Return]]
+      def compute_proc_to_terminating_sequence(alphabet, call_alphabet)
+        proc_to_terminating_sequence = {}
+
+        call_alphabet.each do |proc|
+          dfa = proc_to_dfa[proc]
+          next unless dfa
+          terminating_sequence = dfa.shortest_accept_word(alphabet)
+          next unless terminating_sequence
+          proc_to_terminating_sequence[proc] = terminating_sequence
+        end
+
+        remaining_proc_set = call_alphabet.to_set
+        remaining_proc_set.subtract(proc_to_terminating_sequence.keys)
+
+        eligible_alphabet = alphabet.dup
+        eligible_alphabet.concat(proc_to_terminating_sequence.keys)
+
+        stable = false
+        until stable
+          stable = true
+
+          remaining_proc_set.each do |proc|
+            dfa = proc_to_dfa[proc]
+
+            unless dfa
+              remaining_proc_set.delete(proc)
+              next
+            end
+
+            terminating_sequence = dfa.shortest_accept_word(eligible_alphabet)
+            next unless terminating_sequence
+
+            proc_to_terminating_sequence[proc] = ProcUtil.expand(
+              return_input,
+              terminating_sequence,
+              proc_to_terminating_sequence
+            )
+            remaining_proc_set.delete(proc)
+            eligible_alphabet << proc # steep:ignore
+
+            stable = false
+          end
+        end
+
+        proc_to_terminating_sequence
+      end
+
+      # Returns the mapping from procedure names to access and return sequences.
+      #
+      #: (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    Hash[Call, Array[In | Call | Return]] proc_to_terminating_sequence
+      #  ) -> [Hash[Call, Array[In | Call | Return]], Hash[Call, Array[In | Call | Return]]]
+      def compute_proc_to_access_and_return_sequences(alphabet, call_alphabet, proc_to_terminating_sequence)
+        return {}, {} unless proc_to_dfa[initial_proc]
+
+        proc_to_access_sequence = {}
+        proc_to_return_sequence = {}
+
+        proc_to_access_sequence[initial_proc] = [initial_proc]
+        proc_to_return_sequence[initial_proc] = [return_input]
+
+        found_call_alphabet = [initial_proc]
+        unfound_call_alphabet_set = call_alphabet.to_set
+        unfound_call_alphabet_set.delete(initial_proc)
+
+        stable = false
+        until stable
+          stable = true
+
+          found_call_alphabet.each do |found_proc|
+            dfa = proc_to_dfa[found_proc]
+
+            proc_to_access_and_return_word =
+              explore_proc_to_access_and_return_word(dfa, alphabet, found_call_alphabet, unfound_call_alphabet_set)
+            proc_to_access_and_return_word.each do |proc, (i2s, n2a)|
+              access_sequence = []
+              access_sequence.concat(proc_to_access_sequence[found_proc])
+              access_sequence.concat(ProcUtil.expand(return_input, i2s, proc_to_terminating_sequence))
+              access_sequence << proc
+              proc_to_access_sequence[proc] = access_sequence
+
+              return_sequence = []
+              return_sequence << return_input
+              return_sequence.concat(ProcUtil.expand(return_input, n2a, proc_to_terminating_sequence))
+              return_sequence.concat(proc_to_return_sequence[found_proc])
+              proc_to_return_sequence[proc] = return_sequence
+
+              found_call_alphabet << proc
+              unfound_call_alphabet_set.delete(proc)
+
+              stable = false
+            end
+          end
+        end
+
+        [proc_to_access_sequence, proc_to_return_sequence]
+      end
+
+      #: (
+      #    DFA[In | Call] dfa,
+      #    Array[In] alphabet,
+      #    Array[Call] found_call_alphabet,
+      #    Set[Call] unfound_call_alphabet_set
+      #  ) -> Hash[Call, [Array[In | Call], Array[In | Call]]]
+      def explore_proc_to_access_and_return_word(dfa, alphabet, found_call_alphabet, unfound_call_alphabet_set)
+        states = dfa.states
+        shortest_words = dfa.compute_shortest_words(alphabet + found_call_alphabet)
+
+        proc_to_access_and_return_word = {}
+        unfound_call_alphabet_set.each do |proc|
+          found = false
+          states.each do |state|
+            next_state = dfa.transition_function[[state, proc]]
+            i2s = shortest_words[[dfa.initial_state, state]]
+            next unless i2s
+
+            dfa.accept_state_set.each do |accept_state|
+              n2a = shortest_words[[next_state, accept_state]]
+              next unless n2a
+
+              proc_to_access_and_return_word[proc] = [i2s, n2a]
+              found = true
+              break
+            end
+            break if found
+          end
+        end
+
+        proc_to_access_and_return_word
+      end
+    end
+  end
+end

data/lib/lernen/automaton/transition_system.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Automaton
+    # TransitionSystem represents a labelled transition system.
+    #
+    # We assume that this transition system is *deterministic* and *complete*;
+    # thus, the transition function should be defined for all states and input
+    # characters, and the destination configuration of a transition should be one.
+    #
+    # Also, this transition system has an output value for each transition. From
+    # this point of view, this definition is much like Mealy machines. However,
+    # this class is more generic. Actually, this is a superclass of Moore machines,
+    # DFA, etc.
+    #
+    # Note that this class is *abstract*. We should implement the following method:
+    #
+    # - `#type`
+    # - `#initial_conf`
+    # - `#step(conf, input)`
+    # - `#to_graph`
+    #
+    # @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 TransitionSystem
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      # Returns the automaton type.
+      #
+      # This is an abstract method.
+      #
+      #: () -> transition_system_type
+      def type
+        raise TypeError, "abstract method: `type`"
+      end
+
+      # Returns the initial configuration.
+      #
+      # This is an abstract method.
+      #
+      #: () -> Conf
+      def initial_conf
+        raise TypeError, "abstract method: `initial_conf`"
+      end
+
+      # Runs a transition from the given configuration with the given input.
+      #
+      # It returns a pair of the output value and the next configuration of
+      # this transition.
+      #
+      # This is an abstract method.
+      #
+      #: (Conf conf, In input) -> [Out, Conf]
+      def step(conf, input)
+        raise TypeError, "abstract method: `step`"
+      end
+
+      # Returns a graph of this transition system.
+      #
+      # This is an abstract method.
+      #
+      #: () -> Graph
+      def to_graph
+        raise TypeError, "abstract method: `to_graph`"
+      end
+
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # Runs transitions from the initial configuration with the given word.
+      #
+      # It returns a pair of the output values and the final configuration of
+      # the transitions.
+      #
+      #: (Array[In] word) -> [Array[Out], Conf]
+      def run(word)
+        conf = initial_conf
+        outputs = []
+        word.each do |input|
+          output, conf = step(conf, input)
+          outputs << output
+        end
+        [outputs, conf]
+      end
+
+      # Returns a [Mermaid](https://mermaid.js.org) diagram of this transition system.
+      #
+      #: (?direction: Graph::mermaid_direction) -> String
+      def to_mermaid(direction: "TD") = to_graph.to_mermaid(direction:)
+
+      # Returns a [GraphViz](https://graphviz.org) DOT diagram of this transition system.
+      #
+      #: () -> String
+      def to_dot = to_graph.to_dot
+
+      # Finds a separating word between `automaton1` and `automaton2`.
+      #
+      #: [Conf, In, Out] (
+      #    Array[In] alphabet,
+      #    TransitionSystem[Conf, In, Out] automaton1,
+      #    TransitionSystem[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
+        queue = []
+        prefix_hash = {}
+
+        initial_pair = [automaton1.initial_conf, automaton2.initial_conf]
+        queue << initial_pair
+        prefix_hash[initial_pair] = []
+
+        until queue.empty?
+          conf1, conf2 = queue.shift
+          prefix = prefix_hash[[conf1, conf2]]
+
+          alphabet.each do |input|
+            word = prefix + [input]
+
+            output1, next_conf1 = automaton1.step(conf1, input)
+            output2, next_conf2 = automaton2.step(conf2, input)
+
+            return word if output1 != output2 # steep:ignore
+
+            next_pair = [next_conf1, next_conf2]
+            unless prefix_hash.include?(next_pair)
+              queue << next_pair
+              prefix_hash[next_pair] = word
+            end
+          end
+        end
+
+        nil
+      end
+
+      # Generates a transition function randomly.
+      #
+      # To make a transition function connected, this method generates
+      # a transition function in the following mannar.
+      #
+      # 1. Decide a number of states within `min_state_size..max_state_size` randomly.
+      # 2. Divides the states into `num_reachable_paths` partitions.
+      # 3. Generate a path from the initial state for each paratition.
+      # 4. Generate transition for all `state` and `input`.
+      #
+      # This method returns a pair of a transition function and an array of reachable paths.
+      # The initial state of the result transition function is `0`.
+      #
+      #: [In] (
+      #    alphabet: Array[In],
+      #    ?min_state_size: Integer,
+      #    ?max_state_size: Integer,
+      #    ?num_reachable_paths: Integer,
+      #    ?random: Random,
+      #  ) -> [Hash[[Integer, In], Integer], Array[Array[Integer]]]
+      def self.random_transition_function(
+        alphabet:,
+        min_state_size: 5,
+        max_state_size: 10,
+        num_reachable_paths: 2,
+        random: Random
+      )
+        state_size = random.rand(min_state_size..max_state_size)
+        num_reachable_paths = [num_reachable_paths, alphabet.size, state_size].min #: Integer
+
+        initial_state = 0
+        reachable_paths = []
+        transition_function = {}
+
+        partitions = (0...state_size).to_a + ([nil] * (num_reachable_paths - 1))
+        partitions.shuffle!(random:)
+        partitions.push(nil)
+
+        initial_alphabet = alphabet.dup
+        initial_alphabet.shuffle!(random:)
+
+        until partitions.empty?
+          reachable_path = [initial_state]
+          state = initial_state
+          input = initial_alphabet.shift
+          loop do
+            next_state = partitions.shift
+            break if next_state.nil?
+            next if next_state == initial_state
+
+            reachable_path << next_state
+
+            transition_function[[state, input]] = next_state
+
+            input = alphabet.sample(random:)
+          end
+          reachable_paths << reachable_path
+        end
+
+        state_size.times do |state|
+          alphabet.each do |input|
+            next if transition_function[[state, input]]
+            next_state = random.rand(state_size)
+            transition_function[[state, input]] = next_state
+          end
+        end
+
+        [transition_function, reachable_paths]
+      end
+    end
+  end
+end