ibex 0.2.0 → 0.3.0

data/sig/ibex/verification_report/canonical_ir.rbs

@@ -0,0 +1,41 @@
+# Generated from lib/ibex/verification_report/canonical_ir.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Rebuilds immutable IR with source locations expressed as report logical identities.
+    class CanonicalIR
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[json_value, json_value]
+
+      LOGICAL_ROOT: String
+
+      # @rbs (IR::Automaton automaton, source_records: Array[GenerationInput]) -> void
+      def initialize: (IR::Automaton automaton, source_records: Array[GenerationInput]) -> void
+
+      # @rbs () -> IR::Automaton
+      def build: () -> IR::Automaton
+
+      private
+
+      # @rbs (json_value value) -> json_value
+      def normalize_source_identity!: (json_value value) -> json_value
+
+      # @rbs (json_value value) -> String
+      def generate_json: (json_value value) -> String
+
+      # @rbs (json_value value) -> json_value
+      def normalize_for_json: (json_value value) -> json_value
+
+      # @rbs (String file) -> String
+      def logical_file: (String file) -> String
+
+      # @rbs (GenerationInput record, String file) -> bool
+      def record_matches?: (GenerationInput record, String file) -> bool
+
+      # @rbs (String file) -> bool
+      def absolute_file?: (String file) -> bool
+
+      # @rbs (IR::Grammar grammar) -> String
+      def digest: (IR::Grammar grammar) -> String
+    end
+  end
+end

data/sig/ibex/verification_report/logical_path.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/ibex/verification_report/logical_path.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Closed logical identities used by version 1 verification reports.
+    module LogicalPath
+      MAX_INPUT_FILES: Integer
+
+      BASENAME: Regexp
+
+      INPUT: Regexp
+
+      TABLE: Regexp
+
+      # @rbs (String path, Integer index) -> String
+      def self?.input: (String path, Integer index) -> String
+
+      # @rbs (String path) -> String
+      def self?.table: (String path) -> String
+
+      # @rbs (Object? value, Integer index) -> bool
+      def self?.canonical_input?: (Object? value, Integer index) -> bool
+
+      # @rbs (Object? value) -> bool
+      def self?.canonical_table?: (Object? value) -> bool
+
+      # @rbs (String path) -> String
+      def self?.basename: (String path) -> String
+
+      # @rbs (String value) -> bool
+      def self?.usable_basename?: (String value) -> bool
+    end
+  end
+end

data/sig/ibex/verification_report/validator.rbs

