reasoninglayer 0.1.2

//! Categorical Deep Learning (CDL) DTOs.

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DifferentiableFcRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_iterations: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_weight_threshold: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoftUnifyRequest {
    pub term_a_id: String,
    pub term_b_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TaggedFcRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_iterations: Option<u32>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MonadicFixpointRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_iterations: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FeaturePair {
    pub features_a: Vec<f64>,
    pub features_b: Vec<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DerivedInferenceRequest {
    pub pairs: Vec<FeaturePair>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClassifySafetyRequest {
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub threshold: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicAddSortRequest {
    pub sort_name: String,
    #[serde(default)]
    pub parent_sort_names: Vec<String>,
    #[serde(default)]
    pub feature_names: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WeightedFactDto {
    pub term_id: String,
    pub sort_name: String,
    pub weight: f64,
    pub depth: u32,
    #[serde(default)]
    pub contributing_rules: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IterationMetricDto {
    pub iteration: u32,
    pub active_rules: u32,
    pub max_attention: f64,
    pub entropy: f64,
    pub new_facts: u32,
    pub mean_weight: f64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SymbolicResultDto {
    pub total_facts: u64,
    pub derived_count: u64,
    pub iterations: u32,
    pub fixpoint_reached: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DifferentiableFcResponse {
    #[serde(default)]
    pub weighted_facts: Vec<WeightedFactDto>,
    #[serde(default)]
    pub iteration_metrics: Vec<IterationMetricDto>,
    pub symbolic_result: SymbolicResultDto,
    pub elapsed_ms: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SoftUnifyResponse {
    pub confidence: f64,
    pub sort_score: f64,
    pub feature_score: f64,
    pub hard_compatible: bool,
    pub elapsed_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaggedFactDto {
    pub term_id: String,
    pub sort_name: String,
    pub probability: f64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TaggedFcResponse {
    #[serde(default)]
    pub tagged_facts: Vec<TaggedFactDto>,
    pub iterations: u32,
    pub fixpoint_reached: bool,
    pub derived_count: u64,
    pub elapsed_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MonadicFactDto {
    pub term_id: String,
    pub sort_name: String,
    pub derivation_depth: u32,
    pub confidence: f64,
    pub is_given: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MonadicFixpointResponse {
    #[serde(default)]
    pub facts: Vec<MonadicFactDto>,
    pub iterations: u32,
    pub fixpoint_reached: bool,
    pub given_count: u64,
    pub derived_count: u64,
    pub max_depth: u32,
    pub elapsed_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DerivedInferenceResultDto {
    pub match_score: f64,
    pub gate_value: f64,
    pub proceed: bool,
    pub combined_confidence: f64,
    #[serde(default)]
    pub sort_predictions: BTreeMap<String, f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchitectureInfoDto {
    pub parameters: u64,
    pub sort_count: u32,
    pub embedding_dim: u32,
    pub constraint_satisfied: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DerivedInferenceResponse {
    #[serde(default)]
    pub results: Vec<DerivedInferenceResultDto>,
    #[serde(default)]
    pub architecture: Option<ArchitectureInfoDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SafetyModelInfoDto {
    pub parameters: u64,
    pub embedding_dim: u32,
    pub categories: u32,
    pub questions: u32,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ClassifySafetyResponse {
    #[serde(default)]
    pub question_decisions: BTreeMap<String, bool>,
    #[serde(default)]
    pub question_probabilities: BTreeMap<String, f64>,
    #[serde(default)]
    pub category_activations: BTreeMap<String, f64>,
    #[serde(default)]
    pub model_info: Option<SafetyModelInfoDto>,
    pub elapsed_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CdlVerificationDto {
    pub constraint_satisfied: bool,
    pub max_violation: f64,
    pub sort_count: u32,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DynamicAddSortResponse {
    pub adaptation_time_us: u64,
    pub initialization: String,
    pub max_deviation: f64,
    pub predictions_preserved: bool,
    pub sort_id: String,
    pub sort_index: u32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verification: Option<CdlVerificationDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CdlComponentStatus {
    pub active: bool,
    pub parameters: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CdlStatusResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub derived_layer: Option<CdlComponentStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dynamic_architecture: Option<CdlComponentStatus>,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fact_grounding: Option<CdlComponentStatus>,
}