Struct LSTAR 

pub struct LSTAR {
    pub input_vocabulary: Vec<Letter>,
    pub knowledge_base: Arc<Mutex<dyn KnowledgeBaseTrait>>,
    pub tmp_dir: Option<String>,
    pub observation_table: Option<ObservationTable>,
    pub max_states: usize,
    pub equivalence_test: Arc<dyn EquivalenceTest>,
    /* private fields */
}

The L* algorithm implementation

Fields

input_vocabulary: Vec<Letter>

knowledge_base: Arc<Mutex<dyn KnowledgeBaseTrait>>

tmp_dir: Option<String>

observation_table: Option<ObservationTable>

max_states: usize

equivalence_test: Arc<dyn EquivalenceTest>

Implementations

impl LSTAR

pub fn new( input_vocabulary: Vec<String>, knowledge_base: Arc<Mutex<dyn KnowledgeBaseTrait>>, max_states: usize, tmp_dir: Option<String>, eq_test: Option<Arc<dyn EquivalenceTest>>, ) -> Self

Create a new LSTAR learner

Examples found in repository

examples/vending_machine.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Vending Machine Learning Example ===\n");

    // Create a vending machine knowledge base (SUL)
    let kb = Arc::new(Mutex::new(VendingMachineKB::new()));

    // Define input vocabulary
    let vocabulary = vec![
        "INSERT_COIN".to_string(),
        "PRESS_A".to_string(),
        "PRESS_B".to_string(),
    ];

    // Run L* learner
    let mut learner = LSTAR::new(vocabulary, kb.clone(), 4, None, None);
    match learner.learn() {
        Ok(automata) => {
            println!("\n=== Learned Vending Machine ===\n");
            println!("{}", automata.build_dot_code());
        }
        Err(e) => eprintln!("Learning error: {}", e),
    }

    let kb_guard = kb.lock().unwrap();
    println!("\nKnowledge Base Statistics:\n{}", kb_guard.stats);

    Ok(())
}

examples/custom_kb.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Custom Knowledge Base Example ===");
    println!("Simulating a banking ATM protocol\n");

    let kb = Arc::new(Mutex::new(ATMKnowledgeBase::new()));

    let vocabulary = vec![
        "INSERT_CARD".to_string(),
        "ENTER_PIN".to_string(),
        "REQUEST_WITHDRAW".to_string(),
        "EJECT_CARD".to_string(),
        "TIMEOUT".to_string(),
    ];

    let mut lstar = LSTAR::new(vocabulary, kb.clone(), 8, None, None);

    match lstar.learn() {
        Ok(automata) => {
            println!("\n=== Learned ATM Protocol ===");
            println!("{}", automata.build_dot_code());
            println!("\nATM protocol learned successfully!");
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    let kb_guard = kb.lock().unwrap();
    println!("\nKnowledge Base Stats:\n{}", kb_guard.stats);

    Ok(())
}

examples/memory_kb.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Memory Knowledge Base Learning Example ===\n");

    let input_symbols = vec!["a", "b", "c"];
    let output_symbols = vec!["0", "1", "2", "3"];
    let target_state_count = 5;
    let max_states = 8;

    let target = build_random_machine(target_state_count, &input_symbols, &output_symbols);
    println!(
        "Random target generated (states={}, transitions={})",
        target.get_states().len(),
        target.transitions.len()
    );

    let kb = Arc::new(Mutex::new(RandomMachineKnowledgeBase::new(target.clone())));
    let vocabulary = input_symbols
        .iter()
        .map(|symbol| symbol.to_string())
        .collect::<Vec<_>>();

    let mut learner = LSTAR::new(vocabulary, kb.clone(), max_states, None, None);
    let learned = learner.learn()?;

    println!("\n=== Learned Automaton ===");
    println!("{}", learned.build_dot_code());

    let kb_guard = kb.lock().unwrap();
    println!("\nKnowledge Base Statistics:\n{}", kb_guard.stats());

    Ok(())
}

examples/network_custom_kb.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Network Custom KB (ATM) Example ===\n");

    // Expects an independent ATM server running
    // (see examples/custom_kb_server.rs).
    let kb = NetworkActiveKnowledgeBase::new("127.0.0.1".to_string(), 3001, Duration::from_secs(5));

    let vocabulary = vec![
        "INSERT_CARD".to_string(),
        "ENTER_PIN".to_string(),
        "REQUEST_WITHDRAW".to_string(),
        "EJECT_CARD".to_string(),
        "TIMEOUT".to_string(),
    ];

    println!("Target Host: {}", kb.target_host());
    println!("Target Port: {}\n", kb.target_port());

    let kb: Arc<Mutex<dyn KnowledgeBaseTrait>> = Arc::new(Mutex::new(kb));
    let mut learner = LSTAR::new(vocabulary, kb, 8, None, None);

    match learner.learn() {
        Ok(automata) => {
            println!("\n=== Learned ATM Automaton from Network Target ===\n");
            println!("{}", automata.build_dot_code());
            println!(
                "\nStates: {}\nTransitions: {}",
                automata.get_states().len(),
                automata.transitions.len()
            );
        }
        Err(e) => {
            eprintln!("Learning error: {}", e);
            println!("\nTo run this example with a real connection:");
            println!("  1. Start ATM server: cargo run --example custom_kb_server");
            println!("  2. Run this example again: cargo run --example network_custom_kb");
        }
    }

    Ok(())
}

