Struct GraphCoref 

pub struct GraphCoref { /* private fields */ }

Graph-based coreference resolver with iterative refinement.

This implements a heuristic version of the G2GT architecture, preserving the key insight that iterative graph refinement enables global consistency in coreference decisions.

Algorithm

1. Initialize: Empty graph with mentions as nodes
2. Iterate: For each mention pair, compute score with graph context
3. Update: Add/remove edges based on threshold
4. Converge: Stop when graph unchanged or max iterations reached
5. Extract: Connected components become coreference chains

Complexity

• Time: O(N² × T) where N = mentions, T = iterations (typically 4)
• Space: O(N²) for adjacency representation

Compare to Lee et al. (2017): O(N⁴) for full span enumeration.

Feature Usage

The resolver uses available Mention fields when present:

Field	Used For	Fallback
mention_type	Pronoun detection, type compatibility	Heuristic detection
head_start/head_end	Head word matching	Last word of mention
entity_type	Type compatibility check	Ignored

Implementations

impl GraphCoref

pub fn new() -> Self

Create a new graph coref resolver with default configuration.

pub fn with_config(config: GraphCorefConfig) -> Self

Create with custom configuration.

pub fn resolve(&self, mentions: &[Mention]) -> Vec<CorefChain>

Resolve coreferences among mentions using iterative graph refinement.

Arguments

• mentions - Pre-detected mentions (from NER or mention detector). For best results, set mention_type on each mention.

Returns

Coreference chains (clusters) where each chain contains mentions referring to the same entity. By default, singletons are filtered; set config.include_singletons = true to include them.

Panics

Does not panic. Empty input returns empty output.

Example

use anno::backends::graph_coref::GraphCoref;
use anno::{Mention, MentionType};

let coref = GraphCoref::new();

let mut john = Mention::new("John", 0, 4);
john.mention_type = Some(MentionType::Proper);

let mut he = Mention::new("he", 20, 22);
he.mention_type = Some(MentionType::Pronominal);

let chains = coref.resolve(&[john, he]);

pub fn config(&self) -> &GraphCorefConfig

Get configuration.

impl GraphCoref

pub fn resolve_with_stats( &self, mentions: &[Mention], ) -> (Vec<CorefChain>, GraphCorefStats)

Resolve coreferences and return detailed statistics.

Useful for debugging, tuning parameters, and understanding convergence.

Example

use anno::backends::graph_coref::GraphCoref;
use anno::Mention;

let coref = GraphCoref::new();
let mentions = vec![
    Mention::new("John", 0, 4),
    Mention::new("John", 50, 54),
];

let (chains, stats) = coref.resolve_with_stats(&mentions);
println!("Converged in {} iterations", stats.iterations);
println!("Edge history: {:?}", stats.edge_history);

Trait Implementations

impl Clone for GraphCoref

fn clone(&self) -> GraphCoref

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphCoref

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

Formats the value using the given formatter.

impl Default for GraphCoref

fn default() -> Self

Returns the “default value” for a type.