Struct SummaryView 

pub struct SummaryView {
    pub round: u32,
    pub summary: Vec<SuperEdge>,
    pub class_hierarchy: Vec<ClassNode>,
    pub level_rollups: Vec<LevelRollup>,
    pub level_links: Vec<LevelLinks>,
    pub descriptors: Vec<CommunityDescriptor>,
    pub subclass_cycles: Vec<Vec<String>>,
    pub disjoint_pairs: Vec<(String, String)>,
    pub equivalent_pairs: Vec<(String, String)>,
    /* private fields */
}

A lightweight, overview-only view of a file: the pyramid summary graph plus just enough dictionary to label predicates. Fetched via ranges without touching the (large) triple index — the “load the coarse graph first” path from SPEC.md §7.2.

Fields

round: u32

summary: Vec<SuperEdge>

class_hierarchy: Vec<ClassNode>

The shipped subClassOf hierarchy (v2 schema pyramid; empty on v1 files).

level_rollups: Vec<LevelRollup>

Per-level type rollups — the leveled legend, read index-free.

level_links: Vec<LevelLinks>

Per-level lateral class-relation graph (the non-is-a connections).

descriptors: Vec<CommunityDescriptor>

Per-community descriptors (Phase 4 progressive refinement; may be empty).

subclass_cycles: Vec<Vec<String>>

subClassOf cycles (v2.1; empty on older files).

disjoint_pairs: Vec<(String, String)>

owl:disjointWith class pairs (v2.1; empty on older files).

equivalent_pairs: Vec<(String, String)>

owl:equivalentClass class pairs (v2.1; empty on older files).

Implementations

impl SummaryView

pub fn open_ranged<R: RangeReader>( reader: &R, ) -> Result<Option<Self>, FileError>

Read header → dictionary → pyramid-meta only (skips the index container).

pub fn open_schema_ranged<R: RangeReader>( reader: &R, ) -> Result<Option<Self>, FileError>

A schema-only view of a file without a pyramid, from its SCHEMA section (kind 9): the hierarchy, levels and axioms, with an empty community summary. Reads the header and the SCHEMA section only — the section carries its own class and predicate strings, so no dictionary. Ok(None) when the file has no SCHEMA section. Callers that need the summary (cost, federation source selection, progressive queries) use open_ranged, which keeps requiring a pyramid.

pub fn level_count(&self) -> usize

Number of semantic-zoom levels in the schema pyramid (0 if none shipped).

pub fn level_rollup(&self, k: usize) -> Option<&LevelRollup>

The type rollup at semantic level k (0 = coarsest/most abstract), or None if k is out of range. Index-free — answered from the pyramid-meta.

pub fn predicate_term(&self, id: u32) -> Option<String>

Resolve a predicate ID in the summary to its term.

pub fn predicate_total(&self, predicate: &str) -> u32

Exact number of triples using predicate, summed from the summary’s superedge counts — answered without ever reading the triple index.

pub fn predicate_totals(&self) -> Vec<(String, u32)>

All predicates with their exact triple totals, descending by count.

pub fn community_count(&self) -> usize

Number of communities the summary spans (distinct supernode endpoints).

pub fn tbox_coherence(&self) -> Vec<Inconsistency>

Index-free T-Box coherence (Tier-0). Detect schema-level incoherent points purely from the shipped schema pyramid — no triple index, no instance data, O(ontology) regardless of graph size:

• subclass-cycle: a set of classes that are mutually rdfs:subClassOf.
• unsatisfiable-class: a class whose ancestor closure (over all parents, folded through owl:equivalentClass) contains both ends of an owl:disjointWith pair, so no individual can ever be one.

Soundness is bounded by what the pyramid ships: the subClassOf hierarchy is capped (MAX_HIERARCHY in schema_pyramid), so on a very large ontology a pruned ancestor can hide an unsatisfiable class (a false coherent, never a false incoherent). Instance-level clashes (a node typed into disjoint classes, functional-property clashes) are NOT visible here — they need the A-Box (Tier-1/Tier-2 reason).

pub fn tbox_is_coherent(&self) -> bool

True when tbox_coherence finds no schema-level incoherent point.