Enum Letter 

pub enum Letter {
    Single(String),
    Multiple(Vec<String>),
}

Represents a single letter/symbol in the alphabet.

Variants

Single(String)

Multiple(Vec<String>)

Implementations

impl Letter

pub fn new<S: ToString>(symbol: S) -> Self

Create a new letter from a single symbol

Examples found in repository

examples/vending_machine.rs (line 91)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        // Reset to initial state for each query
        self.state = VendingState::Idle;

        let mut outputs = Vec::new();
        for input_letter in query.input_word.letters() {
            let command_string = input_letter.symbols();
            let command = command_string.as_str();

            let (next, resp) = self.process_input(command, self.state);
            self.state = next;
            outputs.push(Letter::new(resp));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/custom_kb.rs (line 112)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());
        // Reset to initial state for each query
        self.state = ATMState::Idle;

        // let mut state = self.state.lock().unwrap();
        let mut outputs = Vec::new();

        for input_letter in query.input_word.letters() {
            // Extract command from letter name (format: "Letter('x')")
            let symbol = input_letter.symbols();
            let command = symbol.as_str();

            let (next_state, response) = self.process_input(command, self.state);
            self.state = next_state;
            outputs.push(Letter::new(response));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/benchmark.rs (line 107)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.current_state = "s0".to_string();
        let mut output_letters = Vec::new();

        for input_letter in query.input_word.letters() {
            let input = input_letter.symbols();
            let key = (self.current_state.clone(), input);
            let (output, next_state) = self
                .transitions
                .get(&key)
                .cloned()
                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;

            output_letters.push(Letter::new(output));
            self.current_state = next_state;
        }

        query.set_result(Word::from_letters(output_letters));
        Ok(())
    }

examples/memory_kb.rs (line 112)

fn build_random_machine(
    state_count: usize,
    input_symbols: &[&str],
    output_symbols: &[&str],
) -> Automata {
    let mut rng = SimpleRng::new();
    let mut automata = Automata::new(State::new("S0".to_string()), "RandomTarget".to_string());
    let mut transitions = Vec::new();
    let mut transition_id = 0usize;

    for state_idx in 0..state_count {
        let source_state = format!("S{}", state_idx);
        for input_symbol in input_symbols {
            let next_state_idx = rng.gen_range(0, state_count);
            let output_idx = rng.gen_range(0, output_symbols.len());

            transitions.push(Transition::new_with_source(
                format!("t{}", transition_id),
                source_state.clone(),
                State::new(format!("S{}", next_state_idx)),
                Letter::new(*input_symbol),
                Letter::new(output_symbols[output_idx]),
            ));
            transition_id += 1;
        }
    }

    automata.transitions = transitions;
    automata
}

examples/all_eqtests_custom_kb.rs (line 78)

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,
            }
        }
    }
}

fn print_summary(reports: &[StrategyReport]) {
    println!("\n=== Final Statistics Summary ===");
    for report in reports {
        println!("\n[{}]", report.name);
        println!("  runtime_ms: {}", report.elapsed_ms);
        match (&report.state_count, &report.transition_count) {
            (Some(states), Some(transitions)) => {
                println!("  states: {}", states);
                println!("  transitions: {}", transitions);
            }
            _ => println!("  model: n/a"),
        }
        match &report.error {
            Some(err) => println!("  status: failed ({err})"),
            None => println!("  status: success"),
        }
        println!("  kb_nb_query: {}", report.stats.nb_query);
        println!(
            "  kb_nb_submitted_query: {}",
            report.stats.nb_submitted_query
        );
        println!("  kb_nb_letter: {}", report.stats.nb_letter);
        println!(
            "  kb_nb_submitted_letter: {}",
            report.stats.nb_submitted_letter
        );
    }
}

/// Minimal ATM simulator used as a custom knowledge base.
struct ATMKnowledgeBase {
    state: ATMState,
    stats: KnowledgeBaseStats,
}

#[derive(Clone, Copy)]
enum ATMState {
    Idle,
    CardInserted,
    Authenticated,
    Ready,
    Dispensing,
}

impl ATMKnowledgeBase {
    fn new() -> Self {
        Self {
            state: ATMState::Idle,
            stats: KnowledgeBaseStats::new(),
        }
    }

    fn process_input(&self, command: &str, current_state: ATMState) -> (ATMState, &'static str) {
        match current_state {
            ATMState::Idle => match command {
                "INSERT_CARD" => (ATMState::CardInserted, "CARD_ACCEPTED"),
                _ => (ATMState::Idle, "INVALID_OP"),
            },
            ATMState::CardInserted => match command {
                "ENTER_PIN" => (ATMState::Authenticated, "PIN_VERIFIED"),
                "EJECT_CARD" => (ATMState::Idle, "CARD_EJECTED"),
                _ => (ATMState::CardInserted, "RETRY"),
            },
            ATMState::Authenticated => match command {
                "REQUEST_WITHDRAW" => (ATMState::Ready, "ENTER_AMOUNT"),
                "EJECT_CARD" => (ATMState::Idle, "CARD_EJECTED"),
                "TIMEOUT" => (ATMState::Idle, "SESSION_TIMEOUT"),
                _ => (ATMState::Authenticated, "INVALID_COMMAND"),
            },
            ATMState::Ready => match command {
                "REQUEST_WITHDRAW" => (ATMState::Dispensing, "DISPENSING"),
                "EJECT_CARD" => (ATMState::Idle, "CARD_EJECTED"),
                _ => (ATMState::Ready, "WAIT"),
            },
            ATMState::Dispensing => match command {
                "EJECT_CARD" => (ATMState::Idle, "CARD_EJECTED"),
                _ => (ATMState::Dispensing, "DISPENSING"),
            },
        }
    }
}

