stamina-induction 0.5.0

data/lib/stamina-induction/stamina/input_string.rb

@@ -0,0 +1,123 @@
+module Stamina
+  #
+  # An input string is a sequence of input symbols (symbols being letters appearing
+  # on automaton edges) labeled as positive, negative or unlabeled (provided for test
+  # samples and query strings).
+  #
+  # This class include the Enumerable module, that allows reasoning about
+  # ordered symbols.
+  #
+  # == Detailed API
+  class InputString
+    include Enumerable
+
+    #
+    # Creates an input string from symbols and positive or negative labeling.
+    #
+    # Arguments:
+    # - symbols: When an array is provided, it is duplicated by default to be kept
+    #   internally. Set dup to false to avoid duplicating it (in both cases, the
+    #   internal array will be freezed). When a String is provided, symbols array
+    #   is created using <tt>symbols.split(' ')</tt> and then freezed. _dup_ is
+    #   ignored in the case.
+    # - The positive argument may be true (positive string), false (negative one)
+    #   or nil (unlabeled).
+    #
+    # Raises:
+    # - ArgumentError if symbols is not an Array nor a String.
+    #
+    def initialize(symbols, positive, dup=true)
+      raise(ArgumentError,
+            "Input string expects an Array or a String: #{symbols} received",
+            caller) unless Array===symbols or String===symbols
+      @symbols = case symbols
+                   when String
+                     symbols.split(' ').freeze
+                   when Array
+                     (dup ? symbols.dup : symbols).freeze
+                 end
+      @positive = positive
+    end
+
+    #
+    # Checks if this input string is empty (aka lambda, i.e. contains no symbol).
+    #
+    def empty?() @symbols.empty? end
+    alias :lambda? :empty?
+
+    #
+    # Returns the string size, i.e. number of its symbols.
+    #
+    def size() @symbols.size end
+
+    #
+    # Returns the exact label of this string, being true (positive string)
+    # false (negative string) or nil (unlabeled)
+    #
+    def label() @positive end
+
+    #
+    # Returns true if this input string is positively labeled, false otherwise.
+    #
+    def positive?() @positive==true end
+
+    #
+    # Returns true if this input string is negatively labeled, false otherwise.
+    #
+    def negative?() @positive==false end
+
+    #
+    # Returns true if this input string unlabeled.
+    #
+    def unlabeled?() @positive.nil? end
+
+    # Copies and returns the same string, but switch the positive flag. This
+    # method returns self if it is unlabeled.
+    def negate
+      return self if unlabeled?
+      InputString.new(@symbols, !@positive, false)
+    end
+
+    #
+    # Returns an array with symbols of this string. Returned array may not be
+    # modified (it is freezed).
+    #
+    def symbols() @symbols end
+
+    #
+    # Yields the block with each string symbol, in order. Has no effect without
+    # block.
+    #
+    def each() @symbols.each {|s| yield s if block_given? } end
+
+    #
+    # Checks equality with another InputString. Returns true if strings have same
+    # sequence of symbols and same labeling, false otherwise. Returns nil if _o_
+    # is not an InputString.
+    #
+    def ==(o)
+      return nil unless InputString===o
+      label == o.label and @symbols == o.symbols
+    end
+    alias :eql? :==
+
+    #
+    # Computes a hash code for this string.
+    #
+    def hash
+      @symbols.hash + 37*positive?.hash
+    end
+
+    #
+    # Prints this string in ADL.
+    #
+    def to_adl
+      str = (unlabeled? ? '?' : (positive? ? '+ ' : '- '))
+      str << @symbols.join(' ')
+      str
+    end
+    alias :to_s :to_adl
+    alias :inspect :to_adl
+
+  end # class InputString
+end # module Stamina

data/lib/stamina-induction/stamina/reg_lang.rb

