lernen 0.2.0 → 0.3.0

data/sig/generated/lernen/algorithm/procedural/procedural_learner.rbs

@@ -0,0 +1,79 @@
+# Generated from lib/lernen/algorithm/procedural/procedural_learner.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module Procedural
+      # ProceduralLearner is 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).
+      #
+      # @rbs generic In     -- Type for input alphabet
+      # @rbs generic Call   -- Type for call alphabet
+      # @rbs generic Return -- Type for return alphabet
+      class ProceduralLearner[In, Call, Return] < Learner[In | Call | Return, bool]
+        @cex_processing: cex_processing_method
+
+        @algorithm_params: Hash[Symbol, untyped]
+
+        @algorithm: :lstar | :kearns_vazirani | :lsharp
+
+        @sul: System::SUL[In | Call | Return, bool]
+
+        @return_input: Return
+
+        @call_alphabet: Array[Call]
+
+        @alphabet: Array[In]
+
+        @active_call_alphabet_set: Set[Call]
+
+        @manager: ATRManager[In, Call, Return]
+
+        @proc_to_learner: Hash[Call, Learner[In | Call, bool]]
+
+        @initial_proc: Call | nil
+
+        # : (
+        #     Array[In] alphabet,
+        #     Array[Call] call_alphabet,
+        #     Return return_input,
+        #     System::SUL[In | Call | Return, bool] sul,
+        #     ?algorithm: :lstar | :kearns_vazirani | :lsharp,
+        #     ?algorithm_params: Hash[Symbol, untyped],
+        #     ?cex_processing: cex_processing_method,
+        #     ?scan_procs: bool
+        #   ) -> void
+        def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Return return_input, System::SUL[In | Call | Return, bool] sul, ?algorithm: :lstar | :kearns_vazirani | :lsharp, ?algorithm_params: Hash[Symbol, untyped], ?cex_processing: cex_processing_method, ?scan_procs: bool) -> void
+
+        # : () -> [Automaton::SPA[In, Call, Return], Hash[Call, Hash[Integer, Array[In | Call]]]]
+        def build_hypothesis: () -> [ Automaton::SPA[In, Call, Return], Hash[Call, Hash[Integer, Array[In | Call]]] ]
+
+        # : (
+        #     Array[In | Call | Return] cex,
+        #     Automaton::SPA[In, Call, Return] _hypothesis,
+        #     Hash[Call, Hash[Integer, Array[In | Call]]] _proc_to_state_to_prefix
+        #   ) -> void
+        def refine_hypothesis: (Array[In | Call | Return] cex, Automaton::SPA[In, Call, Return] _hypothesis, Hash[Call, Hash[Integer, Array[In | Call]]] _proc_to_state_to_prefix) -> void
+
+        private
+
+        # : () -> Automaton::SPA[In, Call, Return]
+        def build_first_hypothesis: () -> Automaton::SPA[In, Call, Return]
+
+        # : (Array[In | Call | Return] cex) -> void
+        def extract_useful_information_from_cex: (Array[In | Call | Return] cex) -> void
+
+        # : (Array[In | Call | Return] cex) -> bool
+        def refine_hypothesis_internal: (Array[In | Call | Return] cex) -> bool
+
+        # : () -> bool
+        def update_atr_and_check_ts_conformance: () -> bool
+
+        def check_and_ensure_ts_conformance: (untyped hypothesis, untyped proc_to_state_to_prefix) -> untyped
+
+        def check_and_ensure_single_ts_conformance: (untyped ts, untyped hypothesis, untyped proc_to_state_to_prefix) -> untyped
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/procedural/procedural_sul.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/lernen/algorithm/procedural/procedural_sul.rb with RBS::Inline
+
+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[In, Call, Return] < System::MooreLikeSUL[In | Call, bool]
+        @proc: Call
+
+        @sul: System::SUL[In | Call | Return, bool]
+
+        @manager: ATRManager[In, Call, Return]
+
+        # : (
+        #     Call proc,
+        #     System::SUL[In | Call | Return, bool] sul,
+        #     ATRManager[In, Call, Return] manager
+        #   ) -> void
+        def initialize: (Call proc, System::SUL[In | Call | Return, bool] sul, ATRManager[In, Call, Return] manager) -> void
+
+        # @rbs override
+        def query_empty: ...
+
+        # @rbs override
+        def query: ...
+
+        # @rbs override
+        def step: ...
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/procedural/return_indices_acex.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/lernen/algorithm/procedural/return_indices_acex.rb with RBS::Inline
+
+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[In, Call, Return] < CexProcessor::Acex
+        @cex: Array[In | Call | Return]
+
+        @return_indices: Array[Integer]
+
+        @query: ^(Array[In | Call | Return]) -> bool
+
+        @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: (Array[In | Call | Return] cex, Array[Integer] return_indices, ^(Array[In | Call | Return]) -> bool query, ATRManager[In, Call, Return] manager) -> void
+
+        # @rbs override
+        def compute_effect: ...
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/procedural.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/lernen/algorithm/procedural.rb with RBS::Inline
+
+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: [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]
+    end
+  end
+end