examples/network_kb.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Network Active Knowledge Base Example ===\n");

    // This example expects an independent coffee server running
    // (see examples/coffee_server.rs).
    let kb = NetworkActiveKnowledgeBase::new("127.0.0.1".to_string(), 3000, Duration::from_secs(5));

    // Define input vocabulary
    let vocabulary = vec![
        "REFILL_WATER".to_string(),
        "REFILL_COFFEE".to_string(),
        "PRESS_BUTTON_A".to_string(),
        "PRESS_BUTTON_B".to_string(),
        "PRESS_BUTTON_C".to_string(),
    ];

    println!("Target Host: {}", kb.target_host());
    println!("Target Port: {}\n", kb.target_port());

    let kb: Arc<Mutex<dyn KnowledgeBaseTrait>> = Arc::new(Mutex::new(kb));

    // Create learner. The network KB connects per submitted word.
    let mut learner = LSTAR::new(vocabulary, kb, 4, None, None);

    match learner.learn() {
        Ok(automata) => {
            println!("\n=== Learned Automaton from Network Target ===\n");
            println!("{}", automata.build_dot_code());
            println!(
                "\nStates: {}\nTransitions: {}",
                automata.get_states().len(),
                automata.transitions.len()
            );
        }
        Err(e) => {
            eprintln!("Learning error: {}", e);
            println!("\nTo run this example with a real connection:");
            println!("  1. Start a coffee server: cargo run --example coffee_server");
            println!("  2. Run this example again");
        }
    }

    Ok(())
}

examples/all_eqtests_custom_kb.rs (line 85)

fn run_strategy(name: &str, builder: &EqBuilder) -> StrategyReport {
    let vocabulary = vec![
        "INSERT_CARD".to_string(),
        "ENTER_PIN".to_string(),
        "REQUEST_WITHDRAW".to_string(),
        "EJECT_CARD".to_string(),
        "TIMEOUT".to_string(),
    ];
    let input_letters = vocabulary
        .iter()
        .map(|s| Letter::new(s))
        .collect::<Vec<_>>();
    let max_states = 8;

    let kb = Arc::new(Mutex::new(ATMKnowledgeBase::new()));
    let knowledge_base: SharedKb = kb.clone();
    let eqtest = builder(knowledge_base.clone(), input_letters, max_states);
    let mut learner = LSTAR::new(vocabulary, knowledge_base, max_states, None, Some(eqtest));

    println!("\n--- Running {name} ---");
    let started = Instant::now();
    let learn_result = learner.learn();
    let elapsed_ms = started.elapsed().as_millis();

    let stats = {
        let kb_guard = kb.lock().unwrap();
        StatsSnapshot::from_stats(&kb_guard.stats)
    };

    match learn_result {
        Ok(automata) => {
            let state_count = automata.get_states().len();
            let transition_count = automata.transitions.len();
            println!("{name}: success (states={state_count}, transitions={transition_count})");
            StrategyReport {
                name: name.to_string(),
                elapsed_ms,
                state_count: Some(state_count),
                transition_count: Some(transition_count),
                error: None,
                stats,
            }
        }
        Err(err) => {
            println!("{name}: failed ({err})");
            StrategyReport {
                name: name.to_string(),
                elapsed_ms,
                state_count: None,
                transition_count: None,
                error: Some(err),
                stats,
            }
        }
    }
}

Additional examples can be found in:

• examples/random_walk_eq.rs
• examples/benchmark.rs

pub fn with_equivalence_test(self, eq_test: Arc<dyn EquivalenceTest>) -> Self

Set a custom equivalence test

Examples found in repository

