lernen 0.2.0 → 0.3.0

data/sig/generated/lernen/algorithm/kearns_vazirani_vpa/discrimination_tree_vpa.rbs

@@ -0,0 +1,73 @@
+# Generated from lib/lernen/algorithm/kearns_vazirani_vpa/discrimination_tree_vpa.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module KearnsVaziraniVPA
+      # DiscriminationTreeVPA is a extended version of discrimination tree for VPA.
+      #
+      # @rbs generic In     -- Type for input alphabet
+      # @rbs generic Call   -- Type for call alphabet
+      # @rbs generic Return -- Type for return alphabet
+      class DiscriminationTreeVPA[In, Call, Return]
+        type tree[In, Call, Return] = Node[In, Call, Return] | Leaf[In, Call, Return]
+
+        class Node[In, Call, Return] < Data
+          attr_reader access: Array[In | Call | Return]
+          attr_reader suffix: Array[In | Call | Return]
+          attr_reader branch: Hash[bool, tree[In, Call, Return]]
+          def self.[]: [In, Call, Return] (Array[In | Call | Return] access, Array[In | Call | Return] suffix, Hash[bool, tree[In, Call, Return]] branch) -> Node[In, Call, Return]
+        end
+
+        class Leaf[In, Call, Return] < Data
+          attr_reader prefix: Array[In | Call | Return]
+          def self.[]: [In, Call, Return] (Array[In | Call | Return] prefix) -> Leaf[In, Call, Return]
+        end
+
+        @root: Node[In, Call, Return]
+
+        @path_hash: Hash[Array[In | Call | Return], Array[bool]]
+
+        @cex_processing: cex_processing_method
+
+        @sul: System::MooreLikeSUL[In | Call | Return, bool]
+
+        @return_alphabet: Array[Return]
+
+        @call_alphabet: Array[Call]
+
+        @alphabet: Array[In]
+
+        # : (
+        #     Array[In] alphabet,
+        #     Array[Call] call_alphabet,
+        #     Array[Return] return_alphabet,
+        #     System::MooreLikeSUL[In | Call | Return, bool] sul,
+        #     cex: Array[In],
+        #     cex_processing: cex_processing_method
+        #   ) -> void
+        def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet, System::MooreLikeSUL[In | Call | Return, bool] sul, cex: Array[In], cex_processing: cex_processing_method) -> void
+
+        # Constructs a hypothesis automaton from this discrimination tree.
+        #
+        # : () -> [Automaton::VPA[In, Call, Return], Hash[Integer, Array[In | Call | Return]]]
+        def build_hypothesis: () -> [ Automaton::VPA[In, Call, Return], Hash[Integer, Array[In | Call | Return]] ]
+
+        # Update this classification tree by the given `cex`.
+        #
+        # : (
+        #    Array[In | Call | Return] cex,
+        #    Automaton::VPA[In, Call, Return] hypothesis,
+        #    Hash[Integer, Array[In | Call | Return]] state_to_prefix
+        #  ) -> void
+        def refine_hypothesis: (Array[In | Call | Return] cex, Automaton::VPA[In, Call, Return] hypothesis, Hash[Integer, Array[In | Call | Return]] state_to_prefix) -> void
+
+        private
+
+        # Returns a prefix discriminated by `word`.
+        #
+        # : (Array[In | Call | Return] word) -> Array[In | Call | Return]
+        def sift: (Array[In | Call | Return] word) -> Array[In | Call | Return]
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/kearns_vazirani_vpa/kearns_vazirani_vpa_learner.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/lernen/algorithm/kearns_vazirani_vpa/kearns_vazirani_vpa_learner.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module KearnsVaziraniVPA
+      # KearnzVaziraniVPALearner is an implementation of Kearnz-Vazirani algorithm for VPA.
+      #
+      # The idea behind this implementation is described by [Isberner (2015) "Foundations
+      # of Active Automata Learning: An Algorithmic Overview"](https://eldorado.tu-dortmund.de/handle/2003/34282).
+      #
+      # @rbs generic In     -- Type for input alphabet
+      # @rbs generic Call   -- Type for call alphabet
+      # @rbs generic Return -- Type for return alphabet
+      class KearnsVaziraniVPALearner[In, Call, Return] < Learner[In | Call | Return, bool]
+        @alphabet: Array[In]
+
+        @call_alphabet: Array[Call]
+
+        @return_alphabet: Array[Return]
+
+        @sul: System::MooreLikeSUL[In | Call | Return, bool]
+
+        @oracle: Equiv::Oracle[In | Call | Return, bool]
+
+        @cex_processing: cex_processing_method
+
+        @tree: DiscriminationTreeVPA[In, Call, Return] | nil
+
+        # : (
+        #     Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet,
+        #     System::MooreLikeSUL[In | Call | Return, bool] sul,
+        #     ?cex_processing: cex_processing_method
+        #   ) -> void
+        def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet, System::MooreLikeSUL[In | Call | Return, bool] sul, ?cex_processing: cex_processing_method) -> void
+
+        # @rbs override
+        def build_hypothesis: ...
+
+        # @rbs override
+        def refine_hypothesis: ...
+
+        private
+
+        # Constructs the first hypothesis VPA.
+        #
+        # : () -> Automaton::VPA[In, Call, Return]
+        def build_first_hypothesis: () -> Automaton::VPA[In, Call, Return]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# Generated from lib/lernen/algorithm/kearns_vazirani_vpa.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    # KearnzVaziraniVPA provides an implementation of Kearnz-Vazirani algorithm for VPA.
+    #
+    # The idea behind this implementation is described by [Isberner (2015) "Foundations
+    # of Active Automata Learning: An Algorithmic Overview"](https://eldorado.tu-dortmund.de/handle/2003/34282).
+    module KearnsVaziraniVPA
+      # Runs Kearns-Vazirani algorithm for VPA and returns an inferred VPA.
+      #
+      # : [In, Call, Return] (
+      #    Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet,
+      #    System::MooreLikeSUL[In | Call | Return, bool] sul, Equiv::Oracle[In | Call | Return, bool] oracle,
+      #    ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::VPA[In, Call, Return]
+      def self.learn: [In, Call, Return] (Array[In] alphabet, Array[Call] call_alphabet, Array[Return] return_alphabet, System::MooreLikeSUL[In | Call | Return, bool] sul, Equiv::Oracle[In | Call | Return, bool] oracle, ?cex_processing: cex_processing_method, ?max_learning_rounds: Integer | nil) -> Automaton::VPA[In, Call, Return]
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# Generated from lib/lernen/algorithm/learner.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    # Learner is an abstraction of implementations of learning algorithms.
+    #
+    # Note that this class is *abstract*. We should implement the following method:
+    #
+    # - `#oracle`
+    # - `#refine(cex, hypothesis, state_to_prefix)`
+    # - `#build_hypothesis`
+    #
+    # @rbs generic In  -- Type for input alphabet
+    # @rbs generic Out -- Type for output values
+    class Learner[In, Out]
+      # Runs the learning algorithm and returns an inferred automaton.
+      #
+      # `max_learning_rounds` is a parameter for specifying the maximum number of iterations for learning.
+      # When `max_learning_rounds: nil` is specified, it means the algorithm only stops if the equivalent
+      # hypothesis is found.
+      #
+      # : (
+      #    Equiv::Oracle[In, Out] oracle,
+      #    ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::TransitionSystem[untyped, In, Out]
+      def learn: (Equiv::Oracle[In, Out] oracle, ?max_learning_rounds: Integer | nil) -> Automaton::TransitionSystem[untyped, In, Out]
+
+      # Adds the given `input` to the alphabet.
+      #
+      # In the default, this method raises `TypeError` as the learner does not support
+      # adding an input character to the alphabet.
+      #
+      # : (In input) -> void
+      def add_alphabet: (In input) -> void
+
+      # Refine the learning hypothesis by the given counterexample.
+      #
+      # This is an abstract method.
+      #
+      # : (
+      #    Array[In] cex,
+      #    Automaton::TransitionSystem[untyped, In, Out] hypothesis,
+      #    Hash[Integer, Array[In]] state_to_prefix
+      #  ) -> void
+      def refine_hypothesis: (Array[In] cex, Automaton::TransitionSystem[untyped, In, Out] hypothesis, Hash[Integer, Array[In]] state_to_prefix) -> void
+
+      # This is an abstract method.
+      # r
+      # : () -> [Automaton::TransitionSystem[untyped, In, Out], Hash[Integer, Array[In]]]
+      def build_hypothesis: () -> [ Automaton::TransitionSystem[untyped, In, Out], Hash[Integer, Array[In]] ]
+    end
+  end
+end

