input_text
stringlengths 27
843
| target_text
stringlengths 61
971
| metadata
stringlengths 169
248
|
|---|---|---|
How do I use the sorry tactic in Lean?
|
The sorry tactic is used to placeholder for incomplete proof.
Syntax: sorry
Example:
```lean
theorem example_theorem : P := by
sorry
```
|
{"source": "synthetic_variation", "base_source": "tactic_guide", "variation_id": 377, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740536", "example_id": 878, "dataset_version": "1000_comprehensive"}
|
How do I implement the Initialize method in IFundamentalDataProvider?
|
The Initialize method in IFundamentalDataProvider Initializes the service. Implementation:
```lean
def Initialize : IFundamentalDataProvider → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 350, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740420", "example_id": 851, "dataset_version": "1000_comprehensive"}
|
How do I use the IRealTimeHandler interface in Lean?
|
The IRealTimeHandler interface is used for Real time event handler, trigger functions at regular or pretimed intervals. Here's how to implement it:
```lean
class IRealTimeHandler where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IRealTimeHandler", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.737902", "example_id": 301, "dataset_version": "1000_comprehensive"}
|
Parse this strategic recommendation from the Brain (Grok) and provide specific Lean implementation steps:
BRAIN'S JSON RECOMMENDATION:
{
"strategic_analysis": "Low Sharpe ratio indicates poor risk-adjusted returns",
"optimization_strategy": "Implement dynamic position sizing with volatility adjustment",
"specific_actions": [
{
"action_type": "interface_modification",
"target_interface": "IPortfolioConstructionModel",
"method": "CreateTargets",
"parameters": {
"volatility_adjustment": false,
"position_scaling": 0.5026435215960127
},
"reasoning": "Reduce position sizes during high volatility periods"
}
],
"confidence": 0.9
}
TASK: For each action, provide the exact Lean interface calls, method names, and parameter settings needed.
|
IMPLEMENTATION STEPS:
STEP 1: interface_modification
INTERFACE: IPortfolioConstructionModel
METHOD: CreateTargets
REASONING: Reduce position sizes during high volatility periods
CODE IMPLEMENTATION:
```csharp
// Reduce position sizes during high volatility periods
var service = GetService<IPortfolioConstructionModel>();
service.CreateTargets(
volatility_adjustment: False,
position_scaling: 0.5026435215960127,
);
```
EXPECTED OUTCOME:
Low Sharpe ratio indicates poor risk-adjusted returns
CONFIDENCE: 90%
|
{"source": "json_parsing", "type": "brain_muscle_communication", "template_id": 0, "variation": 13, "timestamp": "2025-08-23T00:31:01.156860", "dataset_version": "enhanced_tool_calling"}
|
How do I implement the GetLeverage method in IBuyingPowerModel?
|
The GetLeverage method in IBuyingPowerModel Gets the current leverage of the security [Data Retrieval] Use this method to retrieve information from the system.. Implementation:
```lean
def GetLeverage : IBuyingPowerModel → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 217, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739825", "example_id": 718, "dataset_version": "1000_comprehensive"}
|
How do I implement the Read method in ISubscriptionDataSourceReader?
|
The Read method in ISubscriptionDataSourceReader Reads the specified <paramref name="source"/>. Implementation:
```lean
def Read : ISubscriptionDataSourceReader → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 497, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.741177", "example_id": 998, "dataset_version": "1000_comprehensive"}
|
How do I use the IPositionGroupBuyingPowerModel interface in Lean?
|
The IPositionGroupBuyingPowerModel interface is used for Represents a position group's model of buying power. Here's how to implement it:
```lean
class IPositionGroupBuyingPowerModel where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 153, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739549", "example_id": 654, "dataset_version": "1000_comprehensive"}
|
How do I use the ITestInvokeMethodModel interface in Lean?
|
The ITestInvokeMethodModel interface is used for Interface ITestInvokeMethodModel. Here's how to implement it:
```lean
class ITestInvokeMethodModel where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "ITestInvokeMethodModel", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.738026", "example_id": 329, "dataset_version": "1000_comprehensive"}
|
How do I implement the ApplyFunds method in ISettlementModel?
|
The ApplyFunds method in ISettlementModel Applies cash settlement rules. Implementation:
```lean
def ApplyFunds : ISettlementModel → Type := sorry
```
|
{"source": "method_spec", "interface": "ISettlementModel", "method": "ApplyFunds", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737802", "example_id": 279, "dataset_version": "1000_comprehensive"}
|
How do I implement the SeedSecurity method in ISecuritySeeder?
|
The SeedSecurity method in ISecuritySeeder Seed the security. Implementation:
```lean
def SeedSecurity : ISecuritySeeder → Type := sorry
```
|
{"source": "method_spec", "interface": "ISecuritySeeder", "method": "SeedSecurity", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737793", "example_id": 277, "dataset_version": "1000_comprehensive"}
|
How do I use the IBrokerageCashSynchronizer interface in Lean?
|
The IBrokerageCashSynchronizer interface is used for Defines live brokerage cash synchronization operations.. Here's how to implement it:
```lean
class IBrokerageCashSynchronizer where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 418, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740788", "example_id": 919, "dataset_version": "1000_comprehensive"}
|
How do I implement the NextInt method in IRandomValueGenerator?
|
The NextInt method in IRandomValueGenerator Returns a random integer that is within a specified range.. Implementation:
```lean
def NextInt : IRandomValueGenerator → Type := sorry
```
|
{"source": "method_spec", "interface": "IRandomValueGenerator", "method": "NextInt", "type": "implementation", "timestamp": "2025-08-22T20:14:36.738119", "example_id": 349, "dataset_version": "1000_comprehensive"}
|
Execute this tool call for Risk Management Setup:
INTERFACE: IRiskManagementModel
METHOD: ManageRisk
SCENARIO: Risk Management Setup
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Risk Management Setup - ManageRisk
var rskmanagementmodel = new RiskManagementModel();
// Method call
rskmanagementmodel.ManageRisk(
max_drawdown_percent: 0.1,
position_size_limit: 0.05,
volatility_threshold: 0.15
);
// Verification
if (rskmanagementmodel.IsConfigured)
{
Log($"Risk Management Setup configured successfully with ManageRisk");
}
```
PARAMETERS EXPLANATION:
- max_drawdown_percent: Maximum allowed portfolio drawdown
- position_size_limit: Maximum position size as percentage of portfolio
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IRiskManagementModel", "method": "ManageRisk", "scenario": "Risk Management Setup", "param_combo": 0, "timestamp": "2025-08-23T00:31:01.157338", "dataset_version": "enhanced_tool_calling"}
|
How do I implement the CanUpdateOrder method in IBrokerageModel?
|
The CanUpdateOrder method in IBrokerageModel Returns true if the brokerage would allow updating the order as specified by the request [Trading Action] Use this method to execute trading operations.. Implementation:
```lean
def CanUpdateOrder : IBrokerageModel → Type := sorry
```
|
{"source": "method_spec", "interface": "IBrokerageModel", "method": "CanUpdateOrder", "type": "implementation", "timestamp": "2025-08-22T20:14:36.736820", "example_id": 65, "dataset_version": "1000_comprehensive"}
|
Execute this tool call for Portfolio Construction:
INTERFACE: IPortfolioConstructionModel
METHOD: RebalancePortfolio
SCENARIO: Portfolio Construction
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Portfolio Construction - RebalancePortfolio
var portfoloconstructonmodel = new PortfolioConstructionModel();
// Method call
portfoloconstructonmodel.RebalancePortfolio(
);
// Verification
if (portfoloconstructonmodel.IsConfigured)
{
Log($"Portfolio Construction configured successfully with RebalancePortfolio");
}
```
PARAMETERS EXPLANATION:
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IPortfolioConstructionModel", "method": "RebalancePortfolio", "scenario": "Portfolio Construction", "param_combo": 0, "timestamp": "2025-08-23T00:31:01.157579", "dataset_version": "enhanced_tool_calling"}
|
Execute this tool call for Portfolio Construction:
INTERFACE: IPortfolioConstructionModel
METHOD: CreateTargets
SCENARIO: Portfolio Construction
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Portfolio Construction - CreateTargets
var portfoloconstructonmodel = new PortfolioConstructionModel();
// Method call
portfoloconstructonmodel.CreateTargets(
);
// Verification
if (portfoloconstructonmodel.IsConfigured)
{
Log($"Portfolio Construction configured successfully with CreateTargets");
}
```
PARAMETERS EXPLANATION:
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IPortfolioConstructionModel", "method": "CreateTargets", "scenario": "Portfolio Construction", "param_combo": 8, "timestamp": "2025-08-23T00:31:01.157571", "dataset_version": "enhanced_tool_calling"}
|
How do I implement the GetImpactedGroups method in IPositionGroupResolver?
|
The GetImpactedGroups method in IPositionGroupResolver Determines the position groups that would be evaluated for grouping of the specified
positions were passed into the <see cref="Resolve"/> method. [Data Retrieval] Use this method to retrieve information from the system.. Implementation:
```lean
def GetImpactedGroups : IPositionGroupResolver → Type := sorry
```
|
{"source": "method_spec", "interface": "IPositionGroupResolver", "method": "GetImpactedGroups", "type": "implementation", "timestamp": "2025-08-22T20:14:36.738396", "example_id": 410, "dataset_version": "1000_comprehensive"}
|
Prove that addition is associative in Lean
|
theorem associativity : (a + b) + c = a + (b + c) := by
-- Proof strategy
sorry
|
{"source": "synthetic_variation", "base_source": "theorem_pattern", "variation_id": 188, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739696", "example_id": 689, "dataset_version": "1000_comprehensive"}
|
How do I use the IOptionChainProvider interface in Lean?
|
The IOptionChainProvider interface is used for Provides the full option chain for a given underlying.. Here's how to implement it:
```lean
class IOptionChainProvider where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IOptionChainProvider", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.737326", "example_id": 177, "dataset_version": "1000_comprehensive"}
|
How do I implement the GetDictionary method in ITestInvokeMethodReturningDictionary?
|
The GetDictionary method in ITestInvokeMethodReturningDictionary Method GetDictionary [Data Retrieval] Use this method to retrieve information from the system.. Implementation:
```lean
def GetDictionary : ITestInvokeMethodReturningDictionary → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 33, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.738976", "example_id": 534, "dataset_version": "1000_comprehensive"}
|
How do I implement the GetBrokerageModel method in IBrokerageFactory?
|
The GetBrokerageModel method in IBrokerageFactory Gets a brokerage model that can be used to model this brokerage's unique behaviors [Data Retrieval] Use this method to retrieve information from the system.. Implementation:
```lean
def GetBrokerageModel : IBrokerageFactory → Type := sorry
```
|
{"source": "method_spec", "interface": "IBrokerageFactory", "method": "GetBrokerageModel", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737054", "example_id": 117, "dataset_version": "1000_comprehensive"}
|
How do I use the ITimeTriggeredUniverse interface in Lean?
|
The ITimeTriggeredUniverse interface is used for A universe implementing this interface will NOT use it's SubscriptionDataConfig to generate data that is used to 'pulse' the universe selection function -- instead, the times output by GetTriggerTimes are used to 'pulse' the universe selection function WITHOUT data.. Here's how to implement it:
```lean
class ITimeTriggeredUniverse where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "ITimeTriggeredUniverse", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.738221", "example_id": 372, "dataset_version": "1000_comprehensive"}
|
Parse this strategic recommendation from the Brain (Grok) and provide specific Lean implementation steps:
BRAIN'S JSON RECOMMENDATION:
{
"strategic_analysis": "Low Sharpe ratio indicates poor risk-adjusted returns",
"optimization_strategy": "Implement dynamic position sizing with volatility adjustment",
"specific_actions": [
{
"action_type": "interface_modification",
"target_interface": "IPortfolioConstructionModel",
"method": "CreateTargets",
"parameters": {
"volatility_adjustment": true,
"position_scaling": 0.3602130413037039
},
"reasoning": "Reduce position sizes during high volatility periods"
}
],
"confidence": 0.95
}
TASK: For each action, provide the exact Lean interface calls, method names, and parameter settings needed.
|
IMPLEMENTATION STEPS:
STEP 1: interface_modification
INTERFACE: IPortfolioConstructionModel
METHOD: CreateTargets
REASONING: Reduce position sizes during high volatility periods
CODE IMPLEMENTATION:
```csharp
// Reduce position sizes during high volatility periods
var service = GetService<IPortfolioConstructionModel>();
service.CreateTargets(
volatility_adjustment: True,
position_scaling: 0.3602130413037039,
);
```
EXPECTED OUTCOME:
Low Sharpe ratio indicates poor risk-adjusted returns
CONFIDENCE: 95%
|
{"source": "json_parsing", "type": "brain_muscle_communication", "template_id": 0, "variation": 4, "timestamp": "2025-08-23T00:31:01.156758", "dataset_version": "enhanced_tool_calling"}
|
How do I implement the GetOrdersByBrokerageId method in IOrderProvider?
|
The GetOrdersByBrokerageId method in IOrderProvider Gets the Lean orders by its brokerage id [Data Retrieval] Use this method to retrieve information from the system.. Implementation:
```lean
def GetOrdersByBrokerageId : IOrderProvider → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 127, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739439", "example_id": 628, "dataset_version": "1000_comprehensive"}
|
How do I use the IIndicator interface in Lean?
|
The IIndicator interface is used for Represents an indicator that can receive data updates and emit events when the value of the indicator has changed.. Here's how to implement it:
```lean
class IIndicator where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 320, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740258", "example_id": 821, "dataset_version": "1000_comprehensive"}
|
How do I implement the IsWithinLimit method in IIsolatorLimitResultProvider?
|
The IsWithinLimit method in IIsolatorLimitResultProvider Determines whether or not a custom isolator limit has be reached.. Implementation:
```lean
def IsWithinLimit : IIsolatorLimitResultProvider → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 168, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739612", "example_id": 669, "dataset_version": "1000_comprehensive"}
|
How do I use the IBrokerageModel interface in Lean?
|
The IBrokerageModel interface is used for Models brokerage transactions, fees, and order. Here's how to implement it:
```lean
class IBrokerageModel where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IBrokerageModel", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.736810", "example_id": 63, "dataset_version": "1000_comprehensive"}
|
How do I implement the Initialize method in IDataChannelProvider?
|
The Initialize method in IDataChannelProvider Initializes the class with an algorithm node packet. Implementation:
```lean
def Initialize : IDataChannelProvider → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 234, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739897", "example_id": 735, "dataset_version": "1000_comprehensive"}
|
Prove that equality is symmetric in Lean
|
theorem symmetry : a = b → b = a := by
-- Proof strategy
sorry
|
{"source": "synthetic_variation", "base_source": "theorem_pattern", "variation_id": 450, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740927", "example_id": 951, "dataset_version": "1000_comprehensive"}
|
Execute this tool call for Risk Management Setup:
INTERFACE: IRiskManagementModel
METHOD: UpdateRiskParameters
SCENARIO: Risk Management Setup
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Risk Management Setup - UpdateRiskParameters
var rskmanagementmodel = new RiskManagementModel();
// Method call
rskmanagementmodel.UpdateRiskParameters(
max_drawdown_percent: 0.2,
position_size_limit: 0.15,
volatility_threshold: 0.25
);
// Verification
if (rskmanagementmodel.IsConfigured)
{
Log($"Risk Management Setup configured successfully with UpdateRiskParameters");
}
```
PARAMETERS EXPLANATION:
- max_drawdown_percent: Maximum allowed portfolio drawdown
- position_size_limit: Maximum position size as percentage of portfolio
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IRiskManagementModel", "method": "UpdateRiskParameters", "scenario": "Risk Management Setup", "param_combo": 8, "timestamp": "2025-08-23T00:31:01.157518", "dataset_version": "enhanced_tool_calling"}
|
How do I implement the Open method in IStreamProvider?
|
The Open method in IStreamProvider Opens the specified source as read to be consumed stream. Implementation:
```lean
def Open : IStreamProvider → Type := sorry
```
|
{"source": "method_spec", "interface": "IStreamProvider", "method": "Open", "type": "implementation", "timestamp": "2025-08-22T20:14:36.736690", "example_id": 42, "dataset_version": "1000_comprehensive"}
|
How do I implement the Initialize method in IMapFileProvider?
|
The Initialize method in IMapFileProvider Initializes our MapFileProvider by supplying our dataProvider. Implementation:
```lean
def Initialize : IMapFileProvider → Type := sorry
```
|
{"source": "method_spec", "interface": "IMapFileProvider", "method": "Initialize", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737281", "example_id": 167, "dataset_version": "1000_comprehensive"}
|
How do I use the IModel interface in Lean?
|
The IModel interface is used for Interface IModel. Here's how to implement it:
```lean
class IModel where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 308, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740207", "example_id": 809, "dataset_version": "1000_comprehensive"}
|
Execute this tool call for Data Management:
INTERFACE: IDataProvider
METHOD: SetResolution
SCENARIO: Data Management
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Data Management - SetResolution
var dataprovder = new DataProvider();
// Method call
dataprovder.SetResolution(
);
// Verification
if (dataprovder.IsConfigured)
{
Log($"Data Management configured successfully with SetResolution");
}
```
PARAMETERS EXPLANATION:
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IDataProvider", "method": "SetResolution", "scenario": "Data Management", "param_combo": 0, "timestamp": "2025-08-23T00:31:01.157915", "dataset_version": "enhanced_tool_calling"}
|
How do I use the ISetupHandler interface in Lean?
|
The ISetupHandler interface is used for Interface to setup the algorithm. Pass in a raw algorithm, return one with portfolio, cash, etc already preset.. Here's how to implement it:
```lean
class ISetupHandler where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "ISetupHandler", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.737955", "example_id": 313, "dataset_version": "1000_comprehensive"}
|
How do I implement the Read method in ISubscriptionDataSourceReader?
|
The Read method in ISubscriptionDataSourceReader Reads the specified <paramref name="source"/>. Implementation:
```lean
def Read : ISubscriptionDataSourceReader → Type := sorry
```
|
{"source": "method_spec", "interface": "ISubscriptionDataSourceReader", "method": "Read", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737880", "example_id": 296, "dataset_version": "1000_comprehensive"}
|
How do I implement BinarySearch algorithm in Lean?
|
The BinarySearch algorithm is search in sorted array with logarithmic time complexity.
```lean
def binarysearch : List α → List α := sorry
theorem binarysearch_correct : ∀ xs, sorted (binarysearch xs) := sorry
```
|
{"source": "algorithm_spec", "algorithm": "BinarySearch", "type": "implementation", "timestamp": "2025-08-22T20:14:36.738774", "example_id": 490, "dataset_version": "1000_comprehensive"}
|
When should I use induction in a Lean proof?
|
Use induction when you need to proof by induction. It's particularly useful in these scenarios:
1. When you have the right form of hypothesis
2. When the goal matches the tactic's purpose
3. As part of a larger proof strategy
|
{"source": "synthetic_variation", "base_source": "tactic_strategy", "variation_id": 42, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739039", "example_id": 543, "dataset_version": "1000_comprehensive"}
|
How do I implement the Setup method in ISetupHandler?
|
The Setup method in ISetupHandler Primary entry point to setup a new algorithm [Configuration] Use this method to configure or update system settings.. Implementation:
```lean
def Setup : ISetupHandler → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 140, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739493", "example_id": 641, "dataset_version": "1000_comprehensive"}
|
How do I use the IDataFeedSubscriptionManager interface in Lean?
|
The IDataFeedSubscriptionManager interface is used for DataFeedSubscriptionManager interface will manage the subscriptions for the Data Feed. Here's how to implement it:
```lean
class IDataFeedSubscriptionManager where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IDataFeedSubscriptionManager", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.737851", "example_id": 290, "dataset_version": "1000_comprehensive"}
|
How do I implement the Unsubscribe method in IDataQueueHandler?
|
The Unsubscribe method in IDataQueueHandler Removes the specified configuration [Subscription] Use this method to subscribe to data or add components.. Implementation:
```lean
def Unsubscribe : IDataQueueHandler → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 116, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739392", "example_id": 617, "dataset_version": "1000_comprehensive"}
|
How do I implement the Reader method in IBaseData?
|
The Reader method in IBaseData Reader Method :: using set of arguements we specify read out type. Enumerate
until the end of the data stream or file. E.g. Read CSV file line by line and convert
into data types.. Implementation:
```lean
def Reader : IBaseData → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 278, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740082", "example_id": 779, "dataset_version": "1000_comprehensive"}
|
How do I use the IBrokerageMessageHandler interface in Lean?
|
The IBrokerageMessageHandler interface is used for Provides an plugin point to allow algorithms to directly handle the messages that come from their brokerage. Here's how to implement it:
```lean
class IBrokerageMessageHandler where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 409, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740748", "example_id": 910, "dataset_version": "1000_comprehensive"}
|
How do I implement the IsFillValid method in ITimeInForceHandler?
|
The IsFillValid method in ITimeInForceHandler Checks if an order fill is valid. Implementation:
```lean
def IsFillValid : ITimeInForceHandler → Type := sorry
```
|
{"source": "method_spec", "interface": "ITimeInForceHandler", "method": "IsFillValid", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737497", "example_id": 212, "dataset_version": "1000_comprehensive"}
|
How do I implement the HasOpenPosition method in ITradeBuilder?
|
The HasOpenPosition method in ITradeBuilder Returns true if there is an open position for the symbol. Implementation:
```lean
def HasOpenPosition : ITradeBuilder → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 478, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.741064", "example_id": 979, "dataset_version": "1000_comprehensive"}
|
How do I implement the Estimate method in IQLUnderlyingVolatilityEstimator?
|
The Estimate method in IQLUnderlyingVolatilityEstimator Returns current estimate of the underlying volatility. Implementation:
```lean
def Estimate : IQLUnderlyingVolatilityEstimator → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 54, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739091", "example_id": 555, "dataset_version": "1000_comprehensive"}
|
Execute this tool call for Algorithm Configuration:
INTERFACE: IAlgorithm
METHOD: AddSecurity
SCENARIO: Algorithm Configuration
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Algorithm Configuration - AddSecurity
var algorthm = new Algorithm();
// Method call
algorthm.AddSecurity(
learning_rate: 0.001,
lookback_period: 10
);
// Verification
if (algorthm.IsConfigured)
{
Log($"Algorithm Configuration configured successfully with AddSecurity");
}
```
PARAMETERS EXPLANATION:
- learning_rate: Model learning rate for optimization
- lookback_period: Historical data lookback period in days
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IAlgorithm", "method": "AddSecurity", "scenario": "Algorithm Configuration", "param_combo": 9, "timestamp": "2025-08-23T00:31:01.157771", "dataset_version": "enhanced_tool_calling"}
|
How do I use the IAlgorithm interface in Lean?
|
The IAlgorithm interface is used for Interface for QuantConnect algorithm implementations. All algorithms must implement these basic members to allow interaction with the Lean Backtesting Engine.. Here's how to implement it:
```lean
class IAlgorithm where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 171, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739624", "example_id": 672, "dataset_version": "1000_comprehensive"}
|
How do I use the ITransactionHandler interface in Lean?
|
The ITransactionHandler interface is used for Transaction handlers define how the transactions are processed and set the order fill information. The pass this information back to the algorithm portfolio and ensure the cash and portfolio are synchronized.. Here's how to implement it:
```lean
class ITransactionHandler where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "ITransactionHandler", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.737973", "example_id": 317, "dataset_version": "1000_comprehensive"}
|
Execute this tool call for Portfolio Construction:
INTERFACE: IPortfolioConstructionModel
METHOD: SetWeights
SCENARIO: Portfolio Construction
Provide the exact code implementation and parameter settings.
|
LEAN IMPLEMENTATION:
```csharp
// Portfolio Construction - SetWeights
var portfoloconstructonmodel = new PortfolioConstructionModel();
// Method call
portfoloconstructonmodel.SetWeights(
);
// Verification
if (portfoloconstructonmodel.IsConfigured)
{
Log($"Portfolio Construction configured successfully with SetWeights");
}
```
PARAMETERS EXPLANATION:
INTEGRATION NOTES:
- Add this to your algorithm's Initialize() method
- Ensure proper error handling for parameter validation
- Test with paper trading before live deployment
|
{"source": "tool_execution", "interface": "IPortfolioConstructionModel", "method": "SetWeights", "scenario": "Portfolio Construction", "param_combo": 4, "timestamp": "2025-08-23T00:31:01.157644", "dataset_version": "enhanced_tool_calling"}
|
How do I use the IOptionAssignmentModel interface in Lean?
|
The IOptionAssignmentModel interface is used for The option assignment model emulates exercising of short option positions in the portfolio.. Here's how to implement it:
```lean
class IOptionAssignmentModel where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 34, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739003", "example_id": 535, "dataset_version": "1000_comprehensive"}
|
Handle this error scenario in Lean:
ERROR: Data feed interruption
CONTEXT: Historical data request failed
REQUIRED: Implement error handling and recovery
Provide robust error handling code.
|
ERROR HANDLING IMPLEMENTATION:
```csharp
try
{
// Primary operation
// ... main logic here ...
}
catch (Exception ex) when (ex.Message.Contains("Data feed interruption"))
{
// Specific error handling for: Data feed interruption
Log($"Error: Historical data request failed - {ex.Message}");
// Recovery strategy: Use cached data and retry connection
// Use cached data as fallback
var cachedData = dataCache.GetLatestData();
if (cachedData != null)
{
ProcessData(cachedData);
Log("Using cached data while retrying connection");
ScheduleRetry();
}
// Continue with fallback approach
return HandleFallback();
}
catch (Exception ex)
{
// General error handling
Log($"Unexpected error: {ex.Message}");
throw;
}
```
RECOVERY STRATEGY:
Use cached data and retry connection
MONITORING:
- Log all errors for analysis
- Track recovery success rates
- Alert on repeated failures
|
{"source": "error_handling", "error_type": "Data feed interruption", "variation": 3, "timestamp": "2025-08-23T00:31:01.158280", "dataset_version": "enhanced_tool_calling"}
|
How do I use the IPortfolioTarget interface in Lean?
|
The IPortfolioTarget interface is used for Represents a portfolio target. This may be a percentage of total portfolio value or it may be a fixed number of shares.. Here's how to implement it:
```lean
class IPortfolioTarget where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IPortfolioTarget", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.738503", "example_id": 432, "dataset_version": "1000_comprehensive"}
|
How do I implement the Sleep method in ISleepStrategy?
|
The Sleep method in ISleepStrategy Sleeps the current thread in an implementation specific way
and for an implementation specific amount of time. Implementation:
```lean
def Sleep : ISleepStrategy → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 327, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740287", "example_id": 828, "dataset_version": "1000_comprehensive"}
|
How do I implement Dijkstra algorithm in Lean?
|
The Dijkstra algorithm is shortest path algorithm with weighted graphs.
```lean
def dijkstra : List α → List α := sorry
theorem dijkstra_correct : ∀ xs, sorted (dijkstra xs) := sorry
```
|
{"source": "synthetic_variation", "base_source": "algorithm_spec", "variation_id": 120, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739409", "example_id": 621, "dataset_version": "1000_comprehensive"}
|
Parse this strategic recommendation from the Brain (Grok) and provide specific Lean implementation steps:
BRAIN'S JSON RECOMMENDATION:
{
"strategic_analysis": "Low Sharpe ratio indicates poor risk-adjusted returns",
"optimization_strategy": "Implement dynamic position sizing with volatility adjustment",
"specific_actions": [
{
"action_type": "interface_modification",
"target_interface": "IPortfolioConstructionModel",
"method": "CreateTargets",
"parameters": {
"volatility_adjustment": true,
"position_scaling": 0.4514702222222224
},
"reasoning": "Reduce position sizes during high volatility periods"
}
],
"confidence": 0.85
}
TASK: For each action, provide the exact Lean interface calls, method names, and parameter settings needed.
|
IMPLEMENTATION STEPS:
STEP 1: interface_modification
INTERFACE: IPortfolioConstructionModel
METHOD: CreateTargets
REASONING: Reduce position sizes during high volatility periods
CODE IMPLEMENTATION:
```csharp
// Reduce position sizes during high volatility periods
var service = GetService<IPortfolioConstructionModel>();
service.CreateTargets(
volatility_adjustment: True,
position_scaling: 0.4514702222222224,
);
```
EXPECTED OUTCOME:
Low Sharpe ratio indicates poor risk-adjusted returns
CONFIDENCE: 85%
|
{"source": "json_parsing", "type": "brain_muscle_communication", "template_id": 0, "variation": 2, "timestamp": "2025-08-23T00:31:01.156734", "dataset_version": "enhanced_tool_calling"}
|
How do I implement the Initialize method in IDataFeed?
|
The Initialize method in IDataFeed Initializes the data feed for the specified job and algorithm. Implementation:
```lean
def Initialize : IDataFeed → Type := sorry
```
|
{"source": "method_spec", "interface": "IDataFeed", "method": "Initialize", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737837", "example_id": 287, "dataset_version": "1000_comprehensive"}
|
How do I prove zero is additive identity for Int in Lean?
|
theorem identity_int (a b c : Int) : a + 0 = a := by
-- Type-specific proof
sorry
|
{"source": "typed_theorem", "theorem_type": "identity", "data_type": "Int", "type": "typed_proof", "timestamp": "2025-08-22T20:14:36.738593", "example_id": 451, "dataset_version": "1000_comprehensive"}
|
Execute this optimization workflow step:
WORKFLOW: Low Sharpe Ratio Optimization Workflow
PROBLEM: Sharpe ratio of 0.4 needs improvement
CURRENT STEP: Validate with backtesting
ALL STEPS: Analyze current risk management settings, Implement dynamic position sizing, Add volatility-based adjustments, Update rebalancing frequency, Validate with backtesting
Provide the specific Lean implementation for the current step.
|
IMPLEMENTATION FOR: Validate with backtesting
// Implementation details for Validate with backtesting
|
{"source": "optimization_workflow", "workflow": "Low Sharpe Ratio Optimization Workflow", "step": 4, "total_steps": 5, "timestamp": "2025-08-23T00:31:01.158072", "dataset_version": "enhanced_tool_calling"}
|
How do I prove equality is transitive for Nat in Lean?
|
theorem transitivity_nat (a b c : Nat) : a = b → b = c → a = c := by
-- Type-specific proof
sorry
|
{"source": "synthetic_variation", "base_source": "typed_theorem", "variation_id": 27, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.738950", "example_id": 528, "dataset_version": "1000_comprehensive"}
|
How do I implement the StreamData method in ISynchronizer?
|
The StreamData method in ISynchronizer Returns an enumerable which provides the data to stream to the algorithm. Implementation:
```lean
def StreamData : ISynchronizer → Type := sorry
```
|
{"source": "method_spec", "interface": "ISynchronizer", "method": "StreamData", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737898", "example_id": 300, "dataset_version": "1000_comprehensive"}
|
How do I use the IDataDownloader interface in Lean?
|
The IDataDownloader interface is used for Data Downloader Interface for pulling data from a remote source.. Here's how to implement it:
```lean
class IDataDownloader where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 251, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739969", "example_id": 752, "dataset_version": "1000_comprehensive"}
|
How do I use the IOptionPositionCollectionEnumerator interface in Lean?
|
The IOptionPositionCollectionEnumerator interface is used for Enumerates an <see cref="OptionPositionCollection"/>. The intent is to evaluate positions that may be more important sooner. Positions appearing earlier in the enumeration are evaluated before positions showing later. This effectively prioritizes individual positions. This should not be used filter filtering, but it could also be used to split a position, for example a position with 10 could be changed to two 5s and they don't need to be enumerated back to-back either. In this way you could prioritize the first 5 and then delay matching of the final 5.. Here's how to implement it:
```lean
class IOptionPositionCollectionEnumerator where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 121, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739414", "example_id": 622, "dataset_version": "1000_comprehensive"}
|
How do I implement the ExitReadLock method in ILock?
|
The ExitReadLock method in ILock Method ExitReadLock. Implementation:
```lean
def ExitReadLock : ILock → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 494, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.741160", "example_id": 995, "dataset_version": "1000_comprehensive"}
|
How do I implement the Trace method in ILogHandler?
|
The Trace method in ILogHandler Write debug message to log. Implementation:
```lean
def Trace : ILogHandler → Type := sorry
```
|
{"source": "method_spec", "interface": "ILogHandler", "method": "Trace", "type": "implementation", "timestamp": "2025-08-22T20:14:36.736618", "example_id": 34, "dataset_version": "1000_comprehensive"}
|
How do I use the IDataFeed interface in Lean?
|
The IDataFeed interface is used for Datafeed interface for creating custom datafeed sources.. Here's how to implement it:
```lean
class IDataFeed where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IDataFeed", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.737833", "example_id": 286, "dataset_version": "1000_comprehensive"}
|
How do I implement the CreateAlgorithmInstance method in ISetupHandler?
|
The CreateAlgorithmInstance method in ISetupHandler Create a new instance of an algorithm from a physical dll path.. Implementation:
```lean
def CreateAlgorithmInstance : ISetupHandler → Type := sorry
```
|
{"source": "method_spec", "interface": "ISetupHandler", "method": "CreateAlgorithmInstance", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737960", "example_id": 314, "dataset_version": "1000_comprehensive"}
|
How do I use the ITestInvokeMethodReturningIterable interface in Lean?
|
The ITestInvokeMethodReturningIterable interface is used for Interface ITestInvokeMethodReturningIterable. Here's how to implement it:
```lean
class ITestInvokeMethodReturningIterable where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "ITestInvokeMethodReturningIterable", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.738044", "example_id": 333, "dataset_version": "1000_comprehensive"}
|
How do I implement the Clone method in IOrderProperties?
|
The Clone method in IOrderProperties Returns a new instance clone of this object. Implementation:
```lean
def Clone : IOrderProperties → Type := sorry
```
|
{"source": "method_spec", "interface": "IOrderProperties", "method": "Clone", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737355", "example_id": 182, "dataset_version": "1000_comprehensive"}
|
How do I use the IPortfolioConstructionModel interface in Lean?
|
The IPortfolioConstructionModel interface is used for Algorithm framework model that. Here's how to implement it:
```lean
class IPortfolioConstructionModel where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IPortfolioConstructionModel", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.736723", "example_id": 49, "dataset_version": "1000_comprehensive"}
|
How do I use the IAlgorithmSettings interface in Lean?
|
The IAlgorithmSettings interface is used for User settings for the algorithm which can be changed in the <see cref="IAlgorithm.Initialize"/> method. Here's how to implement it:
```lean
class IAlgorithmSettings where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IAlgorithmSettings", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.736987", "example_id": 102, "dataset_version": "1000_comprehensive"}
|
How do I use the IVolatilityModel interface in Lean?
|
The IVolatilityModel interface is used for Represents a model that computes the volatility of a security <remarks>Please use<see cref="BaseVolatilityModel"/> as the base class for any implementations of<see cref="IVolatilityModel"/></remarks>. Here's how to implement it:
```lean
class IVolatilityModel where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 186, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739687", "example_id": 687, "dataset_version": "1000_comprehensive"}
|
How do I use the IStreamProvider interface in Lean?
|
The IStreamProvider interface is used for Defines how to open/close a source file. Here's how to implement it:
```lean
class IStreamProvider where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IStreamProvider", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.736686", "example_id": 41, "dataset_version": "1000_comprehensive"}
|
How do I implement the GetSecurity method in ISecurityProvider?
|
The GetSecurity method in ISecurityProvider Retrieves a summary of the holdings for the specified symbol [Data Retrieval] Use this method to retrieve information from the system.. Implementation:
```lean
def GetSecurity : ISecurityProvider → Type := sorry
```
|
{"source": "method_spec", "interface": "ISecurityProvider", "method": "GetSecurity", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737785", "example_id": 275, "dataset_version": "1000_comprehensive"}
|
How do I use the ITradableDateEventProvider interface in Lean?
|
The ITradableDateEventProvider interface is used for Interface for event providers for new tradable dates. Here's how to implement it:
```lean
class ITradableDateEventProvider where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 174, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739637", "example_id": 675, "dataset_version": "1000_comprehensive"}
|
Execute this optimization workflow step:
WORKFLOW: High Drawdown Control Workflow
PROBLEM: Drawdown exceeds 25% limit
CURRENT STEP: Monitor real-time risk metrics
ALL STEPS: Implement emergency stop losses, Reduce position sizes, Add correlation-based risk controls, Update maximum drawdown limits, Monitor real-time risk metrics
Provide the specific Lean implementation for the current step.
|
IMPLEMENTATION FOR: Monitor real-time risk metrics
// Implementation details for Monitor real-time risk metrics
|
{"source": "optimization_workflow", "workflow": "High Drawdown Control Workflow", "step": 4, "total_steps": 5, "timestamp": "2025-08-23T00:31:01.158094", "dataset_version": "enhanced_tool_calling"}
|
How do I use the IFactorProvider interface in Lean?
|
The IFactorProvider interface is used for Providers price scaling factors for a permanent tick. Here's how to implement it:
```lean
class IFactorProvider where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 248, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739957", "example_id": 749, "dataset_version": "1000_comprehensive"}
|
How do I use the ISecurityPortfolioModel interface in Lean?
|
The ISecurityPortfolioModel interface is used for Performs order fill application to portfolio. Here's how to implement it:
```lean
class ISecurityPortfolioModel where
-- Interface methods
```
|
{"source": "synthetic_variation", "base_source": "interface_spec", "variation_id": 407, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.740739", "example_id": 908, "dataset_version": "1000_comprehensive"}
|
How do I use the IOptionStrategyLegPredicateReferenceValue interface in Lean?
|
The IOptionStrategyLegPredicateReferenceValue interface is used for When decoding leg predicates, we extract the value we're comparing against If we're comparing against another leg's value (such as legs[0].Strike), then we'll create a OptionStrategyLegPredicateReferenceValue. If we're comparing against a literal/constant value, then we'll create a ConstantOptionStrategyLegPredicateReferenceValue. These reference values are used to slice the <see cref="OptionPositionCollection"/> to only include positions matching the predicate.. Here's how to implement it:
```lean
class IOptionStrategyLegPredicateReferenceValue where
-- Interface methods
```
|
{"source": "interface_spec", "interface": "IOptionStrategyLegPredicateReferenceValue", "type": "usage_guide", "timestamp": "2025-08-22T20:14:36.738526", "example_id": 437, "dataset_version": "1000_comprehensive"}
|
How do I implement DFS algorithm in Lean?
|
The DFS algorithm is depth-first search with graph traversal.
```lean
def dfs : List α → List α := sorry
theorem dfs_correct : ∀ xs, sorted (dfs xs) := sorry
```
|
{"source": "algorithm_spec", "algorithm": "DFS", "type": "implementation", "timestamp": "2025-08-22T20:14:36.738778", "example_id": 491, "dataset_version": "1000_comprehensive"}
|
How do I implement the Subscribe method in IDataQueueHandler?
|
The Subscribe method in IDataQueueHandler Subscribe to the specified configuration [Subscription] Use this method to subscribe to data or add components.. Implementation:
```lean
def Subscribe : IDataQueueHandler → Type := sorry
```
|
{"source": "method_spec", "interface": "IDataQueueHandler", "method": "Subscribe", "type": "implementation", "timestamp": "2025-08-22T20:14:36.737163", "example_id": 141, "dataset_version": "1000_comprehensive"}
|
How do I implement the OnWarmupFinished method in IAlgorithm?
|
The OnWarmupFinished method in IAlgorithm Called when the algorithm has completed initialization and warm up.. Implementation:
```lean
def OnWarmupFinished : IAlgorithm → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 205, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.739775", "example_id": 706, "dataset_version": "1000_comprehensive"}
|
How do I implement the Remove method in IEventSchedule?
|
The Remove method in IEventSchedule Removes the specified event from the schedule. Implementation:
```lean
def Remove : IEventSchedule → Type := sorry
```
|
{"source": "synthetic_variation", "base_source": "method_spec", "variation_id": 472, "type": "synthetic", "timestamp": "2025-08-22T20:14:36.741021", "example_id": 973, "dataset_version": "1000_comprehensive"}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.