Struct InvHom 

pub struct InvHom<'h, A> { /* private fields */ }

Nondeleting inverse-homomorphism automaton.

InvHom<A> accepts a source tree t exactly when the wrapped automaton A accepts the homomorphic image h(t). The state type is unchanged: a source subtree receives the state that A assigns to its image.

The homomorphism is validated when it is built, so every source child occurs exactly once in each image term. This gives the condensed implementation a well-defined way to recover source child states from target-side rules.

Implementations

impl<'h, A> InvHom<'h, A>

pub fn new(inner: A, hom: &'h Homomorphism) -> Self

Wrap inner with the given homomorphism.

pub fn inner(&self) -> &A

Return the wrapped automaton.

pub fn homomorphism(&self) -> &Homomorphism

Return the homomorphism used to map source symbols to target terms.

Trait Implementations

impl<A: BottomUpTa> BottomUpTa for InvHom<'_, A>

type State = <A as BottomUpTa>::State

State type carried by the automaton.

fn step( &self, f_src: Symbol, children: &[A::State], out: &mut dyn FnMut(A::State), )

Report all possible parent states for f(children...).

fn is_accepting(&self, q: &A::State) -> bool

Return whether q is an accepting state.

impl<A> CondensedTa for InvHom<'_, A>

where A: CondensedTa + StateUniverse,

fn condensed_rules( &self, out: &mut dyn FnMut(&[A::State], &SymbolSet, A::State), )

Enumerate every distinct (children, result) pair, reporting the set of symbols that have that shape.

fn condensed_nullary_rules(&self, out: &mut dyn FnMut(&SymbolSet, A::State))

Enumerate condensed nullary rules.

fn condensed_rules_by_child( &self, position: usize, state: &A::State, out: &mut dyn FnMut(&[A::State], &SymbolSet, A::State), )

Enumerate condensed rules whose child at position is state.

impl<A> CondensedTopDownTa for InvHom<'_, A>

where A: TopDownTa,

fn condensed_rules_by_parent( &self, parent: &A::State, out: &mut dyn FnMut(&SymbolSet, &[A::State]), )

Report every condensed rule symbols(children...) -> parent.

fn condensed_initial_states(&self, out: &mut dyn FnMut(A::State))

Report initial states of the top-down view.

impl<A: DetBottomUpTa> DetBottomUpTa for InvHom<'_, A>

fn det_group(&self, f_src: Symbol) -> u32

Source symbols sharing an image term yield identical step_det results for any given children, so the structurally-deduplicated term id groups them: callers can compute one transition per group and reuse it for every symbol in the set. Unmapped symbols (step_det is always None) map to a sentinel group.

fn step_det(&self, f_src: Symbol, children: &[A::State]) -> Option<A::State>

Return the unique result state, or None if no transition exists.

impl IntersectionHeuristic<InvHom<'_, StringDecompositionAutomaton>> for SentenceSxHeuristic<'_>

fn outside_estimate(&self, left: StateId, span: &Span) -> f64

Return an optimistic (admissible) upper bound in (0, 1] on the best outside weight of any completion around product state (left, right).

fn admits(&self, _left: StateId, _right: &R::State) -> bool

Sound hard filter consulted at candidate-construction time: return false iff (left, right) provably has zero outside weight (it can appear in no valid completion), so the A* loop may skip building the edge entirely rather than merely deprioritizing it.

fn estimate_if_admitted(&self, left: StateId, right: &R::State) -> Option<f64>

Return the outside estimate when the product is admitted, and None when it is provably unable to occur in an accepting derivation.

fn memoize_admission(&self) -> bool

Whether A* should memoize the admission decision by product pair.

fn estimate_after_admission(&self, left: StateId, right: &R::State) -> f64

Return the outside estimate when admission for this pair is already known to succeed.

impl IntersectionHeuristic<InvHom<'_, StringDecompositionAutomaton>> for ObligatoryLeafHeuristic<'_>

fn outside_estimate(&self, left: StateId, span: &Span) -> f64

Return an optimistic (admissible) upper bound in (0, 1] on the best outside weight of any completion around product state (left, right).

fn admits(&self, left: StateId, span: &Span) -> bool

Sound hard filter consulted at candidate-construction time: return false iff (left, right) provably has zero outside weight (it can appear in no valid completion), so the A* loop may skip building the edge entirely rather than merely deprioritizing it.

fn estimate_if_admitted(&self, left: StateId, span: &Span) -> Option<f64>

Return the outside estimate when the product is admitted, and None when it is provably unable to occur in an accepting derivation.

fn memoize_admission(&self) -> bool

Whether A* should memoize the admission decision by product pair.

fn estimate_after_admission(&self, _left: StateId, _span: &Span) -> f64

Return the outside estimate when admission for this pair is already known to succeed.

impl<A: StateUniverse> StateUniverse for InvHom<'_, A>

fn all_states(&self, out: &mut dyn FnMut(A::State))

Report every state in the finite universe exactly once.