examples/random_walk_eq.rs (line 51)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Random Walk Equivalence Test Example ===\n");

    // Create a simple system
    let mut kb = DemoKnowledgeBase::new();

    // Define a simple state machine:
    // S0 -a/0-> S1   (initial state)
    // S0 -b/1-> S0
    // S1 -a/0-> S2
    // S1 -b/1-> S0
    // S2 -a/0-> S2
    // S2 -b/1-> S1

    // Make outputs state-dependent so learner must distinguish states
    kb.add_transition("s0", "a", "0", "s1");
    kb.add_transition("s0", "b", "1", "s0");
    kb.add_transition("s1", "a", "1", "s2");
    kb.add_transition("s1", "b", "0", "s0");
    kb.add_transition("s2", "a", "1", "s2");
    kb.add_transition("s2", "b", "0", "s1");

    let knowledge_base = Arc::new(Mutex::new(kb));

    // Create vocabulary
    let vocabulary = vec!["a".to_string(), "b".to_string()];

    // Create learner
    let mut lstar = LSTAR::new(vocabulary.clone(), knowledge_base.clone(), 5, None, None);

    // Use random walk equivalence test instead of W-method
    let input_letters = vocabulary
        .iter()
        .map(|s| Letter::new(s))
        .collect::<Vec<_>>();
    let random_walk = RandomWalkMethod::new(
        knowledge_base.clone(),
        input_letters,
        10000, // max_steps: 10000 steps
        0.75,  // restart_probability: 75%
    );

    lstar = lstar.with_equivalence_test(Arc::new(random_walk));

    // Run learning
    match lstar.learn() {
        Ok(automata) => {
            println!("\n=== Learned Automaton (Random Walk Test) ===\n");
            println!("{}", automata.build_dot_code());
            println!("\nLearning completed successfully!");

            // Print statistics
            println!("\nStatistics:");
            println!("  Number of states: {}", automata.get_states().len());
            println!("  Number of transitions: {}", automata.transitions.len());
        }
        Err(e) => eprintln!("Error during learning: {}", e),
    }

    let kb_guard = knowledge_base.lock().unwrap();
    println!("\nKnowledge Base Statistics:\n{}", kb_guard.stats);

    Ok(())
}

pub fn stop(&mut self)

Stop the learning process

pub fn learn(&mut self) -> Result<Automata, String>

Run the L* algorithm

Examples found in repository

examples/vending_machine.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Vending Machine Learning Example ===\n");

    // Create a vending machine knowledge base (SUL)
    let kb = Arc::new(Mutex::new(VendingMachineKB::new()));

    // Define input vocabulary
    let vocabulary = vec![
        "INSERT_COIN".to_string(),
        "PRESS_A".to_string(),
        "PRESS_B".to_string(),
    ];

    // Run L* learner
    let mut learner = LSTAR::new(vocabulary, kb.clone(), 4, None, None);
    match learner.learn() {
        Ok(automata) => {
            println!("\n=== Learned Vending Machine ===\n");
            println!("{}", automata.build_dot_code());
        }
        Err(e) => eprintln!("Learning error: {}", e),
    }

    let kb_guard = kb.lock().unwrap();
    println!("\nKnowledge Base Statistics:\n{}", kb_guard.stats);

    Ok(())
}

examples/custom_kb.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Custom Knowledge Base Example ===");
    println!("Simulating a banking ATM protocol\n");

    let kb = Arc::new(Mutex::new(ATMKnowledgeBase::new()));

    let vocabulary = vec![
        "INSERT_CARD".to_string(),
        "ENTER_PIN".to_string(),
        "REQUEST_WITHDRAW".to_string(),
        "EJECT_CARD".to_string(),
        "TIMEOUT".to_string(),
    ];

    let mut lstar = LSTAR::new(vocabulary, kb.clone(), 8, None, None);

    match lstar.learn() {
        Ok(automata) => {
            println!("\n=== Learned ATM Protocol ===");
            println!("{}", automata.build_dot_code());
            println!("\nATM protocol learned successfully!");
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    let kb_guard = kb.lock().unwrap();
    println!("\nKnowledge Base Stats:\n{}", kb_guard.stats);

    Ok(())
}

examples/memory_kb.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Memory Knowledge Base Learning Example ===\n");

    let input_symbols = vec!["a", "b", "c"];
    let output_symbols = vec!["0", "1", "2", "3"];
    let target_state_count = 5;
    let max_states = 8;

    let target = build_random_machine(target_state_count, &input_symbols, &output_symbols);
    println!(
        "Random target generated (states={}, transitions={})",
        target.get_states().len(),
        target.transitions.len()
    );

    let kb = Arc::new(Mutex::new(RandomMachineKnowledgeBase::new(target.clone())));
    let vocabulary = input_symbols
        .iter()
        .map(|symbol| symbol.to_string())
        .collect::<Vec<_>>();

    let mut learner = LSTAR::new(vocabulary, kb.clone(), max_states, None, None);
    let learned = learner.learn()?;

    println!("\n=== Learned Automaton ===");
    println!("{}", learned.build_dot_code());

    let kb_guard = kb.lock().unwrap();
    println!("\nKnowledge Base Statistics:\n{}", kb_guard.stats());

    Ok(())
}