impl KnowledgeBaseTrait for ATMKnowledgeBase {
    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.state = ATMState::Idle;
        let mut outputs = Vec::new();

        for input_letter in query.input_word.letters() {
            let command = input_letter.symbols();
            let (next_state, response) = self.process_input(command.as_str(), self.state);
            self.state = next_state;
            outputs.push(Letter::new(response));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/random_walk_eq.rs (line 42)

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(())
}

struct DemoKnowledgeBase {
    transitions: HashMap<(String, String), (String, String)>,
    current_state: String,
    stats: KnowledgeBaseStats,
}

impl DemoKnowledgeBase {
    fn new() -> Self {
        Self {
            transitions: std::collections::HashMap::new(),
            current_state: "s0".to_string(),
            stats: KnowledgeBaseStats::new(),
        }
    }

    fn add_transition(&mut self, from_state: &str, input: &str, output: &str, to_state: &str) {
        self.transitions.insert(
            (from_state.to_string(), input.to_string()),
            (output.to_string(), to_state.to_string()),
        );
    }
}

impl KnowledgeBaseTrait for DemoKnowledgeBase {
    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.current_state = "s0".to_string();
        let mut output_letters = Vec::new();

        for input_letter in query.input_word.letters() {
            let input = input_letter.symbols();
            let key = (self.current_state.clone(), input);
            let (output, next_state) = self
                .transitions
                .get(&key)
                .cloned()
                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;

            output_letters.push(Letter::new(output));
            self.current_state = next_state;
        }

        query.set_result(Word::from_letters(output_letters));
        Ok(())
    }

Additional examples can be found in:

• examples/atm_automata.rs

pub fn from_symbols(symbols: Vec<String>) -> Self

Create a letter from multiple symbols

pub fn symbols(&self) -> String

Get the symbols represented by this letter

Examples found in repository

examples/all_eqtests_custom_kb.rs (line 218)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.state = ATMState::Idle;
        let mut outputs = Vec::new();

        for input_letter in query.input_word.letters() {
            let command = input_letter.symbols();
            let (next_state, response) = self.process_input(command.as_str(), self.state);
            self.state = next_state;
            outputs.push(Letter::new(response));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/vending_machine.rs (line 86)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        // Reset to initial state for each query
        self.state = VendingState::Idle;

        let mut outputs = Vec::new();
        for input_letter in query.input_word.letters() {
            let command_string = input_letter.symbols();
            let command = command_string.as_str();

            let (next, resp) = self.process_input(command, self.state);
            self.state = next;
            outputs.push(Letter::new(resp));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/custom_kb.rs (line 107)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());
        // Reset to initial state for each query
        self.state = ATMState::Idle;

        // let mut state = self.state.lock().unwrap();
        let mut outputs = Vec::new();

        for input_letter in query.input_word.letters() {
            // Extract command from letter name (format: "Letter('x')")
            let symbol = input_letter.symbols();
            let command = symbol.as_str();

            let (next_state, response) = self.process_input(command, self.state);
            self.state = next_state;
            outputs.push(Letter::new(response));
        }

        query.set_result(Word::from_letters(outputs));
        Ok(())
    }

examples/benchmark.rs (line 99)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.current_state = "s0".to_string();
        let mut output_letters = Vec::new();

        for input_letter in query.input_word.letters() {
            let input = input_letter.symbols();
            let key = (self.current_state.clone(), input);
            let (output, next_state) = self
                .transitions
                .get(&key)
                .cloned()
                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;

            output_letters.push(Letter::new(output));
            self.current_state = next_state;
        }

        query.set_result(Word::from_letters(output_letters));
        Ok(())
    }

examples/random_walk_eq.rs (line 108)

    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
        self.stats.increment_nb_query();
        self.stats.add_nb_letter(query.input_word.len());
        self.stats.increment_nb_submitted_query();
        self.stats.add_nb_submitted_letter(query.input_word.len());

        self.current_state = "s0".to_string();
        let mut output_letters = Vec::new();

        for input_letter in query.input_word.letters() {
            let input = input_letter.symbols();
            let key = (self.current_state.clone(), input);
            let (output, next_state) = self
                .transitions
                .get(&key)
                .cloned()
                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;

            output_letters.push(Letter::new(output));
            self.current_state = next_state;
        }

        query.set_result(Word::from_letters(output_letters));
        Ok(())
    }

pub fn name(&self) -> String

Get a string representation of this letter

pub fn is_empty(&self) -> bool

Check if this is an empty letter

pub fn deserialize( str_letters: &str, possible_letters: &[Letter], ) -> Result<Letter, String>

Deserialize a comma-separated string of letter names into a Letter

Trait Implementations

impl Clone for Letter

fn clone(&self) -> Letter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Letter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Letter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Letter

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Letter

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Letter