@@ -0,0 +1,114 @@
+# Generated from lib/ibex/verification_report/validator.rb with RBS::Inline
+
+module Ibex
+  module VerificationReport
+    # Validates a report and its cross-artifact manifest/table bindings.
+    # rubocop:disable Metrics/ClassLength -- closed report and cross-artifact invariants form one validator contract.
+    class Validator
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      ROOT_KEYS: Array[String]
+
+      CHECKER_KEYS: Array[String]
+
+      BOUNDS_KEYS: Array[String]
+
+      INPUT_KEYS: Array[String]
+
+      INPUT_FILE_KEYS: Array[String]
+
+      IR_KEYS: Array[String]
+
+      GRAMMAR_KEYS: Array[String]
+
+      AUTOMATON_KEYS: Array[String]
+
+      TABLE_KEYS: Array[String]
+
+      OUTCOME_KEYS: Array[String]
+
+      VIOLATION_KEYS: Array[String]
+
+      EXHAUSTION_KEYS: Array[String]
+
+      DIGEST: Regexp
+
+      ALGORITHMS: Array[String]
+
+      # @rbs (String source) -> Hash[String, json_value]
+      def validate: (String source) -> Hash[String, json_value]
+
+      # @rbs (manifest_source: String, report_source: String, table_source: String) -> Hash[String, json_value]
+      def validate_bundle: (manifest_source: String, report_source: String, table_source: String) -> Hash[String, json_value]
+
+      # @rbs (String manifest_path) -> Hash[String, json_value]
+      def validate_bundle_file: (String manifest_path) -> Hash[String, json_value]
+
+      private
+
+      # @rbs (json_value document) -> void
+      def validate_document: (json_value document) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_checker: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_bounds: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_input: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_ir: (json_value value) -> void
+
+      # @rbs (json_value value) -> void
+      def validate_table: (json_value value) -> void
+
+      # @rbs (json_value value, String profile) -> void
+      def validate_outcome: (json_value value, String profile) -> void
+
+      # @rbs (json_value value, Array[String] requested) -> Array[json_value]
+      def validate_violations: (json_value value, Array[String] requested) -> Array[json_value]
+
+      # @rbs (Hash[String, json_value] manifest, String kind) -> Hash[String, json_value]
+      def unique_artifact: (Hash[String, json_value] manifest, String kind) -> Hash[String, json_value]
+
+      # @rbs (Hash[String, json_value] entry, String source, String label) -> void
+      def validate_manifest_bytes!: (Hash[String, json_value] entry, String source, String label) -> void
+
+      # @rbs (Hash[String, json_value] manifest, Hash[String, json_value] report) -> void
+      def validate_inputs!: (Hash[String, json_value] manifest, Hash[String, json_value] report) -> void
+
+      # @rbs (Hash[String, json_value] report, TableArtifact::Document table,
+      #   Hash[String, json_value] table_entry) -> void
+      def validate_table_binding!: (Hash[String, json_value] report, TableArtifact::Document table, Hash[String, json_value] table_entry) -> void
+
+      # @rbs (json_value value, String path) -> Array[String]
+      def checks: (json_value value, String path) -> Array[String]
+
+      # @rbs (json_value value, Array[String] keys, String path) -> Hash[String, json_value]
+      def object: (json_value value, Array[String] keys, String path) -> Hash[String, json_value]
+
+      # @rbs (json_value value, String path) -> Array[json_value]
+      def array: (json_value value, String path) -> Array[json_value]
+
+      # @rbs (json_value value, String path, ?allow_empty: bool) -> String
+      def string: (json_value value, String path, ?allow_empty: bool) -> String
+
+      # @rbs (json_value value, String path) -> String
+      def digest: (json_value value, String path) -> String
+
+      # @rbs (json_value value, String path) -> Integer
+      def positive_integer: (json_value value, String path) -> Integer
+
+      # @rbs (json_value value, String path) -> Integer
+      def nonnegative_integer: (json_value value, String path) -> Integer
+
+      # @rbs [T] (T value, Array[T] values, String path) -> T
+      def enum: [T] (T value, Array[T] values, String path) -> T
+
+      # @rbs (json_value actual, json_value expected, String path) -> void
+      def equal: (json_value actual, json_value expected, String path) -> void
+    end
+  end
+end

