Struct ConceptGraphBuilder 

pub struct ConceptGraphBuilder {
    pub config: CgGraphConfig,
    pub concepts: Vec<CgConcept>,
    pub term_to_id: HashMap<String, ConceptId>,
    pub edges: Vec<CgConceptEdge>,
    pub adjacency: HashMap<usize, Vec<usize>>,
    pub total_documents: u64,
    /* private fields */
}

Builds and queries a semantic concept graph.

Example

use ipfrs_semantic::{CgGraphConfig, ConceptGraphBuilder};

let mut builder = ConceptGraphBuilder::new(CgGraphConfig::default());
builder.process_document("doc1", "the quick brown fox jumps over the lazy dog");
builder.process_document("doc2", "the brown fox ran across the field");
let stats = builder.graph_stats();
assert!(stats.concept_count > 0);

Fields

config: CgGraphConfig

concepts: Vec<CgConcept>

All concepts indexed by their stable ConceptId.

term_to_id: HashMap<String, ConceptId>

Reverse map: term → concept index.

edges: Vec<CgConceptEdge>

All edges (both directions may be represented; deduplication is done via the canonical-pair key stored in edge_index).

adjacency: HashMap<usize, Vec<usize>>

Concept id → list of indices into edges (both in-coming and out-going).

total_documents: u64

Implementations

impl ConceptGraphBuilder

pub fn new(config: CgGraphConfig) -> Self

Create a new builder with the supplied configuration.

pub fn add_concept_term( &mut self, term: String, embedding: Option<Vec<f64>>, ) -> ConceptId

Return the ConceptId for term, creating it if it does not exist and the max-concept cap has not been reached.

pub fn process_document(&mut self, doc_id: &str, text: &str)

Tokenize text, index all tokens as concepts, and record co-occurrence edges within the sliding window.

pub fn add_relation( &mut self, term_a: &str, term_b: &str, relation: CgConceptRelation, weight: f64, ) -> bool

Add an explicit semantic relation edge.

Returns false if either term_a or term_b is unknown.

pub fn concept_by_term(&self, term: &str) -> Option<&CgConcept>

Look up a concept by its term string.

pub fn concept_by_id(&self, id: ConceptId) -> Option<&CgConcept>

Look up a concept by its ConceptId.

pub fn neighbors(&self, id: ConceptId) -> Vec<(&CgConcept, f64)>

Return all direct neighbours of id sorted by edge weight (descending).

Each element is (neighbour_concept, edge_weight).

pub fn shortest_path( &self, from: ConceptId, to: ConceptId, ) -> Option<Vec<ConceptId>>

BFS shortest path from from to to.

Returns None if the nodes are not connected.

pub fn similar_concepts( &self, id: ConceptId, k: usize, ) -> Vec<(&CgConcept, f64)>

Return the top-k concepts most similar to id.

Strategy:

• If the target concept has an embedding, rank all other embedded concepts by cosine similarity.
• Otherwise fall back to the top-k neighbours by edge weight.

pub fn prune_low_frequency(&mut self) -> usize

Remove all concepts whose frequency is below min_concept_frequency.

Associated edges and adjacency entries are also removed. Returns the number of concepts removed.

pub fn prune_weak_edges(&mut self) -> usize

Remove all edges whose weight is below min_edge_weight.

Returns the number of edges removed.

pub fn graph_stats(&self) -> ConceptGraphStats

Compute a snapshot of graph statistics.