@@ -0,0 +1,226 @@
+require_relative "reg_lang/parser"
+module Stamina
+  class RegLang
+
+    # Automaton capturing this regular language
+    attr_reader :fa
+    protected :fa
+
+    #
+    # Creates a regular language instance based on an automaton.
+    #
+    def initialize(fa)
+      @fa = fa
+    end
+
+    ############################################################################
+    # CLASS METHODS
+
+    #
+    # Coerces `arg` to a regular language
+    #
+    # @raise ArgumentError if `arg` cannot be coerced to a regular language
+    #
+    def self.coerce(arg)
+      if arg.respond_to?(:to_reglang)
+        arg.to_reglang
+      elsif arg.respond_to?(:to_fa)
+        new(arg.to_fa)
+      elsif arg.is_a?(String)
+        parse(arg)
+      else
+        raise ArgumentError, "Invalid argument #{arg} for `RegLang`"
+      end
+    end
+
+    #
+    # Builds a sigma star language
+    #
+    def self.sigma_star(alph)
+      new(Automaton.new do |fa|
+        fa.alphabet = alph.to_a
+        fa.add_state(:initial => true, :accepting => true)
+        alph.each do |symbol|
+          fa.connect(0,0,symbol)
+        end
+      end)
+    end
+
+    #
+    # Creates a regular language by parsing an expression.
+    #
+    def self.parse(str)
+      RegLang.new(Parser.parse(str).to_fa)
+    end
+
+    ############################################################################
+    # OPERATORS
+
+    #
+    # Returns the prefix-closed version of this regular language.
+    #
+    def prefix_closed
+      automaton = fa.dup
+      automaton.each_state{|s| s.accepting!}
+      RegLang.new(automaton)
+    end
+
+    #
+    # Returns the complement of this regular language
+    #
+    def complement
+      RegLang.new(to_dfa.complement)
+    end
+
+    def **(x)
+      raise ArgumentError, "Invalid argument for ** (#{x})" unless x == -1
+      complement
+    end
+
+    #
+    # Returns a regular language defined as the union of `self` with `other`.
+    #
+    def +(other)
+      unioned = Automaton.new
+      fa.dup(unioned)
+      other.to_fa.dup(unioned)
+      RegLang.new(unioned)
+    end
+    alias :| :+
+    alias :union :+
+
+    #
+    # Returns a regular language defined as the intersection of `self` with
+    # `other`.
+    #
+    def *(other)
+      RegLang.new(fa.compose(other.fa))
+    end
+    alias :& :*
+    alias :intersection :*
+
+    #
+    # Returns a regular language defined capturing all strings from `self` but
+    # those in common with `other`.
+    #
+    def -(other)
+      self & other.complement
+    end
+    alias :difference :-
+
+    #
+    # Returns the regular language defined when abstracting from `symbols`
+    #
+    def hide(symbols)
+      RegLang.new(fa.hide(symbols))
+    end
+
+    #
+    # Returns the regular language defined when projecting on `symbols`
+    #
+    def project(symbols)
+      RegLang.new(fa.keep(symbols))
+    end
+
+    ############################################################################
+    # CANONICAL DFA
+
+    def short_prefixes
+      canonical_info.short_prefixes
+    end
+
+    def kernel
+      canonical_info.kernel
+    end
+
+    def characteristic_sample
+      canonical_info.characteristic_sample
+    end
+
+    private
+
+    def canonical_info
+      @canonical_info ||= CanonicalInfo.new(self)
+    end
+
+    ############################################################################
+    # QUERIES
+    public
+
+    #
+    # Checks if the language is empty
+    #
+    def empty?
+      self <=> EMPTY
+    end
+
+    #
+    # Checks if this regular language includes a given string
+    #
+    def include?(str)
+      fa.accepts?(str)
+    end
+
+    #
+    # Checks if `self` and `other` capture the same regular language.
+    #
+    def eql?(other)
+      self.to_cdfa <=> other.to_cdfa
+    end
+    alias :<=> :eql?
+
+    ############################################################################
+    # COERCIONS
+
+    #
+    # Returns self.
+    #
+    def to_reglang
+      self
+    end
+
+    #
+    # Returns a finite automaton capturing this regular language.
+    #
+    # Returned automaton may be non-deterministic.
+    #
+    def to_fa
+      fa.dup
+    end
+
+    #
+    # Returns a deterministic finite automaton capturing this regular
+    # language.
+    #
+    # Returned automaton is not guaranteed to be minimal or canonical.
+    #
+    def to_dfa
+      fa.determinize
+    end
+
+    #
+    # Returns the canonical deterministic finite automaton capturing this
+    # regular language.
+    #
+    def to_cdfa
+      fa.to_cdfa
+    end
+
+    #
+    # Returns a dot output
+    #
+    def to_dot
+      dfa = to_cdfa
+      dfa.depth
+      dfa.order_states{|s,t| s[:depth] <=> t[:depth]}
+      dfa.to_dot
+    end
+
+    def to_adl
+      to_cdfa.to_adl
+    end
+
+    EMPTY = RegLang.new(Automaton::DUM)
+  end # class RegLang
+end # module Stamina
+require_relative 'reg_lang/canonical_info'

data/lib/stamina-induction/stamina/reg_lang/canonical_info.rb

