Kastor Reasoning Framework

import com.geoknoesis.kastor.rdf.*
import com.geoknoesis.kastor.rdf.reasoning.*
import com.geoknoesis.kastor.rdf.vocab.RDF
import com.geoknoesis.kastor.rdf.vocab.RDFS

// Create a graph with RDFS schema
val graph = Rdf.graph {
    prefixes {
        put("ex", "http://example.org/")
    }
    
    // Define class hierarchy
    val person = iri("ex:Person")
    val student = iri("ex:Student")
    val teacher = iri("ex:Teacher")
    
    person - RDFS.subClassOf - RDFS.Resource
    student - RDFS.subClassOf - person
    teacher - RDFS.subClassOf - person
    
    // Define property hierarchy
    val knows = iri("ex:knows")
    val teaches = iri("ex:teaches")
    
    knows - RDFS.subPropertyOf - RDFS.seeAlso
    teaches - RDFS.subPropertyOf - knows
    
    // Domain and range
    knows - RDFS.domain - person
    knows - RDFS.range - person
    
    // Instances
    val alice = iri("ex:alice")
    val bob = iri("ex:bob")
    
    alice - RDF.type - student
    bob - RDF.type - teacher
    alice - teaches - bob
}

// Create a reasoner
val reasoner = RdfReasoning.reasoner(ReasonerType.RDFS)

// Perform reasoning
val result = reasoner.reason(graph)

println("Found ${result.inferredTriples.size} inferred triples")
println("Graph is consistent: ${result.consistencyCheck.isConsistent}")

// Show inferred triples
result.inferredTriples.forEach { triple ->
    println("  $triple")
}

// Get available providers
val providers = RdfReasoning.reasonerProviders()
providers.forEach { provider ->
    println("${provider.name} (${provider.getType()}) - v${provider.version}")
    println("  Supported types: ${provider.getSupportedTypes().joinToString(", ")}")
}

// Use specific provider
// (com.geoknoesis.kastor.rdf.jena.reasoning.JenaReasonerProvider,
//  com.geoknoesis.kastor.rdf.rdf4j.reasoning.Rdf4jReasonerProvider)
val jenaReasoner = JenaReasonerProvider().createReasoner(ReasonerConfig.rdfs())
val rdf4jReasoner = Rdf4jReasonerProvider().createReasoner(ReasonerConfig.rdfs())

// Default configuration
val defaultConfig = ReasonerConfig.default()

// RDFS-specific configuration
val rdfsConfig = ReasonerConfig.rdfs()

// OWL-EL configuration (no bundled provider serves OWL_EL; Jena rejects it)
val owlElConfig = ReasonerConfig.owlEl()

// Recommended configuration for a type (used by RdfReasoning.reasoner(type))
val dlConfig = ReasonerConfig.forType(ReasonerType.OWL_DL)

// Large graph configuration
val largeGraphConfig = ReasonerConfig.forLargeGraphs()

// Memory-constrained configuration
val memoryConfig = ReasonerConfig.forMemoryConstrained()

// Custom configuration
val customConfig = ReasonerConfig(
    reasonerType = ReasonerType.RDFS,
    enabledRules = setOf(
        ReasoningRule.RDFS_SUBCLASS,
        ReasoningRule.RDFS_SUBPROPERTY
    ),
    timeout = Duration.ofMinutes(10),
    includeAxioms = true
)

data class ReasoningResult(
    val originalGraph: RdfGraph,
    val inferredTriples: List<RdfTriple>,
    val classification: ClassificationResult?,
    val consistencyCheck: ConsistencyResult,
    val reasoningTime: Duration,
    val statistics: ReasoningStatistics
)

data class ClassificationResult(
    val classHierarchy: Map<Iri, List<Iri>>,      // class -> superclasses
    val instanceClassifications: Map<Iri, List<Iri>>, // instance -> types
    val propertyHierarchy: Map<Iri, List<Iri>>,   // property -> superproperties
    val equivalentClasses: Map<Iri, Set<Iri>>,
    val disjointClasses: Map<Iri, Set<Iri>>
)

data class ConsistencyResult(
    val isConsistent: Boolean,
    val inconsistencies: List<Inconsistency>,
    val warnings: List<String>,
    val explanations: List<Explanation>
)

data class ValidationReport(
    val isValid: Boolean,
    val violations: List<ValidationViolation>,
    val warnings: List<String>,
    val statistics: ValidationStatistics
)

data class ReasonerCapabilities(
    val supportedTypes: Set<ReasonerType>,
    val supportsIncrementalReasoning: Boolean,
    val supportsCustomRules: Boolean,
    val supportsExplanation: Boolean,
    val supportsConsistencyChecking: Boolean,
    val supportsClassification: Boolean,
    val maxGraphSize: Long,
    val typicalPerformance: PerformanceProfile
)

class BasicReasoningTest {
    @Test
    fun `memory reasoner performs basic RDFS inference`() {
        val graph = createSampleGraph()
        // Picks the highest-priority RDFS provider: the memory reasoner unless Jena/RDF4J reasoning is on the classpath
        val reasoner = RdfReasoning.reasoner(ReasonerType.RDFS)
        
        val result = reasoner.reason(graph)
        
        assertNotNull(result)
        assertTrue(result.inferredTriples.isNotEmpty())
        assertTrue(result.consistencyCheck.isConsistent)
        assertNotNull(result.classification)
    }
}