data/sig/generated/lernen/algorithm/lsharp/lsharp_learner.rbs

@@ -0,0 +1,103 @@
+# Generated from lib/lernen/algorithm/lsharp/lsharp_learner.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module LSharp
+      # LSharpLearner is an implementation of L# algorithm.
+      #
+      # L# is introduced by [Vaandrager et al. (2022) "A New Approach for Active
+      # Automata Learning Based on Apartness"](https://link.springer.com/chapter/10.1007/978-3-030-99524-9_12).
+      #
+      # @rbs generic In  -- Type for input alphabet
+      # @rbs generic Out -- Type for output values
+      class LSharpLearner[In, Out] < Learner[In, Out]
+        @incomplete_basis: Array[Array[In]]
+
+        @frontier: Hash[Array[In], Array[Array[In]]]
+
+        @basis: Array[Array[In]]
+
+        @witness_cache: Hash[[ Array[In], Array[In] ], Array[In]]
+
+        @tree: ObservationTree[In, Out]
+
+        @automaton_type: :dfa | :mealy | :moore
+
+        @oracle: Equiv::Oracle[In, Out]
+
+        @sul: System::SUL[In, Out]
+
+        @alphabet: Array[In]
+
+        # : (
+        #     Array[In] alphabet,
+        #     System::SUL[In, Out] sul,
+        #     automaton_type: :dfa | :mealy | :moore,
+        #   ) -> void
+        def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, automaton_type: :dfa | :mealy | :moore) -> void
+
+        # @rbs override
+        def build_hypothesis: ...
+
+        # @rbs override
+        def refine_hypothesis: ...
+
+        # @rbs override
+        def add_alphabet: ...
+
+        private
+
+        # Checks apartness on the current observation tree between the given two nodes.
+        # It returns the witness suffix if they are apart. If it is not, it returns `nil`.
+        #
+        # : (
+        #    ObservationTree::Node[In, Out] node1,
+        #    ObservationTree::Node[In, Out] node2
+        #  ) -> (Array[In] | nil)
+        def check_apartness: (ObservationTree::Node[In, Out] node1, ObservationTree::Node[In, Out] node2) -> (Array[In] | nil)
+
+        # Computes the witness suffix of apartness between the given two basis prefixes.
+        #
+        # : (
+        #    Array[In] prefix1,
+        #    Array[In] prefix2
+        #  ) -> Array[In]
+        def compute_witness: (Array[In] prefix1, Array[In] prefix2) -> Array[In]
+
+        # : (Array[In] prefix) -> void
+        def add_basis: (Array[In] prefix) -> void
+
+        # : (Array[In] border) -> void
+        def add_frontier: (Array[In] border) -> void
+
+        # : () -> void
+        def update_frontier: () -> void
+
+        # : () -> [Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]]]
+        def build_hypothesis_internal: () -> [ Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]] ]
+
+        # : (
+        #     Automaton::TransitionSystem[Integer, In, Out] hypothesis,
+        #     Hash[Integer, Array[In]] state_to_prefix
+        #   ) -> (Array[In] | nil)
+        def check_consistency: (Automaton::TransitionSystem[Integer, In, Out] hypothesis, Hash[Integer, Array[In]] state_to_prefix) -> (Array[In] | nil)
+
+        # : () -> bool
+        def promotion: () -> bool
+
+        # : () -> bool
+        def completion: () -> bool
+
+        # : () -> bool
+        def identification: () -> bool
+
+        # : (
+        #     Array[In] cex,
+        #     Automaton::TransitionSystem[Integer, In, Out] hypothesis,
+        #     Hash[Integer, Array[In]] state_to_prefix,
+        #   ) -> void
+        def process_cex: (Array[In] cex, Automaton::TransitionSystem[Integer, In, Out] hypothesis, Hash[Integer, Array[In]] state_to_prefix) -> void
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/lsharp/observation_tree.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/lernen/algorithm/lsharp/observation_tree.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module LSharp
+      # ObservationTree is an implementation of observation tree data structure.
+      #
+      # This data structure is used for L# algorithm.
+      #
+      # @rbs generic In  -- Type for input alphabet
+      # @rbs generic Out -- Type for output values
+      class ObservationTree[In, Out]
+        class Node[In, Out] < Data
+          attr_reader output: Out | nil
+          attr_reader branch: Hash[In, Node[In, Out]]
+          def self.[]: [In, Out] (Out output, Hash[In, Node[In, Out]] branch) -> Node[In, Out]
+        end
+
+        @sul: System::SUL[In, Out]
+
+        @automaton_type: :dfa | :mealy | :moore
+
+        @root: Node[In, Out]
+
+        # : (
+        #     System::SUL[In, Out] sul,
+        #     automaton_type: :dfa | :mealy | :moore
+        #   ) -> void
+        def initialize: (System::SUL[In, Out] sul, automaton_type: :dfa | :mealy | :moore) -> void
+
+        attr_reader root: Node[In, Out]
+
+        # Returns a node for the given word.
+        # When the word (or its subword) is not observed, it returns `nil` instead.
+        #
+        # : (Array[In] word) -> (Node[In, Out] | nil)
+        def []: (Array[In] word) -> (Node[In, Out] | nil)
+
+        # Returns an output sequence for the given word if it is observed.
+        # If it is not, it returns `nil` instead.
+        #
+        # : (Array[In] word) -> (Array[Out] | nil)
+        def observed_query: (Array[In] word) -> (Array[Out] | nil)
+
+        # Returns an output sequence for the given word.
+        # When the word is observed, it runs actual query over `sul`.
+        #
+        # : (Array[In] word) -> Array[Out]
+        def query: (Array[In] word) -> Array[Out]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# Generated from lib/lernen/algorithm/lsharp.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    # LSharp provides an implementation of L# algorithm.
+    #
+    # L# is introduced by [Vaandrager et al. (2022) "A New Approach for Active
+    # Automata Learning Based on Apartness"](https://link.springer.com/chapter/10.1007/978-3-030-99524-9_12).
+    module LSharp
+      # Runs the L# algorithm and returns an inferred automaton.
+      #
+      # : [In] (
+      #    Array[In] alphabet,
+      #    System::SUL[In, bool] sul,
+      #    Equiv::Oracle[In, bool] oracle,
+      #    automaton_type: :dfa,
+      #    ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::DFA[In]
+      # : [In, Out] (
+      #    Array[In] alphabet,
+      #    System::SUL[In, Out] sul,
+      #    Equiv::Oracle[In, Out] oracle,
+      #    automaton_type: :mealy,
+      #    ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::Mealy[In, Out]
+      # : [In, Out] (
+      #    Array[In] alphabet,
+      #    System::SUL[In, Out] sul,
+      #    Equiv::Oracle[In, Out] oracle,
+      #    automaton_type: :moore,
+      #    ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::Moore[In, Out]
+      def self.learn: [In] (Array[In] alphabet, System::SUL[In, bool] sul, Equiv::Oracle[In, bool] oracle, automaton_type: :dfa, ?max_learning_rounds: Integer | nil) -> Automaton::DFA[In]
+                    | [In, Out] (Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle, automaton_type: :mealy, ?max_learning_rounds: Integer | nil) -> Automaton::Mealy[In, Out]
+                    | [In, Out] (Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle, automaton_type: :moore, ?max_learning_rounds: Integer | nil) -> Automaton::Moore[In, Out]
+    end
+  end
+end