@@ -0,0 +1,181 @@
+module Stamina
+  class RegLang
+    class CanonicalInfo
+
+      SHORT_PREFIXES = begin
+        algo = Stamina::Utils::Decorate.new(:short_prefix)
+        algo.set_suppremum do |d0,d1|
+          if (d0.nil? || d1.nil?)
+            (d0 || d1)
+          else
+            d0.size <= d1.size ? d0 : d1
+          end
+        end
+        algo.set_propagate do |deco, edge|
+          deco.dup << edge.symbol
+        end
+        algo
+      end
+
+      attr_reader :cdfa
+
+      def initialize(lang)
+        @cdfa = lang.to_cdfa
+      end
+
+      # Returns the short prefix of a state or an edge.
+      def short_prefix(s_or_e)
+        prefixes!
+        s_or_e[:short_prefix] ||= begin
+          s_or_e.source[:short_prefix] + [s_or_e.symbol]
+        end
+      end
+
+      # Returns a positive suffix for `state`
+      def positive_suffix(state)
+        state[:positive_suffix] ||= find_suffix(state, true)
+      end
+
+      # Returns a negative suffix for `state`
+      def negative_suffix(state)
+        state[:negative_suffix] ||= find_suffix(state, false)
+      end
+
+      #
+      # Returns the short prefixes of the language as a sample
+      #
+      def short_prefixes
+        prefixes = Sample.new
+        cdfa.each_state do |s|
+          prefixes << InputString.new(short_prefix(s), s.accepting?)
+        end
+        prefixes
+      end
+
+      #
+      # Returns the language kernel as a sample
+      #
+      def kernel
+        kernel = Sample.new
+        kernel << InputString.new([], cdfa.initial_state.accepting?)
+        cdfa.each_edge do |e|
+          kernel << InputString.new(short_prefix(e), e.target.accepting?)
+        end
+        kernel
+      end
+
+      #
+      # Builds a characteristic sample
+      #
+      def characteristic_sample
+        sample = Sample.new
+
+        # at least one positive string should be found from
+        # the initial state
+        if pos = positive_suffix(cdfa.initial_state)
+          sample << InputString.new(pos, true)
+        else
+          sample << InputString.new([], false)
+          return sample
+        end
+
+        # condition 1: positive string for each element of the kernel
+        cdfa.each_edge do |edge|
+          pos = short_prefix(edge) + positive_suffix(edge.target)
+          sample << InputString.new(pos, true, false)
+        end
+
+        # condition 2: pair-wise distinguising suffixes
+        cdfa.each_state do |source|
+          cdfa.each_edge do |edge|
+            next if (target = edge.target) == source
+            if suffix = distinguish(source, target)
+              sign = cdfa.accepts?(suffix, source)
+              sample << InputString.new(short_prefix(source) + suffix, sign)
+              sample << InputString.new(short_prefix(edge) + suffix, !sign)
+            end
+          end
+        end
+
+        sample
+      end
+
+      private
+
+      # Ensures that short prefixes of states are recognized
+      def prefixes!
+        unless defined?(@prefixes)
+          SHORT_PREFIXES.execute(cdfa, nil, [])
+          @prefixes = true
+        end
+      end
+
+      def cross(xs, ys)
+        xs.each{|x| ys.each{|y| yield(x,y)}}
+      end
+
+      # Distinguishes two states, returning a suffix which is accepted for one
+      # and rejected by the other
+      def distinguish(x, y)
+        raise ArgumentError, "x and y should be different" if x == y
+        build_distinguish_matrix[[x,y].sort]
+      end
+
+      def build_distinguish_matrix
+        @diff_matrix ||= begin
+          mat = {}
+
+          # pairs to be explored
+          to_explore = []
+
+          # start by marking accepting vs. non-accepting states
+          acc, nonacc = cdfa.states.partition{|s| s.accepting?}
+          cross(acc, nonacc) do |*pair|
+            mat[pair.sort!] = []
+            to_explore << pair
+          end
+
+          # Visit each pair backwards
+          while pair = to_explore.pop
+            suffix = mat[pair]
+            cross(pair[0].in_edges, pair[1].in_edges) do |se, te|
+              next if se.symbol != te.symbol
+              source = [se.source, te.source].sort!
+              if mat[source].nil? ||
+                 (mat[source].length > (1+suffix.length))
+                mat[source] = [se.symbol] + suffix
+                to_explore.push(source)
+              end
+            end
+          end
+
+          mat
+        end
+      end
+
+      # Recursively finds a positive/negative suffix for `state`
+      def find_suffix(state, positive, stack = [], seen = {})
+        if positive == state.accepting?
+          # (pos and accepting) or (neg and non-accepting) => lambda
+          stack
+        elsif found = state.out_edges.find{|e| positive == e.target.accepting?}
+          # at one step => augment stack with symbol
+          stack << found.symbol
+        elsif found = state.out_edges.find{|e| !seen.has_key?(e.target)}
+          # recurse on a neighbour if you find one
+          seen[state] = true
+          find_suffix(found.target, positive, stack << found.symbol, seen)
+        elsif !positive
+          # in case of negative suffix: pick one in alphabet
+          outs  = state.out_symbols
+          found = state.automaton.alphabet.find{|s| !outs.include?(s)}
+          found ? (stack << found) : nil
+        else
+          # unable to find a suffix :-(
+          nil
+        end
+      end
+
+    end # class CanonicalInfo
+  end # class RegLang
+end # module Stamina