Skip to content

validation.md

Latest commit

 

History

History
114 lines (80 loc) · 2.96 KB

validation.md

File metadata and controls

114 lines (80 loc) · 2.96 KB

Validation System

We often require our cell complexes to satisfy geometric constraints. The validation system provides modular, extensible validation for embedded cell complexes to ensure they represent proper embeddings in Euclidean space.

Overview

The validation system distinguishes between two types of rules:

  • Structural Rules (always checked): Basic requirements like vertex counts and dimension validity
  • Geometric Rules (optional): Embedding properties like non-intersecting edges and faces

Architecture

The validation system consists of several components:

  1. Base Classes: Abstract interfaces for validation rules and results
  2. Validation Rules: Concrete implementations for specific validation checks
  3. Validator: Main orchestrator that manages and applies rules

Validation Rules

Structural Rules (Always Enforced)

  • DimensionValidityRule: Ensures cell dimensions are non-negative
  • VertexCountRule: Validates correct vertex counts for cell dimensions
    • 0-cells must have exactly 1 vertex
    • 1-cells must have exactly 2 vertices
    • k-cells (k ≥ 2) must have at least 3 vertices

Geometric Rules (Optional)

  • EdgeInteriorRule: Ensures no vertices lie on edge interiors
  • FaceInteriorRule: Ensures no vertices lie inside face interiors
  • SelfIntersectionRule: Validates that face edges don't self-intersect
  • BoundaryEdgeRule: Ensures required boundary edges exist for faces

Usage

from ect import EmbeddedComplex

# Enable validation during construction
K = EmbeddedComplex(validate_embedding=True)

# Or enable/disable later
K.enable_embedding_validation(tol=1e-10)
K.disable_embedding_validation()

# Override per operation
K.add_cell(vertices, dim=2, check=True)

Custom Validation Rules

You can create custom validation rules by inheriting from ValidationRule:

from ect.validation import ValidationRule, ValidationResult

class MyCustomRule(ValidationRule):
    @property
    def name(self) -> str:
        return "My Custom Rule"
    
    @property
    def is_structural(self) -> bool:
        return False  # Geometric rule
    
    def applies_to_dimension(self, dim: int) -> bool:
        return dim == 2  # Only for 2-cells
    
    def validate(self, cell_coords, all_coords, cell_indices, all_indices, dim):
        # Your validation logic here
        if some_condition:
            return ValidationResult.valid()
        else:
            return ValidationResult.invalid("Validation failed")

# Add to validator
K.get_validator().add_rule(MyCustomRule())

API Reference

Main Module

.. automodule:: ect.validation
   :members:

Base Classes

.. automodule:: ect.validation.base
   :members:
   :show-inheritance:

Validation Rules

.. automodule:: ect.validation.rules
   :members:
   :show-inheritance:

Validator

.. automodule:: ect.validation.validator
   :members:
   :show-inheritance: