lernen 0.1.0 → 0.3.0

data/lib/lernen/equiv/random_walk_oracle.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # RandomWalkOracle provides an implementation of equivalence query
+    # that finds a counterexample by using random walk.
+    #
+    # This takes two important parameters:
+    #
+    # - `max_steps` (default: `1500`): It is a limit of steps of a random walk.
+    #     If a random walk is tried up to this value and no counterexample is found,
+    #     it returns `nil` finally.
+    # - `reset_prob` (default: `0.09`): It is a probability to reset a random walk.
+    #     On resetting a random walk, it resets a word, but it does not reset
+    #     a step counter.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class RandomWalkOracle < Oracle #[In, Out]
+      # @rbs @alphabet: Array[In]
+      # @rbs @max_steps: Integer
+      # @rbs @reset_prob: Float
+      # @rbs @random: Random
+
+      #: (
+      #    Array[In] alphabet,
+      #    System::SUL[In, Out] sul,
+      #    ?max_steps: Integer,
+      #    ?reset_prob: Float,
+      #    ?random: Random
+      #  ) -> void
+      def initialize(alphabet, sul, max_steps: 3000, reset_prob: 0.09, random: Random)
+        super(sul)
+
+        @alphabet = alphabet
+        @max_steps = max_steps
+        @reset_prob = reset_prob
+        @random = random
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        reset_internal(hypothesis)
+        word = []
+
+        @max_steps.times do
+          if @random.rand < @reset_prob
+            reset_internal(hypothesis)
+            word = []
+          end
+
+          word << @alphabet.sample(random: @random)
+
+          hypothesis_output, sul_output = step_internal(hypothesis, word.last)
+
+          if hypothesis_output != sul_output # steep:ignore
+            @sul.shutdown
+            return word
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/lernen/equiv/random_well_matched_word_oracle.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # RandomWellMatchedWordOracle provides an implementation of equivalence query
+    # that finds a counterexample by using random well-matched word generation.
+    #
+    # This takes three important parameters:
+    #
+    # - `max_words` (default: `100`): It is a limit of number of random words.
+    #     If random words is generated and tried up to this value and no counterexample
+    #     is found, it returns `nil` finally.
+    # - `min_word_size` (default: `2`): It is the minimal size of randomly generated word.
+    #     It should be greater than `0`.
+    # - `max_word_size` (default: `30`): It is the maximal size of randomly generated word.
+    #     It should be greater than or equal to `min_word_size`.
+    # - `call_prob` (default: `0.1`): It is a probability to generate call and return subwords.
+    # - `initial_proc` (default `nil`): It is the initial proc character.
+    #     If it is specified, the generated words must be started with it.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    # @rbs generic Out    -- Type for output values
+    class RandomWellMatchedWordOracle < Oracle #[In | Call | Return, Out]
+      # @rbs @alphabet: Array[In]
+      # @rbs @call_alphabet: Array[Call]
+      # @rbs @return_alphabet: Array[Return]
+      # @rbs @max_words: Integer
+      # @rbs @min_word_size: Integer
+      # @rbs @max_word_size: Integer
+      # @rbs @call_prob: Float
+      # @rbs @initial_proc: Call | nil
+      # @rbs @random: Random
+
+      #: (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    Array[Return] return_alphabet,
+      #    System::SUL[In | Call | Return, Out] sul,
+      #    ?max_words: Integer,
+      #    ?min_word_size: Integer,
+      #    ?max_word_size: Integer,
+      #    ?call_prob: Float,
+      #    ?initial_proc: Call | nil,
+      #    ?random: Random
+      #  ) -> void
+      def initialize(
+        alphabet,
+        call_alphabet,
+        return_alphabet,
+        sul,
+        max_words: 100,
+        min_word_size: 2,
+        max_word_size: 30,
+        call_prob: 0.5,
+        initial_proc: nil,
+        random: Random
+      )
+        super(sul)
+
+        @alphabet = alphabet
+        @call_alphabet = call_alphabet
+        @return_alphabet = return_alphabet
+        @max_words = max_words
+        @min_word_size = min_word_size
+        @max_word_size = max_word_size
+        @call_prob = call_prob
+        @initial_proc = initial_proc
+        @random = random
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        @max_words.times do
+          reset_internal(hypothesis)
+
+          word = generate_word
+          word.each_with_index do |input, index|
+            hypothesis_output, sul_output = step_internal(hypothesis, input)
+
+            if hypothesis_output != sul_output # steep:ignore
+              @sul.shutdown
+              return word[0..index]
+            end
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      #: () -> Array[In | Call | Return]
+      def generate_word
+        word_size = @random.rand(@min_word_size..@max_word_size)
+
+        word = []
+        initial_proc = @initial_proc
+        if initial_proc
+          word << initial_proc
+          generate_word_internal(word, word_size - 2)
+          word << @return_alphabet.sample(random: @random)
+          return word
+        end
+
+        generate_word_internal(word, word_size)
+        word
+      end
+
+      #: (Array[In | Call | Return] word, Integer word_size) -> void
+      def generate_word_internal(word, word_size)
+        return if word_size <= 0
+
+        if word_size == 1
+          word << @alphabet.sample(random: @random) # steep:ignore
+          return
+        end
+
+        if @random.rand < @call_prob
+          call_index = @random.rand(0...word_size - 1)
+          generate_word_internal(word, call_index)
+          word << @call_alphabet.sample(random: @random) # steep:ignore
+          return_index = call_index + 1 + @random.rand(0...word_size - call_index - 1)
+          generate_word_internal(word, return_index - call_index - 1)
+          word << @return_alphabet.sample(random: @random) # steep:ignore
+          generate_word_internal(word, word_size - return_index - 1)
+        else
+          split_size = @random.rand(1...word_size)
+          generate_word_internal(word, split_size)
+          generate_word_internal(word, word_size - split_size)
+        end
+      end
+    end
+  end
+end

