Struct Namespace 

pub struct Namespace {
    pub grassmannian: (usize, usize),
    pub position: SchubertClass,
    pub capabilities: Vec<Capability>,
    pub name: String,
}

A namespace: a point in a Grassmannian with associated capabilities

Namespaces represent isolated execution contexts. Their position in the Grassmannian encodes their “geometric location” while their capabilities determine what operations they can perform.

Contracts

• All capabilities must be compatible with the namespace’s Grassmannian
• Capabilities must satisfy dependency ordering
• No two conflicting capabilities can coexist

Fields

grassmannian: (usize, usize)

The Grassmannian this namespace lives in: Gr(k, n)

position: SchubertClass

Schubert cell containing this namespace (its “position”)

capabilities: Vec<Capability>

Capabilities granted to this namespace

name: String

Human-readable name

Implementations

impl Namespace

Namespace integration

pub fn is_degenerate(&self) -> bool

Check if the namespace is degenerate (CSM Euler characteristic is anomalous).

A namespace is degenerate if the CSM class of its position has unexpected Euler characteristic.

Contract

ensures: result == (euler_characteristic(c_SM(position)) != 1)

pub fn csm_count_configurations(&self) -> i64

Count configurations using CSM-corrected intersection theory.

When the intersection is potentially singular, use CSM classes to get the corrected count.

Contract

ensures: result >= 0 when intersection is transverse
ensures: result == 1 when self.capabilities.is_empty()

impl Namespace

Matroid-based namespace analysis.

pub fn capability_matroid(&self) -> Option<Matroid>

Compute the capability matroid of this namespace.

Capabilities are elements; a set is independent if the corresponding Schubert classes have a transverse intersection.

Contract

ensures: result.is_some() implies result.ground_set_size == self.capabilities.len()
ensures: result.is_none() implies self.capabilities.is_empty()

pub fn redundant_capabilities(&self) -> Vec<CapabilityId>

Find redundant capabilities: those that don’t affect the matroid rank.

A capability is redundant if removing it doesn’t change the rank of the capability matroid (i.e., it is a loop).

Contract

ensures: forall id in result. removing id does not change matroid rank

pub fn max_shared_capabilities(&self, other: &Namespace) -> usize

Maximum number of capabilities that can be shared between two namespaces.

Uses matroid intersection to find the largest common independent set.

Contract

ensures: result <= min(self.capabilities.len(), other.capabilities.len())

impl Namespace

pub fn new(name: impl Into<String>, position: SchubertClass) -> Self

Create a new namespace at a given Schubert position

pub fn full( name: impl Into<String>, k: usize, n: usize, ) -> EnumerativeResult<Self>

Create a namespace with full access (identity Schubert class)

Contract

requires: k < n
ensures: result.position.partition.is_empty()
ensures: result.grassmannian == (k, n)

pub fn grant(&mut self, capability: Capability) -> Result<(), NamespaceError>

Grant a capability to this namespace

Contract

requires: forall dep in capability.requires. self.has_capability(dep)
requires: forall conf in capability.conflicts. !self.has_capability(conf)
requires: forall existing in self.capabilities. !existing.conflicts.contains(capability.id)
ensures: self.has_capability(capability.id)

Errors

Returns NamespaceError::Conflict if the capability conflicts with an existing one. Returns NamespaceError::MissingDependency if a required capability is missing.

pub fn grant_all( &mut self, capabilities: Vec<Capability>, ) -> Result<(), NamespaceError>

Try to grant multiple capabilities in dependency order

This is a convenience method that attempts to grant capabilities in the order that satisfies dependencies.

pub fn revoke(&mut self, id: &CapabilityId) -> bool

Revoke a capability from this namespace

Contract

requires: no other capability depends on this one
ensures: !self.has_capability(id)

Returns true if the capability was revoked, false if it couldn’t be (either not present or has dependents).

pub fn has_capability(&self, id: &CapabilityId) -> bool

Check if this namespace has a specific capability

pub fn capability_ids(&self) -> Vec<CapabilityId>

Get all capability IDs

pub fn capability_count(&self) -> usize

Get the number of capabilities

pub fn count_configurations(&self) -> IntersectionResult

Count valid configurations satisfying all capability constraints

This computes the intersection number of the position Schubert class with all capability Schubert classes.

Contract

ensures:
  - total_codim > dim(Gr) => Empty
  - total_codim == dim(Gr) => Finite(n) where n >= 0
  - total_codim < dim(Gr) => PositiveDimensional

pub fn total_codimension(&self) -> usize

Total codimension of position plus all capabilities

pub fn would_overdetermine(&self, capability: &Capability) -> bool

Check if adding a capability would make the system overdetermined

impl Namespace

pub fn quantum_count_configurations<const P: usize, const Q: usize, const R: usize>( &self, quantum_caps: &[QuantumCapability<P, Q, R>], ) -> (IntersectionResult, Rational64)

Count configurations with quantum K-theoretic corrections

This refines count_configurations by incorporating quantum corrections from rational curves in the Grassmannian.

Returns (classical_count, quantum_euler_characteristic).

Contract

ensures: result.0 == self.count_configurations()

Trait Implementations

impl Clone for Namespace

fn clone(&self) -> Namespace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Namespace

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

Formats the value using the given formatter.