data/sig/ibex/verification_report.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/ibex/verification_report.rb with RBS::Inline
+
+module Ibex
+  # A versioned, scoped report that binds bounded verification to input and
+  # data-only parser table identities without claiming to verify opaque code.
+  module VerificationReport
+    IDENTIFIER: String
+
+    SCHEMA_VERSION: Integer
+
+    IR_IDENTITY_SCOPE: String
+
+    DEFAULT_MAX_STATES: Integer
+
+    DEFAULT_MAX_ITEMS: Integer
+
+    EXCLUDED_TRUST: Array[String]
+
+    class ValidationError < Ibex::Error
+    end
+
+    # Rebuild the supplied Automaton IR with path-neutral source locations for one bundle.
+    # @rbs (IR::Automaton automaton, source_records: Array[GenerationInput]) -> IR::Automaton
+    def self?.canonical_automaton: (IR::Automaton automaton, source_records: Array[GenerationInput]) -> IR::Automaton
+
+    # @rbs (IR::Automaton automaton, table: TableArtifact::Document,
+    #   source_records: Array[GenerationInput], table_path: String, ?strict: bool,
+    #   ?max_states: Integer, ?max_items: Integer) -> String
+    def self?.render: (IR::Automaton automaton, table: TableArtifact::Document, source_records: Array[GenerationInput], table_path: String, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> String
+
+    # Validate the closed report shape and its canonical evidence digest.
+    # @rbs (String source) -> Hash[String, VerificationReport::Validator::json_value]
+    def self?.validate: (String source) -> Hash[String, VerificationReport::Validator::json_value]
+
+    # Validate report, table, and manifest bytes as one non-cyclic bundle.
+    # @rbs (manifest_source: String, report_source: String, table_source: String) -> Hash[String, VerificationReport::Validator::json_value]
+    def self?.validate_bundle: (manifest_source: String, report_source: String, table_source: String) -> Hash[String, VerificationReport::Validator::json_value]
+
+    # Resolve the report and table through a manifest and validate every
+    # published artifact before checking the cross-artifact identities.
+    # @rbs (String manifest_path) -> Hash[String, VerificationReport::Validator::json_value]
+    def self?.validate_bundle_file: (String manifest_path) -> Hash[String, VerificationReport::Validator::json_value]
+  end
+end

data/sig/ibex/verify/action_correspondence.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/ibex/verify/action_correspondence.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    type correspondence_action = IR::parser_action
+
+    # Compares resolved ACTION/GOTO behavior over all paired viable prefixes.
+    class ActionCorrespondence
+      class Difference < Struct[Symbol | Integer? | correspondence_action?]
+        attr_accessor kind: Symbol
+        attr_accessor canonical_state: Integer
+        attr_accessor target_state: Integer
+        attr_accessor symbol: Integer?
+        attr_accessor canonical: correspondence_action?
+        attr_accessor target: correspondence_action?
+        def self.new: (kind: Symbol, canonical_state: Integer, target_state: Integer, symbol: Integer?, canonical: correspondence_action?, target: correspondence_action?) -> instance
+      end
+
+      class Result < Struct[Array[Difference] | Integer | bool]
+        attr_accessor differences: Array[Difference]
+        attr_accessor explored: Integer
+        attr_accessor truncated: bool
+        def self.new: (differences: Array[Difference], explored: Integer, truncated: bool) -> instance
+        def ok?: () -> bool
+      end
+
+      # @rbs (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+      def initialize: (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+
+      # @rbs () -> Result
+      def verify: () -> Result
+
+      private
+
+      # @rbs (Integer, Integer, IR::AutomatonState, IR::AutomatonState,
+      #   Array[Difference], Array[Array[Integer]]) -> void
+      def compare_terminals: (Integer, Integer, IR::AutomatonState, IR::AutomatonState, Array[Difference], Array[Array[Integer]]) -> void
+
+      # @rbs (Integer, Integer, IR::AutomatonState, IR::AutomatonState,
+      #   Array[Difference], Array[Array[Integer]]) -> void
+      def compare_gotos: (Integer, Integer, IR::AutomatonState, IR::AutomatonState, Array[Difference], Array[Array[Integer]]) -> void
+
+      # @rbs (IR::AutomatonState, Integer) -> IR::parser_action
+      def effective_action: (IR::AutomatonState, Integer) -> IR::parser_action
+
+      # @rbs (IR::parser_action) -> Array[Object]
+      def action_signature: (IR::parser_action) -> Array[Object]
+    end
+  end
+end

data/sig/ibex/verify/language_witness.rbs

@@ -0,0 +1,112 @@
+# Generated from lib/ibex/verify/language_witness.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    type witness_status = :accepted | :error | :missing_entry | :shifted
+
+    # Compares canonical and submitted parser acceptance over a bounded set of
+    # terminal sequences.  This is a semantic witness, not a proof of language
+    # equivalence: the reference collection is complete within its budgets and
+    # the token enumeration is deliberately finite.
+    class LanguageWitness
+      class Difference
+        attr_reader entry: String
+
+        attr_reader tokens: Array[String]
+
+        attr_reader canonical: witness_status
+
+        attr_reader target: witness_status
+
+        # @rbs (entry: String, tokens: Array[String], canonical: witness_status,
+        #   target: witness_status) -> void
+        def initialize: (entry: String, tokens: Array[String], canonical: witness_status, target: witness_status) -> void
+      end
+
+      class Result
+        attr_reader differences: Array[Difference]
+
+        attr_reader explored: Integer
+
+        attr_reader truncated: bool
+
+        attr_reader max_tokens: Integer
+
+        attr_reader max_cases: Integer
+
+        # @rbs (differences: Array[Difference], explored: Integer, truncated: bool,
+        #   max_tokens: Integer, max_cases: Integer) -> void
+        def initialize: (differences: Array[Difference], explored: Integer, truncated: bool, max_tokens: Integer, max_cases: Integer) -> void
+
+        # @rbs () -> bool
+        def ok?: () -> bool
+      end
+
+      # @rbs (IR::Grammar grammar, IR::Automaton target, ?max_tokens: Integer,
+      #   ?max_cases: Integer, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize: (IR::Grammar grammar, IR::Automaton target, ?max_tokens: Integer, ?max_cases: Integer, ?max_states: Integer, ?max_items: Integer) -> void
+
+      # @rbs () -> Result
+      def verify: () -> Result
+
+      private
+
+      # @rbs () -> Array[IR::GrammarSymbol]
+      def input_tokens: () -> Array[IR::GrammarSymbol]
+
+      # @rbs (String, Array[Integer], Array[Difference], Integer) -> [Integer, bool]
+      def verify_entry: (String, Array[Integer], Array[Difference], Integer) -> [ Integer, bool ]
+
+      # @rbs (Integer id) -> String
+      def token_name: (Integer id) -> String
+
+      # @rbs (String entry, Array[Integer]) -> witness_status
+      def simulate_target: (String entry, Array[Integer]) -> witness_status
+
+      # Canonical collection is intentionally built here rather than through
+      # the production construction entry point, keeping this witness
+      # independent from construction code.
+      class CanonicalMachine
+        # @rbs (IR::Grammar grammar, max_states: Integer, max_items: Integer) -> void
+        def initialize: (IR::Grammar grammar, max_states: Integer, max_items: Integer) -> void
+
+        # @rbs (String entry, Array[Integer]) -> witness_status
+        def simulate: (String entry, Array[Integer]) -> witness_status
+
+        private
+
+        # @rbs (ReferenceCollection::Collection) -> Array[IR::AutomatonState]
+        def build_states: (ReferenceCollection::Collection) -> Array[IR::AutomatonState]
+
+        # @rbs (ReferenceCollection::Collection, Set[Array[Integer]], Integer) -> IR::AutomatonState
+        def build_state: (ReferenceCollection::Collection, Set[Array[Integer]], Integer) -> IR::AutomatonState
+
+        # @rbs (Array[IR::AutomatonItem], Hash[Integer, Integer]) -> Hash[Integer, IR::parser_action]
+        def resolve_actions: (Array[IR::AutomatonItem], Hash[Integer, Integer]) -> Hash[Integer, IR::parser_action]
+
+        # @rbs (Hash[Integer, Integer]) -> Hash[Integer, Array[IR::parser_action]]
+        def transition_candidates: (Hash[Integer, Integer]) -> Hash[Integer, Array[IR::parser_action]]
+
+        # @rbs (Array[IR::AutomatonItem], Hash[Integer, Array[IR::parser_action]]) -> void
+        def completed_candidates: (Array[IR::AutomatonItem], Hash[Integer, Array[IR::parser_action]]) -> void
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for: (Integer production_id) -> Array[Integer]
+      end
+
+      # A stack machine shared by the canonical reference and submitted IR.
+      class Machine
+        # @rbs (Array[IR::AutomatonState] states, IR::Grammar grammar) -> void
+        def initialize: (Array[IR::AutomatonState] states, IR::Grammar grammar) -> void
+
+        # @rbs (Integer initial, Array[Integer]) -> witness_status
+        def simulate: (Integer initial, Array[Integer]) -> witness_status
+
+        private
+
+        # @rbs (Array[Integer], Integer) -> witness_status
+        def consume: (Array[Integer], Integer) -> witness_status
+      end
+    end
+  end
+end

data/sig/ibex/verify/reference_collection.rbs

@@ -0,0 +1,63 @@
+# Generated from lib/ibex/verify/reference_collection.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    # Independently derives canonical LR(1) and LR(0) item collections.
+    class ReferenceCollection
+      # Immutable canonical collection and its symbol transitions.
+      class Collection
+        attr_reader states: Array[Set[Array[Integer]]]
+
+        attr_reader transitions: Array[Hash[Integer, Integer]]
+
+        # @rbs (states: Array[Set[Array[Integer]]], transitions: Array[Hash[Integer, Integer]]) -> void
+        def initialize: (states: Array[Set[Array[Integer]]], transitions: Array[Hash[Integer, Integer]]) -> void
+      end
+
+      # @rbs (IR::Grammar grammar, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize: (IR::Grammar grammar, ?max_states: Integer, ?max_items: Integer) -> void
+
+      # @rbs (Symbol kind) -> Collection
+      def build: (Symbol kind) -> Collection
+
+      private
+
+      # @rbs (Array[Set[Array[Integer]]] seeds, Symbol kind) -> Collection
+      def collection: (Array[Set[Array[Integer]]] seeds, Symbol kind) -> Collection
+
+      # @rbs (Array[Set[Array[Integer]]] states, Hash[Array[Array[Integer]], Integer] indexes,
+      #   Set[Array[Integer]] state) -> Integer
+      def insert_state: (Array[Set[Array[Integer]]] states, Hash[Array[Array[Integer]], Integer] indexes, Set[Array[Integer]] state) -> Integer
+
+      # @rbs (Set[Array[Integer]] seed, Symbol kind) -> Set[Array[Integer]]
+      def closure: (Set[Array[Integer]] seed, Symbol kind) -> Set[Array[Integer]]
+
+      # @rbs (Set[Array[Integer]] state, Integer symbol_id, Symbol kind) -> Set[Array[Integer]]
+      def go_to: (Set[Array[Integer]] state, Integer symbol_id, Symbol kind) -> Set[Array[Integer]]
+
+      # @rbs (Set[Array[Integer]] items, Array[Array[Integer]] queue, Array[Integer] item) -> void
+      def add_item: (Set[Array[Integer]] items, Array[Array[Integer]] queue, Array[Integer] item) -> void
+
+      # @rbs () -> void
+      def account_item: () -> void
+
+      # @rbs (Set[Array[Integer]] state) -> Array[Integer]
+      def next_symbols: (Set[Array[Integer]] state) -> Array[Integer]
+
+      # @rbs (Integer production_id, Integer dot, Integer? inherited) -> Array[Integer]
+      def closure_lookaheads: (Integer production_id, Integer dot, Integer? inherited) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> IR::GrammarSymbol
+      def start_symbol: (Integer production_id) -> IR::GrammarSymbol
+
+      # @rbs () -> Integer
+      def eof_id: () -> Integer
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def bounds: () -> Hash[Symbol, Integer]
+    end
+  end
+end

data/sig/ibex/verify/result.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/ibex/verify/result.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    # One stable verifier finding.
+    class Violation
+      attr_reader id: String
+
+      attr_reader location: String
+
+      attr_reader message: String
+
+      # @rbs (id: String, location: String, message: String) -> void
+      def initialize: (id: String, location: String, message: String) -> void
+
+      # @rbs () -> Hash[Symbol, String]
+      def to_h: () -> Hash[Symbol, String]
+    end
+
+    # Immutable independent-verification report.
+    class Result
+      type report_value = String | Integer | bool | Array[String] | Hash[Symbol, Integer] | Array[Hash[Symbol, String]]
+
+      attr_reader algorithm: String
+
+      attr_reader strict: bool
+
+      attr_reader checks: Array[String]
+
+      attr_reader violations: Array[Violation]
+
+      attr_reader bounds: Hash[Symbol, Integer]
+
+      # @rbs (algorithm: String, strict: bool, checks: Array[String], violations: Array[Violation],
+      #   bounds: Hash[Symbol, Integer]) -> void
+      def initialize: (algorithm: String, strict: bool, checks: Array[String], violations: Array[Violation], bounds: Hash[Symbol, Integer]) -> void
+
+      # @rbs () -> bool
+      def valid?: () -> bool
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h: () -> Hash[Symbol, report_value]
+    end
+
+    class BudgetExceeded < Ibex::Error
+      attr_reader bounds: Hash[Symbol, Integer]
+
+      # @rbs (String message, bounds: Hash[Symbol, Integer]) -> void
+      def initialize: (String message, bounds: Hash[Symbol, Integer]) -> void
+    end
+  end
+end

data/sig/ibex/verify/verifier.rbs

@@ -0,0 +1,170 @@
+# Generated from lib/ibex/verify/verifier.rb with RBS::Inline
+
+module Ibex
+  module Verify
+    # Checks Automaton IR semantics against an independently derived collection.
+    # rubocop:disable Metrics/ClassLength -- V1-V9 share one violation and item-identity model.
+    class Verifier
+      DEFAULT_CHECKS: Array[String]
+
+      STRICT_CHECKS: Array[String]
+
+      ERROR_ACTION: IR::error_action
+
+      # @rbs (IR::Automaton automaton, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize: (IR::Automaton automaton, ?strict: bool, ?max_states: Integer, ?max_items: Integer) -> void
+
+      # @rbs () -> Result
+      def verify: () -> Result
+
+      private
+
+      # V9 is a bounded semantic witness for IELR only.  It deliberately does
+      # not replace V1/V2 or claim unbounded language equivalence.
+      # @rbs () -> void
+      def verify_ielr_adequacy: () -> void
+
+      # @rbs () -> void
+      def verify_grammar_digest: () -> void
+
+      # @rbs () -> void
+      def verify_item_collection: () -> void
+
+      # SLR lookaheads affect completed items only. The builder may retain
+      # propagation lookaheads on non-completed items, but they cannot select
+      # an ACTION cell and therefore are outside the SLR semantic contract.
+      # @rbs (Array[Set[Array[Integer]]] expected_states) -> void
+      def compare_slr_states: (Array[Set[Array[Integer]]] expected_states) -> void
+
+      # @rbs (IR::AutomatonState state,
+      #   Hash[Array[Array[Integer]], Array[Set[Array[Integer]]]] expected_by_core) ->
+      #   Array[Array[Integer]]?
+      def verify_slr_state: (IR::AutomatonState state, Hash[Array[Array[Integer]], Array[Set[Array[Integer]]]] expected_by_core) -> Array[Array[Integer]]?
+
+      # @rbs (IR::AutomatonState state, IR::AutomatonItem item) -> void
+      def verify_slr_lookaheads: (IR::AutomatonState state, IR::AutomatonItem item) -> void
+
+      # @rbs () -> Array[Set[Array[Integer]]]
+      def lr1_states: () -> Array[Set[Array[Integer]]]
+
+      # @rbs () -> Array[Set[Array[Integer]]]
+      def lalr_states: () -> Array[Set[Array[Integer]]]
+
+      # @rbs () -> Array[Set[Array[Integer]]]
+      def canonical_lr1_states: () -> Array[Set[Array[Integer]]]
+
+      # @rbs (Array[Set[Array[Integer]]] expected_states) -> void
+      def compare_expected_states: (Array[Set[Array[Integer]]] expected_states) -> void
+
+      # @rbs (Array[Set[Array[Integer]]] expected_states) -> void
+      def compare_ielr_states: (Array[Set[Array[Integer]]] expected_states) -> void
+
+      # @rbs () -> void
+      def verify_transitions_and_actions: () -> void
+
+      # @rbs (IR::AutomatonState state) -> void
+      def verify_transition_items: (IR::AutomatonState state) -> void
+
+      # @rbs (IR::AutomatonState state) -> void
+      def verify_state_actions: (IR::AutomatonState state) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected,
+      #   IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+      def verify_terminal_action: (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected, IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action actual) -> void
+      def verify_error_cell: (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action actual) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action expected,
+      #   IR::parser_action actual) -> void
+      def verify_single_action: (IR::AutomatonState state, IR::GrammarSymbol terminal, IR::parser_action expected, IR::parser_action actual) -> void
+
+      # @rbs (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected,
+      #   IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+      def verify_conflicted_action: (IR::AutomatonState state, IR::GrammarSymbol terminal, Array[IR::parser_action] expected, IR::parser_action actual, Array[Integer] conflict_tokens) -> void
+
+      # @rbs () -> void
+      def verify_table_formats: () -> void
+
+      # @rbs (Tables::action_table table, Integer row) -> Hash[Integer, IR::runtime_action]
+      def action_row: (Tables::action_table table, Integer row) -> Hash[Integer, IR::runtime_action]
+
+      # @rbs (Tables::goto_table table, Integer row) -> Hash[Integer, untyped]
+      def goto_row: (Tables::goto_table table, Integer row) -> Hash[Integer, untyped]
+
+      # @rbs () -> void
+      def verify_reachability_and_productivity: () -> void
+
+      # @rbs () -> void
+      def verify_epsilon_termination: () -> void
+
+      # @rbs () -> void
+      def verify_conflict_determinism: () -> void
+
+      # @rbs (IR::AutomatonState state, IR::conflict conflict) -> void
+      def verify_conflict_resolution: (IR::AutomatonState state, IR::conflict conflict) -> void
+
+      # @rbs (IR::conflict conflict) -> Array[IR::parser_action]
+      def conflict_candidates: (IR::conflict conflict) -> Array[IR::parser_action]
+
+      # @rbs (IR::conflict conflict) -> IR::parser_action?
+      def resolved_conflict_action: (IR::conflict conflict) -> IR::parser_action?
+
+      # @rbs (IR::AutomatonState state) -> Hash[Integer, Array[IR::parser_action]]
+      def action_candidates: (IR::AutomatonState state) -> Hash[Integer, Array[IR::parser_action]]
+
+      # @rbs (IR::AutomatonState state, Integer symbol_id) -> Array[Array[Integer]]
+      def shifted_items: (IR::AutomatonState state, Integer symbol_id) -> Array[Array[Integer]]
+
+      # @rbs (IR::AutomatonState state, Integer terminal_id) -> IR::parser_action
+      def effective_action: (IR::AutomatonState state, Integer terminal_id) -> IR::parser_action
+
+      # @rbs () -> Set[Integer]
+      def reachable_states: () -> Set[Integer]
+
+      # @rbs () -> Set[Integer]
+      def productive_nonterminals: () -> Set[Integer]
+
+      # @rbs (Hash[Integer, Integer] edges) -> bool
+      def directed_cycle?: (Hash[Integer, Integer] edges) -> bool
+
+      # @rbs (IR::AutomatonState state) -> Set[Array[Integer]]
+      def expanded_items: (IR::AutomatonState state) -> Set[Array[Integer]]
+
+      # Automaton IR intentionally exposes every augmented production as -1,
+      # even when construction internally assigned one per start symbol.
+      # @rbs (Set[Array[Integer]] state) -> Set[Array[Integer]]
+      def visible_state: (Set[Array[Integer]] state) -> Set[Array[Integer]]
+
+      # @rbs (Set[Array[Integer]] state) -> Array[Array[Integer]]
+      def core_key: (Set[Array[Integer]] state) -> Array[Array[Integer]]
+
+      # @rbs (Array[Set[Array[Integer]]] states) -> Hash[Array[Array[Integer]], Integer]
+      def multiset: (Array[Set[Array[Integer]]] states) -> Hash[Array[Array[Integer]], Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def follow_ids: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> IR::GrammarSymbol
+      def start_symbol: (Integer production_id) -> IR::GrammarSymbol
+
+      # @rbs () -> Integer
+      def eof_id: () -> Integer
+
+      # @rbs () -> Array[Integer]
+      def start_symbol_ids: () -> Array[Integer]
+
+      # @rbs () -> ReferenceCollection
+      def reference: () -> ReferenceCollection
+
+      # @rbs (String id, String location, String message) -> void
+      def violation: (String id, String location, String message) -> void
+
+      # @rbs (IR::AutomatonState state) -> String
+      def state_path: (IR::AutomatonState state) -> String
+    end
+  end
+end