add test-cases for Moore and DFAs in hW, rename function params

Author: emuskardin

aalpy/learning_algs/resetless/hW.py

@@ -819,8 +819,14 @@ def main_loop(self, print_level=2):
         return hypothesis, info
 
 
-def run_hW(alphabet: list, sul, automaton_type='mealy', num_testing_steps=200, reset_testing_counter=True,
-           query_for_initial_state=True, H=None, W=None, return_data=False, print_level=2):
+def run_hW(alphabet: list, sul, automaton_type='mealy',
+           num_testing_steps=200,
+           reset_testing_counter=True,
+           query_for_initial_state=True,
+           provided_homing_sequence=None,
+           provided_characterization_set=None,
+           return_data=False,
+           print_level=2):
     """
     Executes the hW resetless learning algorithm.
     Algorithm description can be found in "hW-inference: A heuristic approach to retrieve models through
@@ -845,10 +851,10 @@ def run_hW(alphabet: list, sul, automaton_type='mealy', num_testing_steps=200, r
 
         query_for_initial_state: if True, query the SUL to identify the true initial state (Default value = True)
 
-        H: optional user-provided homing sequence. If supplied, hW starts with this sequence instead of deriving an
+        provided_homing_sequence: optional user-provided homing sequence. If supplied, hW starts with this sequence instead of deriving an
             initial one from the daisy hypothesis counterexample. (Default value = None)
 
-        W: optional user-provided characterization set. If supplied, hW starts with these suffixes instead of an empty
+        provided_characterization_set: optional user-provided characterization set. If supplied, hW starts with these suffixes instead of an empty
             characterization set. For Moore machines and DFAs, the empty suffix is added automatically.
             (Default value = None)
 
@@ -873,8 +879,8 @@ def run_hW(alphabet: list, sul, automaton_type='mealy', num_testing_steps=200, r
         num_testing_steps=num_testing_steps,
         reset_testing_counter=reset_testing_counter,
         query_for_initial_state=query_for_initial_state,
-        H=H,
-        W=W,
+        H=provided_homing_sequence,
+        W=provided_characterization_set,
     )
 
     hypothesis, info = hw.main_loop(print_level=print_level)

tests/test_hW_moore_dfa.py

@@ -0,0 +1,109 @@
+import pytest
+
+from aalpy import generate_random_deterministic_automata, bisimilar, run_hW
+from aalpy.SULs import MealySUL
+
+SEEDS = list(range(20))
+MODEL_SIZES = [
+    (2, 2, 2),
+    (2, 2, 3),
+    (3, 2, 2),
+    (3, 2, 3),
+    (3, 3, 2),
+    (4, 2, 3),
+    (4, 3, 2),
+    (5, 3, 3),
+    (6, 2, 3),
+    (6, 3, 2),
+    (10, 2, 3),
+    (10, 2, 4),
+    (10, 2, 2),
+    (10, 2, 3),
+    (20, 5, 5),
+    (30, 3, 4),
+]
+
+TEST_CASES = [
+    pytest.param(
+        automaton_type,
+        seed_val,
+        num_states,
+        input_size,
+        output_size,
+        id=f"states={num_states}-inputs={input_size}-outputs={output_size}-seed={seed_val}-automaton_type={automaton_type}",
+    )
+    for num_states, input_size, output_size in MODEL_SIZES
+    for seed_val in SEEDS
+    for automaton_type in ['dfa', 'moore']
+]
+
+
+@pytest.mark.parametrize("automaton_type,seed_val,num_states,input_size,output_size", TEST_CASES)
+@pytest.mark.timeout(5)
+def test_hw_seed(automaton_type, seed_val, num_states, input_size, output_size):
+    from random import seed
+
+    seed(seed_val)
+
+    model = generate_random_deterministic_automata(
+        automaton_type,
+        num_states=num_states,
+        input_alphabet_size=input_size,
+        output_alphabet_size=output_size,
+    )
+    if not model.is_minimal():
+        pytest.skip(f"seed {seed_val} does not produce a minimal model")
+    if not model.is_strongly_connected():
+        pytest.skip(
+            f"seed {seed_val} does not produce a strongly connected model "
+            f"for states={num_states}, inputs={input_size}, outputs={output_size}"
+        )
+
+    sul = MealySUL(model)
+    input_alphabet = model.get_input_alphabet()
+
+
+    learned_model = run_hW(input_alphabet,
+                     sul,
+                     num_testing_steps=1000 * num_states,
+                     automaton_type=automaton_type,
+                     reset_testing_counter=True,
+                     query_for_initial_state=True)
+
+    assert learned_model.is_minimal()
+
+    print(learned_model)
+    print(model)
+    assert bisimilar(model, learned_model)
+
+
+def test_hw_uses_user_provided_h_and_w():
+    from aalpy import bisimilar, generate_random_deterministic_automata, run_hW, AutomatonSUL
+    from random import seed
+    seed(1)
+
+    model = generate_random_deterministic_automata(
+        'mealy',
+        num_states=100,
+        input_alphabet_size=4,
+        output_alphabet_size=4,
+    )
+
+    sul = AutomatonSUL(model)
+    input_alphabet = model.get_input_alphabet()
+
+    char_set = model.compute_characterization_set()
+
+    assert model.is_minimal() and model.is_minimal()
+
+    learned_model = run_hW(input_alphabet,
+                           sul,
+                           automaton_type='mealy',
+                           provided_characterization_set=char_set,
+                           num_testing_steps=2000,
+                           reset_testing_counter=True,
+                           query_for_initial_state=True)
+
+    assert learned_model.is_minimal()
+    assert bisimilar(model, learned_model)
+