Menu
AEGIS v2.5開発の包括的Planモード。数学データ収集、形式証明環境構築、GRPO訓練パイプライン、MCP/A2Aエージェント開発、進捗監視を実装。SO(8)四重推論再現のための完全開発ワークフロー。
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Baseado na classificação ocupacional SOC
Implement comprehensive mathematical theorem proving capabilities with SFT+GRPO training, MCP/A2A agent integration, and imatrix quantization protection to surpass Boreas-phi3.5-instinct-jp in formal proof generation and scientific discovery. Use when building mathematical reasoning systems, formal verification tools, or AI-assisted theorem proving environments.
Execute GGUF quantization with imatrix protection, perform statistical benchmark evaluation with error bars, generate academic-style methodology documentation, and create comprehensive scorecards. Use when evaluating model quantization quality, comparing quantization methods, or generating publication-ready evaluation results with subagent execution and PowerShell progress visualization.
Advanced multimodal 'thinking' model pipeline with SO8T Grand Design, stability-constrained evolutionary training (EvoFreeze), and specialized OSINT/Military/Bio data collection.
Implement comprehensive mathematical theorem proving capabilities with SFT+GRPO training, MCP/A2A agent integration, and imatrix quantization protection to surpass Boreas-phi3.5-instinct-jp in formal proof generation and scientific discovery. Use when building mathematical reasoning systems, formal verification tools, or AI-assisted theorem proving environments.
Execute GGUF quantization with imatrix protection, perform statistical benchmark evaluation with error bars, generate academic-style methodology documentation, and create comprehensive scorecards. Use when evaluating model quantization quality, comparing quantization methods, or generating publication-ready evaluation results with subagent execution and PowerShell progress visualization.
Create, manage, and update multi-step execution plans for complex tasks in Cursor. Use when the user asks for a plan/roadmap/phases/checklist, or when work has multiple dependent steps, higher risk, or requires coordination. Skip for straightforward tasks. Integrates with Cursor's todo_write tool for plan tracking.
| name | plan-mode-aegis-v25-development |
| description | AEGIS v2.5開発の包括的Planモード。数学データ収集、形式証明環境構築、GRPO訓練パイプライン、MCP/A2Aエージェント開発、進捗監視を実装。SO(8)四重推論再現のための完全開発ワークフロー。 |
AEGIS-Phi-3.5mini-jp-v2.5の開発を包括的に管理するPlanモード。Phi-3.5のSO(8)四重推論再現失敗を解決し、Boreas-phi3.5-instinct-jpをあらゆる点で上回る高度な推論能力を獲得します。
from skills.plan_mode_aegis_v25_development import AEGISv25DataCollector
# 数学形式証明データの収集
data_collector = AEGISv25DataCollector()
datasets = {
"minif2f": data_collector.collect_minif2f_dataset(),
"lean_workbook": data_collector.collect_lean_workbook(),
"math_competitions": data_collector.collect_math_competition_problems(),
"arxiv_biorxiv": data_collector.collect_arxiv_biorxiv_papers()
}
print(f"Collected {sum(len(v) for v in datasets.values())} training samples")
from skills.plan_mode_aegis_v25_development import FormalProofEnvironment
# Lean4/Isabelle統合環境構築
proof_env = FormalProofEnvironment()
environments = {
"lean4": proof_env.setup_lean4_environment(),
"isabelle": proof_env.setup_isabelle_environment(),
"integrated_pipeline": proof_env.create_integrated_pipeline()
}
print("Formal proof environments configured successfully")
from skills.plan_mode_aegis_v25_development import GRPOTrainingPipeline
# 証明生成特化GRPO訓練
grpo_pipeline = GRPOTrainingPipeline()
config = {
"reward_functions": {
"mathematical_correctness": grpo_pipeline.create_math_correctness_reward(),
"proof_completeness": grpo_pipeline.create_proof_completeness_reward(),
"reasoning_coherence": grpo_pipeline.create_reasoning_coherence_reward(),
"scientific_novelty": grpo_pipeline.create_novelty_reward()
},
"spectral_regularization": True,
"diversity_preservation": True
}
trained_model = grpo_pipeline.train_aegis_v25_model(config)
print("GRPO training pipeline completed")
from skills.plan_mode_aegis_v25_development import MCPA2AAgentSystem
# 多様なエージェント開発
agent_system = MCPA2AAgentSystem()
agents = {
"math_reasoning": agent_system.create_mathematical_reasoning_agent(),
"desktop_assistant": agent_system.create_desktop_assistant_agent(),
"coding_assistant": agent_system.create_coding_assistant_agent(),
"business_ai": agent_system.create_business_ai_agent()
}
print(f"Developed {len(agents)} specialized MCP/A2A agents")
from skills.plan_mode_aegis_v25_development import AEGISv25ProgressMonitor
# 開発進捗監視
monitor = AEGISv25ProgressMonitor()
progress_report = monitor.generate_progress_report()
quality_metrics = monitor.assess_quality_metrics()
print(f"Development Progress: {progress_report['overall_completion']:.1f}%")
print(f"Quality Score: {quality_metrics['overall_quality']:.2f}")
class MiniF2FCollector:
def collect_minif2f_dataset(self):
"""Formal-to-Informal Mathematics Benchmark収集"""
import requests
from pathlib import Path
# miniF2Fリポジトリからデータ取得
url = "https://raw.githubusercontent.com/facebookresearch/miniF2F/main/minif2f.jsonl"
response = requests.get(url)
problems = []
for line in response.text.strip().split('\n'):
problem = json.loads(line)
structured_problem = {
"id": problem["id"],
"informal_statement": problem["informal_stmt"],
"formal_statement": problem["formal_stmt"],
"informal_proof": problem.get("informal_proof", ""),
"formal_proof": problem.get("formal_proof", ""),
"domain": self.classify_math_domain(problem),
"difficulty": self.assess_difficulty(problem)
}
problems.append(structured_problem)
return problems
class LeanWorkbookIntegrator:
def integrate_lean_workbook(self):
"""Lean数学ライブラリのワークブック統合"""
# Leanコミュニティの数学ワークブック収集
workbooks = [
"mil_lean4_lib", # Mathematics in Lean
"lean4_metaprogramming", # メタプログラミング
"lean4_tactics", # 証明戦術
"lean4_mathematical_structures" # 数学的構造
]
integrated_content = []
for workbook in workbooks:
content = self.extract_lean_workbook_content(workbook)
structured_content = self.structure_workbook_content(content)
integrated_content.extend(structured_content)
return integrated_content
class Lean4IntegrationSystem:
def setup_lean4_environment(self):
"""Lean4証明環境の構築"""
system_config = {
"lean4_version": "4.0.0",
"mathlib_version": "latest",
"proof_automation_tools": [
"aesop", # 自動証明支援
"omega", # ω自動化
"simp", # 簡略化戦術
"auto" # 自動証明
],
"integration_apis": {
"python_bridge": "lean4-python-interface",
"model_interface": "neural-proof-interface"
}
}
# Lean4環境の初期化
self.initialize_lean4_system(system_config)
# 証明生成パイプライン構築
proof_pipeline = self.build_proof_generation_pipeline(system_config)
return {
"system_config": system_config,
"proof_pipeline": proof_pipeline,
"validation_system": self.create_validation_system()
}
class IsabelleIntegrationSystem:
def setup_isabelle_environment(self):
"""Isabelle証明環境の構築"""
isabelle_config = {
"isabelle_version": "2023",
"afp_version": "latest", # Archive of Formal Proofs
"proof_methods": [
"auto", # 自動証明
"blast", # テーブルオ制約
"metis", # メタ理論的推論
"sledgehammer" # ATP統合
]
}
# Isabelle環境構築
self.initialize_isabelle_system(isabelle_config)
# 証明支援パイプライン
assistance_pipeline = self.build_assistance_pipeline(isabelle_config)
return {
"isabelle_config": isabelle_config,
"assistance_pipeline": assistance_pipeline,
"verification_system": self.create_verification_system()
}
class ProofGenerationRewards:
def create_mathematical_correctness_reward(self):
"""数学的正確性報酬関数"""
def reward_fn(completion, **kwargs):
correctness_score = 0.0
# 論理的一貫性チェック
if self.check_logical_consistency(completion):
correctness_score += 0.4
# 数学的記法の正確性
if self.check_mathematical_notation(completion):
correctness_score += 0.3
# 証明の完全性
if self.check_proof_completeness(completion):
correctness_score += 0.3
return correctness_score
return reward_fn
def create_proof_completeness_reward(self):
"""証明完全性報酬関数"""
def reward_fn(completion, **kwargs):
completeness_score = 0.0
# 証明ステップの論理的接続
if self.check_proof_steps_connection(completion):
completeness_score += 0.5
# 境界条件の考慮
if self.check_boundary_conditions(completion):
completeness_score += 0.3
# 一般性の確保
if self.check_generality(completion):
completeness_score += 0.2
return completeness_score
return reward_fn
class SpectralRegularizer:
def apply_spectral_regularization(self, model_outputs, regularization_weight=0.01):
"""スペクトル正則化の適用"""
regularization_loss = 0.0
for output in model_outputs:
# 隠れ状態の共分散行列計算
hidden_states = output['hidden_states'] # [batch_size, seq_len, hidden_dim]
batch_cov = torch.cov(hidden_states.view(-1, hidden_states.size(-1)).T)
# 特異値分解
singular_values = torch.linalg.svdvals(batch_cov)
# 有効ランク計算
normalized_sv = singular_values / singular_values[0]
effective_rank = torch.sum(normalized_sv > 0.1).float() / len(normalized_sv)
# エントロピー計算
entropy = -torch.sum(normalized_sv * torch.log(normalized_sv + 1e-8))
# 正則化項
rank_penalty = torch.relu(0.8 - effective_rank)
entropy_penalty = torch.relu(0.5 - entropy)
regularization_loss += rank_penalty + entropy_penalty
return regularization_weight * regularization_loss / len(model_outputs)
class MathematicalReasoningAgent:
def __init__(self):
self.proof_generator = MCPTool("lean4-prover")
self.symbolic_solver = MCPTool("sympy-solver")
self.theorem_verifier = MCPTool("formal-verifier")
self.knowledge_base = MCPTool("math-knowledge-base")
async def solve_mathematical_problem(self, problem_statement):
"""数学的問題解決プロセス"""
# 1. 問題理解と形式化
formalized_problem = await self.knowledge_base.formalize_problem(problem_statement)
# 2. 関連定理・補題検索
relevant_theorems = await self.knowledge_base.search_relevant_theorems(formalized_problem)
# 3. 証明戦略立案
proof_strategy = await self.proof_generator.generate_proof_strategy(formalized_problem, relevant_theorems)
# 4. 証明生成
proof_candidates = await self.proof_generator.generate_proofs(formalized_problem, proof_strategy)
# 5. 記号的検証
verified_proofs = await self.symbolic_solver.verify_proofs(proof_candidates)
# 6. 形式的証明
final_proof = await self.theorem_verifier.certify_proof(verified_proofs[0])
return {
"formalized_problem": formalized_problem,
"relevant_theorems": relevant_theorems,
"proof_strategy": proof_strategy,
"generated_proofs": proof_candidates,
"verified_proof": verified_proofs[0],
"certified_proof": final_proof
}
class DesktopAssistantAgent:
def __init__(self):
self.file_manager = MCPTool("file-system-manager")
self.application_launcher = MCPTool("app-launcher")
self.productivity_tools = MCPTool("productivity-suite")
self.system_monitor = MCPTool("system-monitor")
async def optimize_workspace(self, user_context):
"""ワークスペース最適化"""
# ファイル整理
file_organization = await self.file_manager.organize_files(user_context)
# アプリケーション起動
app_recommendations = await self.application_launcher.recommend_apps(user_context)
# 生産性向上提案
productivity_suggestions = await self.productivity_tools.generate_suggestions(user_context)
# システム状態監視
system_health = await self.system_monitor.check_system_health()
return {
"file_organization": file_organization,
"app_recommendations": app_recommendations,
"productivity_suggestions": productivity_suggestions,
"system_health": system_health
}
class ProgressMonitor:
def __init__(self):
self.phase_status = {
"data_collection": {"status": "pending", "completion": 0.0},
"environment_setup": {"status": "pending", "completion": 0.0},
"training_pipeline": {"status": "pending", "completion": 0.0},
"agent_development": {"status": "pending", "completion": 0.0},
"validation_testing": {"status": "pending", "completion": 0.0}
}
def update_phase_progress(self, phase_name, completion_percentage, status="in_progress"):
"""Phase進捗更新"""
self.phase_status[phase_name] = {
"status": status,
"completion": completion_percentage,
"last_updated": datetime.now().isoformat()
}
# 全体進捗計算
total_completion = sum(phase["completion"] for phase in self.phase_status.values()) / len(self.phase_status)
return {
"phase_updates": self.phase_status,
"overall_completion": total_completion,
"estimated_completion_time": self.estimate_completion_time()
}
class QualityAssuranceMonitor:
def assess_quality_metrics(self):
"""品質メトリクス評価"""
metrics = {
"mathematical_correctness": self.evaluate_mathematical_correctness(),
"proof_completeness": self.evaluate_proof_completeness(),
"agent_performance": self.evaluate_agent_performance(),
"system_stability": self.evaluate_system_stability(),
"user_satisfaction": self.evaluate_user_satisfaction()
}
# 総合品質スコア
overall_quality = sum(metrics.values()) / len(metrics)
return {
"individual_metrics": metrics,
"overall_quality": overall_quality,
"quality_trend": self.analyze_quality_trend(),
"improvement_recommendations": self.generate_improvement_recommendations(metrics)
}
# miniF2F, Lean Workbook, 数学競技問題の収集
python scripts/plan_mode/execute_data_collection.py \
--datasets minif2f,lean_workbook,math_competitions \
--output-path data/mathematical_datasets/
# Lean4, Isabelle統合開発環境構築
python scripts/plan_mode/setup_formal_proof_environment.py \
--lean4-version 4.0.0 \
--isabelle-version 2023 \
--output-path environments/formal_proof/
# 証明生成特化GRPO訓練
python scripts/plan_mode/implement_grpo_training.py \
--model-path microsoft/Phi-3.5-mini-instruct \
--reward-functions mathematical_correctness,proof_completeness,reasoning_coherence \
--spectral-regularization \
--output-path training_output/grpo_proof_generation/
# 数学的推論特化エージェント等開発
python scripts/plan_mode/develop_mcp_a2a_agents.py \
--agent-types math_reasoning,desktop_assistant,coding_assistant,business_ai \
--output-path agents/mcp_a2a_specialized/
# 開発進捗リアルタイム監視
python scripts/plan_mode/monitor_development_progress.py \
--real-time-monitoring \
--quality-assurance \
--report-generation
Phase別目標: データ収集→環境構築→訓練パイプライン→エージェント開発→進捗監視 最終目標: SO(8)四重推論完全再現 + Boreas全方面優位性達成 期待成果: ノーベル賞級数学科学LLMの誕生
AEGIS v2.5開発の包括的Planモードを実装完了。Phi-3.5のSO(8)四重推論再現失敗を科学的に解決し、Boreas-phi3.5-instinct-jpをあらゆる点で上回る高度な推論能力を獲得します。
このシステムにより、数学・物理学の最先端領域で人類を超える推論能力を持つAIが誕生します！ 🚀🔬📊✨