data/sig/generated/lernen/algorithm/lstar/lstar_learner.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/lernen/algorithm/lstar/lstar_learner.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module LStar
+      # LStarLearner is an implementation of Angluin's L* algorithm.
+      #
+      # Angluin's L* is introduced by [Angluin (1987) "Learning Regular Sets from
+      # Queries and Counterexamples"](https://dl.acm.org/doi/10.1016/0890-5401%2887%2990052-6).
+      #
+      # @rbs generic In  -- Type for input alphabet
+      # @rbs generic Out -- Type for output values
+      class LStarLearner[In, Out] < Learner[In, Out]
+        @alphabet: Array[In]
+
+        @oracle: Equiv::Oracle[In, Out]
+
+        @table: ObservationTable[In, Out]
+
+        # : (
+        #     Array[In] alphabet, System::SUL[In, Out] sul,
+        #     automaton_type: :dfa | :moore | :mealy,
+        #     ?cex_processing: cex_processing_method | nil
+        #   ) -> void
+        def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, automaton_type: :dfa | :moore | :mealy, ?cex_processing: cex_processing_method | nil) -> void
+
+        # @rbs override
+        def build_hypothesis: ...
+
+        # @rbs override
+        def refine_hypothesis: ...
+
+        # @rbs override
+        def add_alphabet: ...
+      end
+    end
+  end
+end