data/sig/generated/lernen/algorithm.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/lernen/algorithm.rb with RBS::Inline
+
+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

data/sig/generated/lernen/automaton/dfa.rbs

@@ -0,0 +1,93 @@
+# Generated from lib/lernen/automaton/dfa.rb with RBS::Inline
+
+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[In] < MooreLike[Integer, In, bool]
+      @transition_function: Hash[[ Integer, In ], Integer]
+
+      @accept_state_set: Set[Integer]
+
+      @initial_state: Integer
+
+      # : (
+      #     Integer initial_state,
+      #     Set[Integer] accept_state_set,
+      #     Hash[[Integer, In], Integer] transition_function
+      #   ) -> void
+      def initialize: (Integer initial_state, Set[Integer] accept_state_set, Hash[[ Integer, In ], Integer] transition_function) -> void
+
+      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: ...
+
+      # @rbs override
+      def step_conf: ...
+
+      # @rbs override
+      def output: ...
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      # : (untyped other) -> bool
+      def ==: (untyped other) -> bool
+
+      # Returns the array of states of this DFA.
+      #
+      # The result array is sorted.
+      #
+      # : () -> Array[Integer]
+      def states: () -> Array[Integer]
+
+      # 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: () -> (Integer | nil)
+
+      # 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: (Array[In] alphabet) -> (Array[In] | nil)
+
+      # Computes the shortest paths between states.
+      #
+      # : (Array[In] alphabet) -> Hash[[Integer, Integer], Array[In]]
+      def compute_shortest_words: (Array[In] alphabet) -> Hash[[ Integer, Integer ], Array[In]]
+
+      # Returns a graph of this DFA.
+      #
+      # (?shows_error_state: bool) -> Graph
+      def to_graph: (?shows_error_state: untyped) -> untyped
+
+      # 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: [In] (alphabet: Array[In], ?min_state_size: Integer, ?max_state_size: Integer, ?accept_state_size: Integer, ?random: Random) -> DFA[In]
+    end
+  end
+end

data/sig/generated/lernen/automaton/mealy.rbs

@@ -0,0 +1,61 @@
+# Generated from lib/lernen/automaton/mealy.rb with RBS::Inline
+
+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[In, Out] < TransitionSystem[Integer, In, Out]
+      @initial_state: Integer
+
+      @transition_function: Hash[[ Integer, In ], [ Out, Integer ]]
+
+      # : (
+      #     Integer initial_state,
+      #     Hash[[Integer, In], [Out, Integer]] transition_function
+      #   ) -> void
+      def initialize: (Integer initial_state, Hash[[ Integer, In ], [ Out, Integer ]] transition_function) -> void
+
+      attr_reader initial_state: Integer
+
+      attr_reader transition_function: Hash[[ Integer, In ], [ Out, Integer ]]
+
+      # : () -> :mealy
+      def type: () -> :mealy
+
+      # @rbs override
+      def initial_conf: ...
+
+      # @rbs override
+      def step: ...
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      # : (untyped other) -> bool
+      def ==: (untyped other) -> bool
+
+      # Returns the array of states of this Mealy machine.
+      #
+      # The result array is sorted.
+      #
+      # : () -> Array[Integer]
+      def states: () -> Array[Integer]
+
+      # @rbs override
+      def to_graph: ...
+
+      # 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: [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]
+    end
+  end
+end

data/sig/generated/lernen/automaton/moore.rbs

