lernen 0.2.0 → 0.3.0

data/lib/lernen/equiv/oracle.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Lernen
+  module Equiv
+    # Oracle is an oracle for answering a equivalence query.
+    #
+    # On running equivalence queries, this records the statistics information.
+    # We can obtain this information by `Oracle#stats`.
+    #
+    # Note that this class is *abstract*. You should implement the following method:
+    #
+    # - `#find_cex(hypothesis)`
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class Oracle
+      # @rbs @sul: System::SUL[In, Out]
+      # @rbs @num_calls: Integer
+      # @rbs @num_queries: Integer
+      # @rbs @num_steps: Integer
+      # @rbs @current_conf: untyped
+
+      #: (System::SUL[In, Out] sul) -> void
+      def initialize(sul)
+        @sul = sul
+
+        @num_calls = 0
+        @num_queries = 0
+        @num_steps = 0
+        @current_conf = nil
+      end
+
+      attr_reader :sul #: System::SUL[In, Out]
+
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      # Finds a conterexample against the given `hypothesis` automaton.
+      # If it is found, it returns the counterexample word, or it returns `nil` otherwise.
+      #
+      # A counterexample means that it separates a sul and a hypothesis automaton on an output
+      # value, i.e., `hypothesis.run(cex)[0].last != sul.query_last(cex)`. We also assume
+      # a counterexample is minimal; that is, there is no `n` (where `0 <= n < cex.size`)
+      # such that `hypothesis.run(cex[0...n])[0].last != sul.query_last(cex[0...n])`.
+      #
+      #: [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis) -> (Array[In] | nil)
+      def find_cex(hypothesis)
+        @num_calls += 1
+        nil
+      end
+
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # Returns the statistics information as a `Hash` object.
+      #
+      # The result hash contains the following values.
+      #
+      # - `num_calls`: The number of calls of `find_cex`.
+      # - `num_queries`: The number of queries.
+      # - `num_steps`: The total number of steps.
+      #
+      #: () -> Hash[Symbol, Integer]
+      def stats
+        { num_calls: @num_calls, num_queries: @num_queries, num_steps: @num_steps }
+      end
+
+      # Combines two oracles.
+      #
+      #: (Oracle[In, Out] other) -> CombinedOracle[In, Out]
+      def +(other)
+        oracles = []
+
+        is_a?(CombinedOracle) ? oracles.concat(oracles) : oracles << self
+        other.is_a?(CombinedOracle) ? oracles.concat(other.oracles) : oracles << other
+
+        CombinedOracle.new(oracles)
+      end
+
+      private
+
+      # Resets the internal states of this oracle.
+      #
+      #: [Conf] (Automaton::TransitionSystem[Conf, In, Out] hypothesis) -> void
+      def reset_internal(hypothesis)
+        @num_queries += 1
+
+        @current_conf = hypothesis.initial_conf
+
+        @sul.shutdown
+        @sul.setup
+      end
+
+      # Runs a transition of both a hypothesis and a SUL.
+      #
+      #: [Conf] (
+      #    Automaton::TransitionSystem[Conf, In, Out] hypothesis,
+      #    In input
+      #  ) -> [Out, Out]
+      def step_internal(hypothesis, input)
+        @num_steps += 1
+
+        hypothesis_output, @current_conf = hypothesis.step(@current_conf, input)
+        sul_output = @sul.step(input)
+
+        [hypothesis_output, sul_output]
+      end
+    end
+  end
+end

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"