data/sig/generated/lernen/algorithm/lstar/observation_table.rbs

@@ -0,0 +1,79 @@
+# Generated from lib/lernen/algorithm/lstar/observation_table.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module LStar
+      # ObservationTable is an implementation of observation tabel data structure.
+      #
+      # This data structure is used for Angluin's L* algorithm.
+      #
+      # @rbs generic In  -- Type for input alphabet
+      # @rbs generic Out -- Type for output values
+      class ObservationTable[In, Out]
+        @table: Hash[Array[In], Array[Out]]
+
+        @suffixes: Array[Array[In]]
+
+        @prefixes: Array[Array[In]]
+
+        @cex_processing: cex_processing_method | nil
+
+        @automaton_type: Automaton::transition_system_type
+
+        @sul: System::SUL[In, Out]
+
+        @alphabet: Array[In]
+
+        # : (
+        #     Array[In] alphabet,
+        #     System::SUL[In, Out] sul,
+        #     automaton_type: :dfa | :moore | :mealy,
+        #     cex_processing: cex_processing_method | nil
+        #   ) -> void
+        def initialize: (Array[In] alphabet, System::SUL[In, Out] sul, automaton_type: :dfa | :moore | :mealy, cex_processing: cex_processing_method | nil) -> void
+
+        # Constructs a hypothesis automaton from this observation table.
+        #
+        # : () -> [Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]]]
+        def build_hypothesis: () -> [ Automaton::TransitionSystem[Integer, In, Out], Hash[Integer, Array[In]] ]
+
+        # Updates this observation table by the given `cex`.
+        #
+        # : (
+        #    Array[In] cex,
+        #    Automaton::TransitionSystem[Integer, In, Out] hypothesis,
+        #    Hash[Integer, Array[In]] state_to_prefix
+        #  ) -> void
+        def refine_hypothesis: (Array[In] cex, Automaton::TransitionSystem[Integer, In, Out] hypothesis, Hash[Integer, Array[In]] state_to_prefix) -> void
+
+        private
+
+        # Finds new prefixes to close.
+        #
+        # : () -> (Array[Array[In]] | nil)
+        def find_prefixes_to_close: () -> (Array[Array[In]] | nil)
+
+        # Checks consistency and returns a new suffix to add if this observation table
+        # is inconsistent.
+        #
+        # : () -> (Array[In] | nil)
+        def check_consistency: () -> (Array[In] | nil)
+
+        # Updates rows of this observation table.
+        #
+        # : () -> void
+        def update_table: () -> void
+
+        # Updates the row for the given `prefix` of this observation table.
+        #
+        # : (Array[In] prefix) -> void
+        def update_table_row: (Array[In] prefix) -> void
+
+        # Update this table to be consistent and closed.
+        #
+        # : () -> void
+        def make_consistent_and_closed: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# Generated from lib/lernen/algorithm/lstar.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    # LStar provides an implementation of Angluin's L* algorithm.
+    #
+    # Angluin's L* is introduced by [Angluin (1987) "Learning Regular Sets from
+    # Queries and Counterexamples"](https://dl.acm.org/doi/10.1016/0890-5401%2887%2990052-6).
+    module LStar
+      # Runs Angluin's L* algorithm and returns an inferred automaton.
+      #
+      # `cex_processing` is used for determining a method of counterexample processing.
+      # In additional to predefined `cex_processing_method`, we can specify `nil` as `cex_processing`.
+      # When `cex_processing: nil` is specified, it uses the original counterexample processing
+      # described in the Angluin paper.
+      #
+      # : [In] (
+      #    Array[In] alphabet, System::SUL[In, bool] sul, Equiv::Oracle[In, bool] oracle,
+      #    automaton_type: :dfa,
+      #    ?cex_processing: cex_processing_method | nil, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::DFA[In]
+      # : [In, Out] (
+      #    Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle,
+      #    automaton_type: :mealy,
+      #    ?cex_processing: cex_processing_method | nil, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::Mealy[In, Out]
+      # : [In, Out] (
+      #    Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle,
+      #    automaton_type: :moore,
+      #    ?cex_processing: cex_processing_method | nil, ?max_learning_rounds: Integer | nil
+      #  ) -> Automaton::Moore[In, Out]
+      def self.learn: [In] (Array[In] alphabet, System::SUL[In, bool] sul, Equiv::Oracle[In, bool] oracle, automaton_type: :dfa, ?cex_processing: cex_processing_method | nil, ?max_learning_rounds: Integer | nil) -> Automaton::DFA[In]
+                    | [In, Out] (Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle, automaton_type: :mealy, ?cex_processing: cex_processing_method | nil, ?max_learning_rounds: Integer | nil) -> Automaton::Mealy[In, Out]
+                    | [In, Out] (Array[In] alphabet, System::SUL[In, Out] sul, Equiv::Oracle[In, Out] oracle, automaton_type: :moore, ?cex_processing: cex_processing_method | nil, ?max_learning_rounds: Integer | nil) -> Automaton::Moore[In, Out]
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# Generated from lib/lernen/algorithm/procedural/atr_manager.rb with RBS::Inline
+
+module Lernen
+  module Algorithm
+    module Procedural
+      # ATRManager is a collection to manage access, terminating, and return sequences.
+      #
+      # @rbs generic In     -- Type for input alphabet
+      # @rbs generic Call   -- Type for call alphabet
+      # @rbs generic Return -- Type for return alphabet
+      class ATRManager[In, Call, Return]
+        @scan_procs: bool
+
+        @return_input: Return
+
+        @call_alphabet_set: Set[Call]
+
+        @alphabet: Array[In]
+
+        @proc_to_return_sequence: Hash[Call, Array[In | Call | Return]]
+
+        @proc_to_terminating_sequence: Hash[Call, Array[In | Call | Return]]
+
+        @proc_to_access_sequence: Hash[Call, Array[In | Call | Return]]
+
+        # : (
+        #     Array[In] alphabet,
+        #     Array[Call] call_alphabet,
+        #     Return return_input,
+        #     ?scan_procs: bool
+        #   ) -> void
+        def initialize: (Array[In] alphabet, Array[Call] call_alphabet, Return return_input, ?scan_procs: bool) -> void
+
+        attr_reader proc_to_access_sequence: Hash[Call, Array[In | Call | Return]]
+
+        attr_reader proc_to_terminating_sequence: Hash[Call, Array[In | Call | Return]]
+
+        attr_reader proc_to_return_sequence: Hash[Call, Array[In | Call | Return]]
+
+        # : (Array[In | Call | Return] cex) -> Array[Call]
+        def scan_positive_cex: (Array[In | Call | Return] cex) -> Array[Call]
+
+        # : (
+        #     Hash[Call, Automaton::DFA[In | Call]] procs,
+        #     Hash[Call, Hash[Integer, Array[In | Call]]] proc_to_state_to_prefix
+        #   ) -> void
+        def scan_procs: (Hash[Call, Automaton::DFA[In | Call]] procs, Hash[Call, Hash[Integer, Array[In | Call]]] proc_to_state_to_prefix) -> void
+
+        # : (Call proc, Array[In | Call] word) -> Array[In | Call | Return]
+        def embed: (Call proc, Array[In | Call] word) -> Array[In | Call | Return]
+
+        # : [In, Call, Return] (Array[In | Call] word) -> Array[In | Call | Return]
+        def expand: [In, Call, Return] (Array[In | Call] word) -> Array[In | Call | Return]
+
+        # : [In, Call, Return] (Array[In | Call] word) -> Array[In | Call | Return]
+        def project: [In, Call, Return] (Array[In | Call] word) -> Array[In | Call | Return]
+
+        # : (Array[In | Call | Return] word, Integer index) -> Integer
+        def find_call_index: (Array[In | Call | Return] word, Integer index) -> Integer
+
+        # : (Array[In | Call | Return] word, Integer index) -> Integer
+        def find_return_index: (Array[In | Call | Return] word, Integer index) -> Integer
+
+        private
+
+        # : (Array[In | Call | Return] cex) -> Array[Call]
+        def extract_potential_terminating_sequences: (Array[In | Call | Return] cex) -> Array[Call]
+
+        # : (Array[In | Call | Return] cex) -> void
+        def extract_potential_access_and_return_sequences: (Array[In | Call | Return] cex) -> void
+
+        # : (Array[In | Call | Return] word) -> Array[In | Call | Return]
+        def minify_well_matched: (Array[In | Call | Return] word) -> Array[In | Call | Return]
+
+        # : (Hash[Call, Array[In | Call | Return]]) -> void
+        def optimize_sequences: (Hash[Call, Array[In | Call | Return]]) -> void
+      end
+    end
+  end
+end