@@ -0,0 +1,69 @@
+# Generated from lib/lernen/automaton/moore.rb with RBS::Inline
+
+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[In, Out] < MooreLike[Integer, In, Out]
+      @transition_function: Hash[[ Integer, In ], Integer]
+
+      @output_function: Hash[Integer, Out]
+
+      @initial_state: Integer
+
+      # : (
+      #     Integer initial_state,
+      #     Hash[Integer, Out] output_function,
+      #     Hash[[Integer, In], Integer] transition_function,
+      #   ) -> void
+      def initialize: (Integer initial_state, Hash[Integer, Out] output_function, Hash[[ Integer, In ], Integer] transition_function) -> void
+
+      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: ...
+
+      # @rbs override
+      def step_conf: ...
+
+      # @rbs override
+      def output: ...
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      # : (untyped other) -> bool
+      def ==: (untyped other) -> bool
+
+      # Returns the array of states of this Moore machine.
+      #
+      # The result array is sorted.
+      #
+      # : () -> Array[Integer]
+      def states: () -> Array[Integer]
+
+      # @rbs override
+      def to_graph: ...
+
+      # 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: [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]
+    end
+  end
+end

data/sig/generated/lernen/automaton/moore_like.rbs

@@ -0,0 +1,63 @@
+# Generated from lib/lernen/automaton/moore_like.rb with RBS::Inline
+
+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[Conf, In, Out] < TransitionSystem[Conf, In, Out]
+      # 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 conf, In innput) -> Conf
+
+      # Returns the output value for the given configuration.
+      #
+      # This is an abstract method.
+      #
+      # : (Conf conf) -> Out
+      def output: (Conf conf) -> Out
+
+      # @rbs override
+      def step: ...
+
+      # Runs and returns the output value of the transitions for the empty string.
+      #
+      # : () -> Out
+      def run_empty: () -> Out
+
+      # 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: [Conf, In, Out] (Array[In] alphabet, MooreLike[Conf, In, Out] automaton1, MooreLike[Conf, In, Out] automaton2) -> (Array[In] | nil)
+    end
+  end
+end

data/sig/generated/lernen/automaton/proc_util.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/lernen/automaton/proc_util.rb with RBS::Inline
+
+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: [In, Call, Return] (Return return_input, Array[In | Call] word, Hash[Call, Array[In | Call | Return]] proc_to_terminating_sequence) -> Array[In | Call | Return]
+
+      # : [In, Call, Return] (
+      #     Set[Call] call_alphabet_set,
+      #     Return return_input,
+      #     Array[In | Call | Return] word
+      #   ) -> Array[In | Call]
+      def self.project: [In, Call, Return] (Set[Call] call_alphabet_set, Return return_input, Array[In | Call | Return] word) -> Array[In | Call]
+
+      # : [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: [In, Call, Return] (Set[Call] call_alphabet_set, Return return_input, Array[In | Call | Return] word, Integer index) -> (Integer | nil)
+
+      # : [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: [In, Call, Return] (Set[Call] call_alphabet_set, Return return_input, Array[In | Call | Return] word, Integer index) -> (Integer | nil)
+    end
+  end
+end

data/sig/generated/lernen/automaton/spa.rbs

@@ -0,0 +1,125 @@
+# Generated from lib/lernen/automaton/spa.rb with RBS::Inline
+
+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[In, Call, Return] < MooreLike[SPA::conf[Call], In | Call | Return, bool]
+      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
+
+      @proc_to_dfa: Hash[Call, DFA[In | Call]]
+
+      @initial_proc: Call
+
+      # : (
+      #     Call initial_proc,
+      #     Return return_input,
+      #     Hash[Call, DFA[In | Call]] proc_to_dfa
+      #   ) -> void
+      def initialize: (Call initial_proc, Return return_input, Hash[Call, DFA[In | Call]] proc_to_dfa) -> void
+
+      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: ...
+
+      # @rbs override
+      def step_conf: ...
+
+      # @rbs override
+      def output: ...
+
+      # Checks the structural equality between `self` and `other`.
+      #
+      # : (untyped other) -> bool
+      def ==: (untyped other) -> bool
+
+      # @rbs override
+      def to_graph: ...
+
+      # 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: (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]] ]
+
+      # 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: [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)
+
+      # 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: [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]
+
+      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: (Array[In] alphabet, Array[Call] call_alphabet) -> Hash[Call, Array[In | Call | Return]]
+
+      # 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: (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]] ]
+
+      # : (
+      #     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[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] ]]
+    end
+  end
+end