examples/network_custom_kb.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Network Custom KB (ATM) Example ===\n");

    // Expects an independent ATM server running
    // (see examples/custom_kb_server.rs).
    let kb = NetworkActiveKnowledgeBase::new("127.0.0.1".to_string(), 3001, Duration::from_secs(5));

    let vocabulary = vec![
        "INSERT_CARD".to_string(),
        "ENTER_PIN".to_string(),
        "REQUEST_WITHDRAW".to_string(),
        "EJECT_CARD".to_string(),
        "TIMEOUT".to_string(),
    ];

    println!("Target Host: {}", kb.target_host());
    println!("Target Port: {}\n", kb.target_port());

    let kb: Arc<Mutex<dyn KnowledgeBaseTrait>> = Arc::new(Mutex::new(kb));
    let mut learner = LSTAR::new(vocabulary, kb, 8, None, None);

    match learner.learn() {
        Ok(automata) => {
            println!("\n=== Learned ATM Automaton from Network Target ===\n");
            println!("{}", automata.build_dot_code());
            println!(
                "\nStates: {}\nTransitions: {}",
                automata.get_states().len(),
                automata.transitions.len()
            );
        }
        Err(e) => {
            eprintln!("Learning error: {}", e);
            println!("\nTo run this example with a real connection:");
            println!("  1. Start ATM server: cargo run --example custom_kb_server");
            println!("  2. Run this example again: cargo run --example network_custom_kb");
        }
    }

    Ok(())
}

examples/network_kb.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Network Active Knowledge Base Example ===\n");

    // This example expects an independent coffee server running
    // (see examples/coffee_server.rs).
    let kb = NetworkActiveKnowledgeBase::new("127.0.0.1".to_string(), 3000, Duration::from_secs(5));

    // Define input vocabulary
    let vocabulary = vec![
        "REFILL_WATER".to_string(),
        "REFILL_COFFEE".to_string(),
        "PRESS_BUTTON_A".to_string(),
        "PRESS_BUTTON_B".to_string(),
        "PRESS_BUTTON_C".to_string(),
    ];

    println!("Target Host: {}", kb.target_host());
    println!("Target Port: {}\n", kb.target_port());

    let kb: Arc<Mutex<dyn KnowledgeBaseTrait>> = Arc::new(Mutex::new(kb));

    // Create learner. The network KB connects per submitted word.
    let mut learner = LSTAR::new(vocabulary, kb, 4, None, None);

    match learner.learn() {
        Ok(automata) => {
            println!("\n=== Learned Automaton from Network Target ===\n");
            println!("{}", automata.build_dot_code());
            println!(
                "\nStates: {}\nTransitions: {}",
                automata.get_states().len(),
                automata.transitions.len()
            );
        }
        Err(e) => {
            eprintln!("Learning error: {}", e);
            println!("\nTo run this example with a real connection:");
            println!("  1. Start a coffee server: cargo run --example coffee_server");
            println!("  2. Run this example again");
        }
    }

    Ok(())
}

examples/all_eqtests_custom_kb.rs (line 89)

fn run_strategy(name: &str, builder: &EqBuilder) -> StrategyReport {
    let vocabulary = vec![
        "INSERT_CARD".to_string(),
        "ENTER_PIN".to_string(),
        "REQUEST_WITHDRAW".to_string(),
        "EJECT_CARD".to_string(),
        "TIMEOUT".to_string(),
    ];
    let input_letters = vocabulary
        .iter()
        .map(|s| Letter::new(s))
        .collect::<Vec<_>>();
    let max_states = 8;

    let kb = Arc::new(Mutex::new(ATMKnowledgeBase::new()));
    let knowledge_base: SharedKb = kb.clone();
    let eqtest = builder(knowledge_base.clone(), input_letters, max_states);
    let mut learner = LSTAR::new(vocabulary, knowledge_base, max_states, None, Some(eqtest));

    println!("\n--- Running {name} ---");
    let started = Instant::now();
    let learn_result = learner.learn();
    let elapsed_ms = started.elapsed().as_millis();

    let stats = {
        let kb_guard = kb.lock().unwrap();
        StatsSnapshot::from_stats(&kb_guard.stats)
    };

    match learn_result {
        Ok(automata) => {
            let state_count = automata.get_states().len();
            let transition_count = automata.transitions.len();
            println!("{name}: success (states={state_count}, transitions={transition_count})");
            StrategyReport {
                name: name.to_string(),
                elapsed_ms,
                state_count: Some(state_count),
                transition_count: Some(transition_count),
                error: None,
                stats,
            }
        }
        Err(err) => {
            println!("{name}: failed ({err})");
            StrategyReport {
                name: name.to_string(),
                elapsed_ms,
                state_count: None,
                transition_count: None,
                error: Some(err),
                stats,
            }
        }
    }
}

Additional examples can be found in:

• examples/random_walk_eq.rs
• examples/benchmark.rs