reasoninglayer 0.1.2

Rust client SDK for the Reasoning Layer API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! ILP (Inductive Logic Programming) DTOs.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ArithmeticRecursionOp {
    Multiplication,
    Addition,
    Accumulation,
    Subtraction,
    Power,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrainingExample {
    pub input: f64,
    pub output: f64,
}

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

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LearnPatternRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<LearnPatternConfigDto>,
    pub examples: Vec<TrainingExample>,
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LearnedPatternDto {
    #[serde(default)]
    pub base_case_inputs: Vec<f64>,
    pub confidence: f64,
    pub description: String,
    pub input_feature: String,
    pub operation: ArithmeticRecursionOp,
    pub output_feature: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LearnPatternResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    pub examples_used: u32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pattern: Option<LearnedPatternDto>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pattern_id: Option<String>,
    pub processing_time_ms: u64,
    pub success: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvaluatePatternRequest {
    pub inputs: Vec<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_depth: Option<u32>,
    pub pattern_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvaluationResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    pub input: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<f64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EvaluatePatternResponse {
    pub processing_time_ms: u64,
    #[serde(default)]
    pub results: Vec<EvaluationResult>,
    pub success: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GFlowNetSampleRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_body_size: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub num_trajectories: Option<u32>,
    pub target_sort: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SampledHypothesisDto {
    #[serde(default)]
    pub body_sorts: Vec<String>,
    pub from_joining: bool,
    pub log_probability: f64,
    pub trajectory_index: u32,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GFlowNetSampleResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default)]
    pub hypotheses: Vec<SampledHypothesisDto>,
    pub joined_count: u32,
    pub masked_count: u32,
    pub neural_guide_available: bool,
    pub processing_time_ms: u64,
    pub success: bool,
    pub total_sampled: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SynthesizeRequest {
    pub examples: Vec<TrainingExample>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_proposals: Option<u32>,
    pub target_sort: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub use_gflownet: Option<bool>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SynthesizeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub found_by: Option<String>,
    pub gflownet_hypotheses_sampled: u32,
    pub neural_guide_available: bool,
    pub processing_time_ms: u64,
    pub proposals_tried: u32,
    pub success: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PatternSummaryDto {
    #[serde(default)]
    pub base_case_inputs: Vec<f64>,
    pub confidence: f64,
    pub operation: ArithmeticRecursionOp,
    pub pattern_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListPatternsResponse {
    pub count: u64,
    #[serde(default)]
    pub patterns: Vec<PatternSummaryDto>,
}