data/lib/lernen/equiv/random_word_oracle.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # RandomWordOracle provides an implementation of equivalence query
+    # that finds a counterexample by using random word generation.
+    #
+    # This takes three important parameters:
+    #
+    # - `max_words` (default: `100`): It is a limit of number of random words.
+    #     If random words is generated and tried up to this value and no counterexample
+    #     is found, it returns `nil` finally.
+    # - `min_word_size` (default: `1`): It is the minimal size of randomly generated word.
+    #     It should be greater than `0`.
+    # - `max_word_size` (default: `30`): It is the maximal size of randomly generated word.
+    #     It should be greater than or equal to `min_word_size`.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class RandomWordOracle < Oracle #[In, Out]
+      # @rbs @alphabet: Array[In]
+      # @rbs @max_word: Integer
+      # @rbs @min_word_size: Integer
+      # @rbs @max_word_size: Integer
+      # @rbs @random: Random
+
+      #: (
+      #    Array[In] alphabet,
+      #    System::SUL[In, Out] sul,
+      #    ?max_words: Integer,
+      #    ?min_word_size: Integer,
+      #    ?max_word_size: Integer,
+      #    ?random: Random,
+      #  ) -> void
+      def initialize(alphabet, sul, max_words: 100, min_word_size: 1, max_word_size: 30, random: Random)
+        super(sul)
+
+        @alphabet = alphabet
+        @max_words = max_words
+        @min_word_size = min_word_size
+        @max_word_size = max_word_size
+        @random = random
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        @max_words.times do
+          reset_internal(hypothesis)
+          word = []
+
+          word_size = @random.rand(@min_word_size..@max_word_size)
+          word_size.times do
+            word << @alphabet.sample(random: @random)
+
+            hypothesis_output, sul_output = step_internal(hypothesis, word.last)
+
+            if hypothesis_output != sul_output # steep:ignore
+              @sul.shutdown
+              return word
+            end
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/lernen/equiv/spa_simulator_oracle.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # SPASimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the SPA.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    class SPASimulatorOracle < Oracle #[In | Call | Return, bool]
+      # @rbs @alphabet: Array[In]
+      # @rbs @call_alphabet: Array[Call]
+      # @rbs @spa: Automaton::SPA[In, Call, Return]
+
+      #: (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    Automaton::SPA[In, Call, Return] spa,
+      #    System::SUL[In | Call | Return, bool] sul
+      #  ) -> void
+      def initialize(alphabet, call_alphabet, spa, sul)
+        super(sul)
+
+        @alphabet = alphabet
+        @call_alphabet = call_alphabet
+        @spa = spa
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        Automaton::SPA.find_separating_word(@alphabet, @call_alphabet, @spa, hypothesis) # steep:ignore
+      end
+    end
+  end
+end

data/lib/lernen/equiv/test_words_oracle.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # TestWordsOracle provides an implementation of equivalence query
+    # that find a counterexample from the given words.
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class TestWordsOracle < Oracle #[In, Out]
+      # @rbs @words: Array[Array[In]]
+
+      #: (Array[Array[In]] words, System::SUL[In, Out] sul) -> void
+      def initialize(words, sul)
+        super(sul)
+
+        @words = words
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        @words.each do |word|
+          reset_internal(hypothesis)
+
+          word.each_with_index do |input, index|
+            hypothesis_output, sul_output = step_internal(hypothesis, input)
+
+            if hypothesis_output != sul_output # steep:ignore
+              @sul.shutdown
+              return word[0..index]
+            end
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/lernen/equiv/transition_system_simulator_oracle.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # TransitionSystemSimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the transition system.
+    #
+    # @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 TransitionSystemSimulatorOracle < Oracle #[In, Out]
+      # @rbs @alphabet: Array[In]
+      # @rbs @automaton: Automaton::TransitionSystem[Conf, In, Out]
+
+      #: (
+      #    Array[In] alphabet,
+      #    Automaton::TransitionSystem[Conf, In, Out] spa,
+      #    System::SUL[In, Out] sul
+      #  ) -> void
+      def initialize(alphabet, automaton, sul)
+        super(sul)
+
+        @alphabet = alphabet
+        @automaton = automaton
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        Automaton::TransitionSystem.find_separating_word(@alphabet, @automaton, hypothesis)
+      end
+    end
+  end
+end

