backend/db/models.py

from sqlalchemy import Column, Integer, String, Text, ForeignKey, Index, UniqueConstraint
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.sql import func
from sqlalchemy import DateTime

Base = declarative_base()

class Universe(Base):  # type: ignore[valid-type]
    """Universe model: represents a mathematical universe."""
    __tablename__ = 'universes'
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, unique=True, index=True)
    description = Column(Text)
    universe_type = Column(String, default="generic", index=True)  # e.g., group theory, geometry
    version = Column(Integer, default=1)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())

    __table_args__ = (
        UniqueConstraint('name', 'version', name='uix_universe_name_version'),
        Index('ix_universe_type_version', 'universe_type', 'version'),
    )

class Axiom(Base):  # type: ignore[valid-type]
    """Axiom model: represents an axiom in a universe."""
    __tablename__ = 'axioms'
    id = Column(Integer, primary_key=True, index=True)
    universe_id = Column(Integer, ForeignKey('universes.id'), index=True)
    statement = Column(Text, index=True)
    is_active = Column(Integer, default=1, index=True)  # for axiom evolution
    parent_axiom_id = Column(Integer, ForeignKey('axioms.id'), nullable=True, index=True)  # lineage tracking
    version = Column(Integer, default=1)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())

    __table_args__ = (
        Index('ix_axiom_universe_id_is_active', 'universe_id', 'is_active'),
        Index('ix_axiom_parent_axiom_id', 'parent_axiom_id'),
        UniqueConstraint('universe_id', 'statement', 'version', name='uix_axiom_universe_statement_version'),
    )

class Theorem(Base):  # type: ignore[valid-type]
    """Theorem model: represents a derived theorem."""
    __tablename__ = 'theorems'
    id = Column(Integer, primary_key=True, index=True)
    universe_id = Column(Integer, ForeignKey('universes.id'), index=True)
    statement = Column(Text, index=True)
    proof = Column(Text)
    created_at = Column(DateTime(timezone=True), server_default=func.now())

    __table_args__ = (
        Index('ix_theorem_universe_id_statement', 'universe_id', 'statement'),
    )

class Proof(Base):  # type: ignore[valid-type]
    """Proof model: represents a proof for an axiom."""
    __tablename__ = 'proofs'
    id = Column(Integer, primary_key=True, index=True)
    axiom_id = Column(Integer, ForeignKey('axioms.id'), index=True)
    content = Column(Text)
    created_at = Column(DateTime(timezone=True), server_default=func.now())

    __table_args__ = (
        Index('ix_proof_axiom_id', 'axiom_id'),
    )

class AnalysisResult(Base):  # type: ignore[valid-type]
    """AnalysisResult model: stores analysis results for universes."""
    __tablename__ = 'analysis_results'
    id = Column(Integer, primary_key=True, index=True)
    universe_id = Column(Integer, ForeignKey('universes.id'), index=True)
    result = Column(Text)
    created_at = Column(DateTime(timezone=True), server_default=func.now())

    __table_args__ = (
        Index('ix_analysisresult_universe_id', 'universe_id'),
    )