data/lib/lernen/equiv/vpa_simulator_oracle.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # VPASimulatorOracle provides an implementation of equivalence query
+    # that finds a counterexample by simulating the VPA.
+    #
+    # @rbs generic In     -- Type for input alphabet
+    # @rbs generic Call   -- Type for call alphabet
+    # @rbs generic Return -- Type for return alphabet
+    class VPASimulatorOracle < Oracle #[In | Call | Return, bool]
+      # @rbs @alphabet: Array[In]
+      # @rbs @call_alphabet: Array[Call]
+      # @rbs @return_alphabet: Array[Return]
+      # @rbs @spa: Automaton::VPA[In, Call, Return]
+
+      #: (
+      #    Array[In] alphabet,
+      #    Array[Call] call_alphabet,
+      #    Array[Return] return_alphabet,
+      #    Automaton::VPA[In, Call, Return] vpa,
+      #    System::SUL[In | Call | Return, bool] sul
+      #  ) -> void
+      def initialize(alphabet, call_alphabet, return_alphabet, vpa, sul)
+        super(sul)
+
+        @alphabet = alphabet
+        @call_alphabet = call_alphabet
+        @return_alphabet = return_alphabet
+        @vpa = vpa
+      end
+
+      # @rbs override
+      def find_cex(hypothesis)
+        super
+
+        Automaton::VPA.find_separating_word(
+          @alphabet,
+          @call_alphabet,
+          @return_alphabet,
+          @vpa,
+          hypothesis # steep:ignore
+        )
+      end
+    end
+  end
+end

data/lib/lernen/equiv.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  # This is a namespace for equivalence query oracles.
+  #
+  # A equivalence query check the given hypothesis automaton is equivalence
+  # to a SUL. If that is not, it returns a counterexample, which leads
+  # different output values between the hypothesis and the SUL.
+  module Equiv
+  end
+end
+
+require "lernen/equiv/oracle"
+
+require "lernen/equiv/combined_oracle"
+require "lernen/equiv/exhaustive_search_oracle"
+require "lernen/equiv/test_words_oracle"
+require "lernen/equiv/random_walk_oracle"
+require "lernen/equiv/random_word_oracle"
+require "lernen/equiv/random_well_matched_word_oracle"
+require "lernen/equiv/transition_system_simulator_oracle"
+require "lernen/equiv/moore_like_simulator_oracle"
+require "lernen/equiv/vpa_simulator_oracle"
+require "lernen/equiv/spa_simulator_oracle"

data/lib/lernen/graph.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  # Graph represents a labelled directed graph.
+  #
+  # This is an intermediate data structure for rendering Mermaid and Graphviz diagrams.
+  class Graph
+    # @rbs!
+    #   type node_shape = :circle | :doublecircle
+    #
+    #   type mermaid_direction = "TD" | "DT" | "LR" | "RL"
+
+    # Node represents a node of graphs.
+    #
+    # @rbs skip
+    Node = Data.define(:label, :shape)
+
+    # @rbs!
+    #   class Node < Data
+    #     attr_reader label: String
+    #     attr_reader shape: node_shape
+    #     def self.[]: (String label, node_shape shape) -> Node
+    #   end
+
+    # Edge represents an edge of graphs.
+    #
+    # @rbs skip
+    Edge = Data.define(:from, :label, :to)
+
+    # @rbs!
+    #   class Edge < Data
+    #     attr_reader from: Integer
+    #     attr_reader label: String
+    #     attr_reader to: Integer
+    #     def self.[]: (Integer from, String label, Integer to) -> Edge
+    #   end
+
+    # SubGraph represents a sub-graph of graphs.
+    #
+    # @rbs skip
+    SubGraph = Data.define(:label, :graph)
+
+    # @rbs!
+    #   class SubGraph < Data
+    #     attr_reader label: String
+    #     attr_reader graph: Graph
+    #     def self.[]: (String label, Graph graph) -> SubGraph
+    #   end
+
+    # Returns the escaped string for Mermaid diagrams.
+    #
+    # See https://mermaid.js.org/syntax/flowchart.html#entity-codes-to-escape-characters.
+    #
+    #: (String label) -> String
+    def self.mermaid_escape(label)
+      label =
+        label.gsub(/[#"]/) do |c|
+          case c
+          in "#"
+            "#35;"
+          in "\""
+            "#quot;"
+          end
+        end
+      "\"#{label}\""
+    end
+
+    # Returns the escaped string for GraphViz DOTs.
+    #
+    # See https://graphviz.org/docs/attr-types/escString/.
+    #
+    #: (String label) -> String
+    def self.dot_escape(label)
+      label =
+        label.gsub(/[\\"]/) do |c|
+          case c
+          in "\\"
+            "\\\\"
+          in "\""
+            "\\\""
+          end
+        end
+      "\"#{label}\""
+    end
+
+    # @rbs @nodes: Hash[Integer, Node]
+    # @rbs @edges: Array[Edge]
+    # @rbs @subgraphs: Array[SubGraph]
+
+    #: (
+    #    Hash[Integer, Node] nodes,
+    #    Array[Edge] edges,
+    #    ?Array[SubGraph] subgraphs
+    #  ) -> void
+    def initialize(nodes, edges, subgraphs = [])
+      @nodes = nodes
+      @edges = edges
+      @subgraphs = subgraphs
+    end
+
+    attr_reader :nodes #: Hash[Integer, Node]
+    attr_reader :edges #: Array[Edge]
+    attr_reader :subgraphs #: Array[SubGraph]
+
+    # Returns a [Mermaid](https://mermaid.js.org) diagram of this graph.
+    #
+    #: (?direction: mermaid_direction) -> String
+    def to_mermaid(direction: "TD")
+      mmd = +""
+
+      mmd << "flowchart #{direction}\n"
+      mmd << to_mermaid_internal
+
+      mmd.freeze
+    end
+
+    # Returns a [GraphViz](https://graphviz.org) DOT diagram of this graph.
+    #
+    #: () -> String
+    def to_dot
+      dot = +""
+
+      dot << "digraph {\n"
+      dot << to_dot_internal
+      dot << "}\n"
+
+      dot.freeze
+    end
+
+    protected
+
+    #: (?String id_prefix) -> String
+    def to_mermaid_internal(id_prefix = "")
+      mmd = +""
+      needs_sep = false
+
+      nodes.each do |id, node|
+        needs_sep = true
+
+        node_def =
+          case node.shape
+          in :circle
+            "((#{Graph.mermaid_escape(node.label)}))"
+          in :doublecircle
+            "(((#{Graph.mermaid_escape(node.label)})))"
+          end
+        mmd << "  #{id_prefix}#{id}#{node_def}\n"
+      end
+      mmd << "\n" if needs_sep
+
+      edges.each do |edge|
+        needs_sep = true
+
+        from = "#{id_prefix}#{edge.from}"
+        to = "#{id_prefix}#{edge.to}"
+        mmd << "  #{from} -- #{Graph.mermaid_escape(edge.label)} --> #{to}\n"
+      end
+
+      subgraphs.each_with_index do |subgraph, index|
+        mmd << "\n" if needs_sep
+        needs_sep = true
+
+        subgraph_id = "#{id_prefix}g#{index}"
+        mmd << "  subgraph #{subgraph_id}[#{Graph.mermaid_escape(subgraph.label)}]\n"
+        subgraph
+          .graph
+          .to_mermaid_internal("#{subgraph_id}_")
+          .lines
+          .each { |line| mmd << (line == "\n" ? line : "  #{line}") }
+        mmd << "  end\n"
+      end
+
+      mmd.freeze
+    end
+
+    #: (?String id_prefix) -> String
+    def to_dot_internal(id_prefix = "")
+      dot = +""
+      needs_sep = false
+
+      nodes.each do |index, node|
+        needs_sep = true
+
+        dot << "  #{id_prefix}#{index} [label=#{Graph.dot_escape(node.label)}, shape=#{node.shape}];\n"
+      end
+      dot << "\n" if needs_sep
+
+      edges.each do |edge|
+        needs_sep = true
+
+        from = "#{id_prefix}#{edge.from}"
+        to = "#{id_prefix}#{edge.to}"
+        dot << "  #{from} -> #{to} [label=#{Graph.dot_escape(edge.label)}];\n"
+      end
+
+      subgraphs.each_with_index do |subgraph, index|
+        dot << "\n" if needs_sep
+        needs_sep = true
+
+        subgraph_id = "#{id_prefix}g#{index}"
+        dot << "  subgraph cluster_#{subgraph_id} {\n"
+        dot << "    label=#{Graph.dot_escape(subgraph.label)};\n"
+        subgraph
+          .graph
+          .to_dot_internal("#{subgraph_id}_")
+          .lines
+          .each { |line| dot << (line == "\n" ? line : "  #{line}") }
+        dot << "  }\n"
+      end
+
+      dot.freeze
+    end
+  end
+end