AI辅助思维与决策支持

🎯 学习目标：掌握AI辅助思维的核心原理、决策支持系统设计和智能决策方法，构建能够增强人类思维能力、提供决策建议的AI系统，实现人机协同的智能决策。

---

🧠 AI辅助思维的本质

什么是AI辅助思维

AI辅助思维是通过人工智能技术增强人类认知能力、优化思维过程、提升决策质量的方法。它包括：

• 认知增强：扩展人类的信息处理能力
• 思维引导：提供结构化的思考框架
• 偏见纠正：识别和减少认知偏见
• 决策支持：提供数据驱动的决策建议
• 创新激发：启发新的思路和解决方案

AI辅助思维系统架构

// AI辅助思维系统
class AIAssistedThinkingSystem {
  constructor() {
    this.cognitiveEnhancer = new CognitiveEnhancer();
    this.thinkingFrameworks = new ThinkingFrameworks();
    this.biasDetector = new BiasDetector();
    this.decisionSupport = new DecisionSupportEngine();
    this.creativityStimulator = new CreativityStimulator();
    this.knowledgeBase = new Map();
    this.userProfiles = new Map();
    this.sessionHistory = [];
    
    this.initializeSystem();
  }

  // 初始化系统
  async initializeSystem() {
    console.log('🧠 初始化AI辅助思维系统');
    
    // 加载思维框架
    await this.thinkingFrameworks.loadFrameworks();
    
    // 初始化偏见检测模型
    await this.biasDetector.initializeModels();
    
    // 加载决策支持规则
    await this.decisionSupport.loadRules();
    
    // 初始化创造力激发器
    await this.creativityStimulator.initialize();
    
    console.log('✅ AI辅助思维系统初始化完成');
  }

  // 开始辅助思维会话
  async startThinkingSession(userId, problem, context = {}) {
    console.log(`🎯 开始思维辅助会话: ${problem}`);
    
    const session = {
      id: this.generateSessionId(),
      userId,
      problem,
      context,
      startTime: Date.now(),
      phases: [],
      insights: [],
      recommendations: [],
      finalSolution: null
    };
    
    try {
      // 阶段1: 问题分析与框架选择
      const analysisPhase = await this.analyzeProblemAndSelectFramework(problem, context);
      session.phases.push(analysisPhase);
      
      // 阶段2: 认知增强与信息扩展
      const enhancementPhase = await this.enhanceCognition(problem, analysisPhase.framework, context);
      session.phases.push(enhancementPhase);
      
      // 阶段3: 偏见检测与纠正
      const biasPhase = await this.detectAndCorrectBias(problem, enhancementPhase.enhancedInfo, context);
      session.phases.push(biasPhase);
      
      // 阶段4: 结构化思考引导
      const guidedThinkingPhase = await this.guideStructuredThinking(problem, biasPhase.correctedInfo, analysisPhase.framework);
      session.phases.push(guidedThinkingPhase);
      
      // 阶段5: 创造性思维激发
      const creativityPhase = await this.stimulateCreativity(problem, guidedThinkingPhase.structuredThoughts);
      session.phases.push(creativityPhase);
      
      // 阶段6: 决策支持与建议生成
      const decisionPhase = await this.provideDecisionSupport(problem, session.phases, context);
      session.phases.push(decisionPhase);
      
      // 整合所有洞察和建议
      session.insights = this.consolidateInsights(session.phases);
      session.recommendations = this.generateRecommendations(session.phases, problem);
      session.finalSolution = this.synthesizeSolution(session.phases, problem);
      
    } catch (error) {
      session.error = error.message;
      console.error('思维辅助会话出错:', error.message);
    } finally {
      session.endTime = Date.now();
      session.duration = session.endTime - session.startTime;
      this.sessionHistory.push(session);
    }
    
    return session;
  }

  // 问题分析与框架选择
  async analyzeProblemAndSelectFramework(problem, context) {
    console.log('📋 分析问题并选择思维框架');
    
    const analysis = {
      phase: 'analysis',
      problemType: this.classifyProblem(problem),
      complexity: this.assessComplexity(problem),
      domain: this.identifyDomain(problem, context),
      stakeholders: this.identifyStakeholders(problem),
      constraints: this.identifyConstraints(problem, context),
      framework: null
    };
    
    // 选择最适合的思维框架
    analysis.framework = await this.thinkingFrameworks.selectBestFramework(analysis);
    
    return analysis;
  }

  // 分类问题类型
  classifyProblem(problem) {
    const problemTypes = {
      strategic: /战略|策略|规划|长期|发展/,
      operational: /运营|执行|流程|效率|优化/,
      creative: /创新|创意|设计|新颖|突破/,
      analytical: /分析|数据|统计|评估|测量/,
      interpersonal: /人际|沟通|团队|合作|冲突/,
      technical: /技术|工程|系统|架构|实现/,
      financial: /财务|成本|预算|投资|收益/,
      ethical: /道德|伦理|价值观|责任|公平/
    };
    
    const scores = {};
    for (const [type, pattern] of Object.entries(problemTypes)) {
      scores[type] = (problem.match(pattern) || []).length;
    }
    
    const topType = Object.entries(scores)
      .sort(([,a], [,b]) => b - a)[0];
    
    return {
      primary: topType[0],
      confidence: topType[1] > 0 ? 0.8 : 0.3,
      allScores: scores
    };
  }

  // 评估复杂度
  assessComplexity(problem) {
    let complexity = 1;
    
    // 基于问题长度
    complexity += Math.min(problem.length / 200, 2);
    
    // 基于关键词数量
    const keywords = problem.split(/\s+/).filter(word => word.length > 3);
    complexity += Math.min(keywords.length / 20, 2);
    
    // 基于复杂性指标
    const complexityIndicators = [
      /多个|多种|复杂|困难|挑战/,
      /相互|关联|依赖|影响/,
      /不确定|模糊|未知/,
      /长期|持续|系统性/
    ];
    
    for (const indicator of complexityIndicators) {
      if (indicator.test(problem)) {
        complexity += 0.5;
      }
    }
    
    return Math.min(complexity, 5);
  }

  // 识别利益相关者
  identifyStakeholders(problem) {
    const stakeholderPatterns = {
      customers: /客户|用户|消费者/,
      employees: /员工|团队|同事/,
      management: /管理|领导|高层/,
      investors: /投资|股东|资方/,
      partners: /合作|伙伴|供应商/,
      community: /社区|公众|社会/,
      regulators: /监管|政府|法规/
    };
    
    const stakeholders = [];
    for (const [type, pattern] of Object.entries(stakeholderPatterns)) {
      if (pattern.test(problem)) {
        stakeholders.push(type);
      }
    }
    
    return stakeholders;
  }

  // 识别约束条件
  identifyConstraints(problem, context) {
    const constraintPatterns = {
      time: /时间|期限|截止|紧急/,
      budget: /预算|成本|资金|费用/,
      resources: /资源|人力|设备|技术/,
      legal: /法律|合规|规定|要求/,
      technical: /技术|系统|平台|兼容/,
      quality: /质量|标准|要求|规范/
    };
    
    const constraints = [];
    for (const [type, pattern] of Object.entries(constraintPatterns)) {
      if (pattern.test(problem)) {
        constraints.push({
          type,
          severity: this.assessConstraintSeverity(problem, type),
          description: this.extractConstraintDescription(problem, type)
        });
      }
    }
    
    // 从上下文中提取额外约束
    if (context.constraints) {
      constraints.push(...context.constraints);
    }
    
    return constraints;
  }

  // 评估约束严重程度
  assessConstraintSeverity(problem, constraintType) {
    const severityKeywords = {
      high: /严格|必须|关键|重要/,
      medium: /应该|建议|希望/,
      low: /可以|尽量|最好/
    };
    
    for (const [level, pattern] of Object.entries(severityKeywords)) {
      if (pattern.test(problem)) {
        return level;
      }
    }
    
    return 'medium';
  }

  // 提取约束描述
  extractConstraintDescription(problem, constraintType) {
    // 简化的约束描述提取
    const sentences = problem.split(/[。！？.!?]/);
    const relevantSentences = sentences.filter(sentence => 
      sentence.includes(constraintType) || 
      this.isConstraintRelated(sentence, constraintType)
    );
    
    return relevantSentences.length > 0 ? relevantSentences[0].trim() : `${constraintType}相关约束`;
  }

  // 判断是否与约束相关
  isConstraintRelated(sentence, constraintType) {
    const relatedKeywords = {
      time: ['时间', '期限', '截止', '紧急', '快速'],
      budget: ['预算', '成本', '资金', '费用', '价格'],
      resources: ['资源', '人力', '设备', '技术', '工具'],
      legal: ['法律', '合规', '规定', '要求', '政策'],
      technical: ['技术', '系统', '平台', '兼容', '架构'],
      quality: ['质量', '标准', '要求', '规范', '水平']
    };
    
    const keywords = relatedKeywords[constraintType] || [];
    return keywords.some(keyword => sentence.includes(keyword));
  }

  // 认知增强
  async enhanceCognition(problem, framework, context) {
    console.log('🧠 进行认知增强');
    
    const enhancement = {
      phase: 'enhancement',
      framework,
      enhancedInfo: {
        relatedConcepts: [],
        analogies: [],
        precedents: [],
        alternativePerspectives: [],
        hiddenAssumptions: []
      },
      cognitiveTools: []
    };
    
    // 概念扩展
    enhancement.enhancedInfo.relatedConcepts = await this.cognitiveEnhancer.expandConcepts(problem);
    
    // 类比发现
    enhancement.enhancedInfo.analogies = await this.cognitiveEnhancer.findAnalogies(problem);
    
    // 先例搜索
    enhancement.enhancedInfo.precedents = await this.cognitiveEnhancer.findPrecedents(problem, context);
    
    // 多角度视角
    enhancement.enhancedInfo.alternativePerspectives = await this.cognitiveEnhancer.generatePerspectives(problem);
    
    // 隐含假设识别
    enhancement.enhancedInfo.hiddenAssumptions = await this.cognitiveEnhancer.identifyAssumptions(problem);
    
    // 选择认知工具
    enhancement.cognitiveTools = this.selectCognitiveTools(problem, framework);
    
    return enhancement;
  }

  // 选择认知工具
  selectCognitiveTools(problem, framework) {
    const tools = [];
    
    // 根据问题类型选择工具
    if (framework.name.includes('分析')) {
      tools.push('因果分析', '根本原因分析', 'SWOT分析');
    }
    
    if (framework.name.includes('创新')) {
      tools.push('头脑风暴', '六顶思考帽', 'SCAMPER技法');
    }
    
    if (framework.name.includes('决策')) {
      tools.push('决策树', '成本效益分析', '风险评估');
    }
    
    return tools;
  }

  // 偏见检测与纠正
  async detectAndCorrectBias(problem, enhancedInfo, context) {
    console.log('🔍 检测和纠正认知偏见');
    
    const biasAnalysis = {
      phase: 'bias_correction',
      detectedBiases: [],
      corrections: [],
      correctedInfo: { ...enhancedInfo }
    };
    
    // 检测常见偏见
    const biases = await this.biasDetector.detectBiases(problem, enhancedInfo, context);
    biasAnalysis.detectedBiases = biases;
    
    // 为每个偏见提供纠正建议
    for (const bias of biases) {
      const correction = await this.biasDetector.generateCorrection(bias, problem, enhancedInfo);
      biasAnalysis.corrections.push(correction);
      
      // 应用纠正
      this.applyBiasCorrection(biasAnalysis.correctedInfo, correction);
    }
    
    return biasAnalysis;
  }

  // 应用偏见纠正
  applyBiasCorrection(correctedInfo, correction) {
    switch (correction.type) {
      case 'confirmation_bias':
        // 添加反对观点
        correctedInfo.alternativePerspectives.push(...correction.counterArguments);
        break;
        
      case 'anchoring_bias':
        // 提供多个参考点
        correctedInfo.alternativeAnchors = correction.alternativeAnchors;
        break;
        
      case 'availability_bias':
        // 补充统计数据
        correctedInfo.statisticalEvidence = correction.statisticalEvidence;
        break;
        
      case 'overconfidence_bias':
        // 添加不确定性提醒
        correctedInfo.uncertaintyFactors = correction.uncertaintyFactors;
        break;
    }
  }

  // 结构化思考引导
  async guideStructuredThinking(problem, correctedInfo, framework) {
    console.log('🗂️ 引导结构化思考');
    
    const guidedThinking = {
      phase: 'guided_thinking',
      framework,
      structuredThoughts: {},
      thinkingSteps: [],
      insights: []
    };
    
    // 根据框架引导思考
    const steps = framework.steps || [];
    
    for (const step of steps) {
      const stepResult = await this.executeThinkingStep(step, problem, correctedInfo);
      guidedThinking.thinkingSteps.push(stepResult);
      guidedThinking.structuredThoughts[step.name] = stepResult.output;
      
      if (stepResult.insights) {
        guidedThinking.insights.push(...stepResult.insights);
      }
    }
    
    return guidedThinking;
  }

  // 执行思考步骤
  async executeThinkingStep(step, problem, correctedInfo) {
    const stepResult = {
      step: step.name,
      description: step.description,
      input: problem,
      output: null,
      insights: [],
      duration: 0
    };
    
    const startTime = Date.now();
    
    try {
      switch (step.type) {
        case 'analysis':
          stepResult.output = await this.performAnalysis(step, problem, correctedInfo);
          break;
          
        case 'synthesis':
          stepResult.output = await this.performSynthesis(step, problem, correctedInfo);
          break;
          
        case 'evaluation':
          stepResult.output = await this.performEvaluation(step, problem, correctedInfo);
          break;
          
        case 'generation':
          stepResult.output = await this.performGeneration(step, problem, correctedInfo);
          break;
          
        default:
          stepResult.output = await this.performGenericStep(step, problem, correctedInfo);
      }
      
      // 提取洞察
      stepResult.insights = this.extractInsights(stepResult.output, step);
      
    } catch (error) {
      stepResult.error = error.message;
      console.error(`执行思考步骤 ${step.name} 出错:`, error.message);
    } finally {
      stepResult.duration = Date.now() - startTime;
    }
    
    return stepResult;
  }

  // 执行分析步骤
  async performAnalysis(step, problem, correctedInfo) {
    const analysis = {
      type: 'analysis',
      findings: [],
      patterns: [],
      relationships: []
    };
    
    // 根据分析类型执行不同的分析
    switch (step.analysisType) {
      case 'root_cause':
        analysis.findings = this.performRootCauseAnalysis(problem, correctedInfo);
        break;
        
      case 'stakeholder':
        analysis.findings = this.performStakeholderAnalysis(problem, correctedInfo);
        break;
        
      case 'risk':
        analysis.findings = this.performRiskAnalysis(problem, correctedInfo);
        break;
        
      default:
        analysis.findings = this.performGenericAnalysis(problem, correctedInfo);
    }
    
    return analysis;
  }

  // 根本原因分析
  performRootCauseAnalysis(problem, correctedInfo) {
    const causes = [];
    
    // 简化的根本原因分析
    const problemKeywords = this.extractKeywords(problem);
    
    for (const keyword of problemKeywords) {
      if (this.isProblemIndicator(keyword)) {
        causes.push({
          cause: `${keyword}相关因素`,
          level: 'surface',
          evidence: `问题描述中提到了${keyword}`,
          likelihood: 0.7
        });
        
        // 寻找更深层的原因
        const deeperCauses = this.findDeeperCauses(keyword, correctedInfo);
        causes.push(...deeperCauses);
      }
    }
    
    return causes.sort((a, b) => b.likelihood - a.likelihood);
  }

  // 判断是否为问题指标
  isProblemIndicator(keyword) {
    const problemIndicators = [
      '问题', '困难', '挑战', '障碍', '瓶颈',
      '错误', '失败', '延迟', '超支', '质量'
    ];
    
    return problemIndicators.some(indicator => 
      keyword.includes(indicator) || indicator.includes(keyword)
    );
  }

  // 寻找更深层原因
  findDeeperCauses(surfaceCause, correctedInfo) {
    const deeperCauses = [];
    
    // 基于类比寻找原因
    for (const analogy of correctedInfo.analogies || []) {
      if (analogy.similarity > 0.6) {
        deeperCauses.push({
          cause: `类似于${analogy.case}的根本原因`,
          level: 'root',
          evidence: `基于类比案例${analogy.case}`,
          likelihood: analogy.similarity * 0.8
        });
      }
    }
    
    // 基于先例寻找原因
    for (const precedent of correctedInfo.precedents || []) {
      if (precedent.relevance > 0.7) {
        deeperCauses.push({
          cause: `历史案例显示的系统性原因`,
          level: 'systemic',
          evidence: `基于历史案例${precedent.title}`,
          likelihood: precedent.relevance * 0.9
        });
      }
    }
    
    return deeperCauses;
  }

  // 利益相关者分析
  performStakeholderAnalysis(problem, correctedInfo) {
    const stakeholderAnalysis = [];
    
    // 从问题中识别的利益相关者
    const identifiedStakeholders = this.identifyStakeholders(problem);
    
    for (const stakeholder of identifiedStakeholders) {
      stakeholderAnalysis.push({
        stakeholder,
        interest: this.assessStakeholderInterest(stakeholder, problem),
        influence: this.assessStakeholderInfluence(stakeholder, problem),
        impact: this.assessStakeholderImpact(stakeholder, problem),
        strategy: this.recommendStakeholderStrategy(stakeholder, problem)
      });
    }
    
    return stakeholderAnalysis;
  }

  // 评估利益相关者兴趣
  assessStakeholderInterest(stakeholder, problem) {
    // 简化的兴趣评估
    const interestKeywords = {
      customers: ['满意', '体验', '价值', '服务'],
      employees: ['工作', '发展', '薪酬', '环境'],
      management: ['业绩', '效率', '成本', '战略'],
      investors: ['回报', '增长', '风险', '价值']
    };
    
    const keywords = interestKeywords[stakeholder] || [];
    const matches = keywords.filter(keyword => problem.includes(keyword)).length;
    
    return {
      level: matches > 2 ? 'high' : matches > 0 ? 'medium' : 'low',
      score: matches / keywords.length,
      keywords: keywords.filter(keyword => problem.includes(keyword))
    };
  }

  // 评估利益相关者影响力
  assessStakeholderInfluence(stakeholder, problem) {
    const influenceLevels = {
      management: 'high',
      investors: 'high',
      regulators: 'high',
      customers: 'medium',
      employees: 'medium',
      partners: 'medium',
      community: 'low'
    };
    
    return {
      level: influenceLevels[stakeholder] || 'medium',
      reasoning: `基于${stakeholder}在组织中的典型影响力水平`
    };
  }

  // 评估利益相关者影响
  assessStakeholderImpact(stakeholder, problem) {
    // 基于问题类型评估影响
    const impactMatrix = {
      strategic: { management: 'high', investors: 'high', employees: 'medium' },
      operational: { employees: 'high', customers: 'high', management: 'medium' },
      financial: { investors: 'high', management: 'high', employees: 'medium' }
    };
    
    const problemType = this.classifyProblem(problem).primary;
    const impact = impactMatrix[problemType]?.[stakeholder] || 'medium';
    
    return {
      level: impact,
      reasoning: `基于${problemType}类型问题对${stakeholder}的典型影响`
    };
  }

  // 推荐利益相关者策略
  recommendStakeholderStrategy(stakeholder, problem) {
    const strategies = {
      high_high: '密切合作，积极参与',
      high_medium: '保持满意，定期沟通',
      high_low: '重点关注，满足需求',
      medium_high: '保持知情，寻求支持',
      medium_medium: '定期监控，适度参与',
      medium_low: '最小努力，基本沟通',
      low_high: '保持知情，防范风险',
      low_medium: '监控态度，必要时沟通',
      low_low: '最小关注，基本监控'
    };
    
    const interest = this.assessStakeholderInterest(stakeholder, problem).level;
    const influence = this.assessStakeholderInfluence(stakeholder, problem).level;
    const key = `${interest}_${influence}`;
    
    return strategies[key] || '适度关注，灵活应对';
  }

  // 风险分析
  performRiskAnalysis(problem, correctedInfo) {
    const risks = [];
    
    // 识别风险关键词
    const riskKeywords = [
      '风险', '威胁', '危险', '不确定', '失败',
      '延迟', '超支', '质量', '安全', '合规'
    ];
    
    for (const keyword of riskKeywords) {
      if (problem.includes(keyword)) {
        risks.push({
          risk: `${keyword}相关风险`,
          probability: this.assessRiskProbability(keyword, problem),
          impact: this.assessRiskImpact(keyword, problem),
          mitigation: this.suggestRiskMitigation(keyword, problem)
        });
      }
    }
    
    // 基于隐含假设识别风险
    for (const assumption of correctedInfo.hiddenAssumptions || []) {
      if (assumption.confidence < 0.7) {
        risks.push({
          risk: `假设"${assumption.assumption}"可能不成立的风险`,
          probability: 1 - assumption.confidence,
          impact: 'medium',
          mitigation: `验证假设：${assumption.assumption}`
        });
      }
    }
    
    return risks.sort((a, b) => (b.probability * this.impactToNumber(b.impact)) - 
                                (a.probability * this.impactToNumber(a.impact)));
  }

  // 评估风险概率
  assessRiskProbability(riskKeyword, problem) {
    const probabilityIndicators = {
      high: /很可能|经常|通常|大概率/,
      medium: /可能|也许|或许|有时/,
      low: /不太可能|很少|偶尔|小概率/
    };
    
    for (const [level, pattern] of Object.entries(probabilityIndicators)) {
      if (pattern.test(problem)) {
        return level === 'high' ? 0.8 : level === 'medium' ? 0.5 : 0.2;
      }
    }
    
    return 0.5; // 默认中等概率
  }

  // 评估风险影响
  assessRiskImpact(riskKeyword, problem) {
    const highImpactKeywords = ['关键', '重要', '核心', '致命', '严重'];
    const lowImpactKeywords = ['轻微', '小', '局部', '暂时', '可控'];
    
    if (highImpactKeywords.some(keyword => problem.includes(keyword))) {
      return 'high';
    } else if (lowImpactKeywords.some(keyword => problem.includes(keyword))) {
      return 'low';
    }
    
    return 'medium';
  }

  // 建议风险缓解措施
  suggestRiskMitigation(riskKeyword, problem) {
    const mitigationStrategies = {
      '风险': '制定风险管理计划，建立监控机制',
      '延迟': '制定详细时间表，设置里程碑检查点',
      '超支': '严格预算控制，定期成本审查',
      '质量': '建立质量保证流程，增加测试环节',
      '安全': '实施安全协议，定期安全审计',
      '合规': '咨询法律专家，建立合规检查清单'
    };
    
    return mitigationStrategies[riskKeyword] || '制定应对计划，定期监控评估';
  }

  // 影响级别转数字
  impactToNumber(impact) {
    const mapping = { low: 1, medium: 2, high: 3 };
    return mapping[impact] || 2;
  }

  // 通用分析
  performGenericAnalysis(problem, correctedInfo) {
    return {
      summary: '基于提供的信息进行了综合分析',
      keyFindings: [
        '识别了问题的主要组成部分',
        '分析了相关的影响因素',
        '考虑了多个角度的观点'
      ],
      recommendations: [
        '建议进一步收集具体数据',
        '考虑咨询相关专家意见',
        '制定分阶段的解决方案'
      ]
    };
  }

  // 执行综合步骤
  async performSynthesis(step, problem, correctedInfo) {
    const synthesis = {
      type: 'synthesis',
      integratedInsights: [],
      patterns: [],
      connections: []
    };
    
    // 整合不同来源的信息
    const allInsights = [
      ...(correctedInfo.relatedConcepts || []),
      ...(correctedInfo.analogies || []),
      ...(correctedInfo.precedents || [])
    ];
    
    // 寻找模式和连接
    synthesis.patterns = this.identifyPatterns(allInsights);
    synthesis.connections = this.findConnections(allInsights, problem);
    synthesis.integratedInsights = this.integrateInsights(allInsights, synthesis.patterns);
    
    return synthesis;
  }

  // 识别模式
  identifyPatterns(insights) {
    const patterns = [];
    
    // 简化的模式识别
    const themes = new Map();
    
    for (const insight of insights) {
      const keywords = this.extractKeywords(insight.description || insight.title || '');
      for (const keyword of keywords) {
        themes.set(keyword, (themes.get(keyword) || 0) + 1);
      }
    }
    
    // 找出频繁出现的主题
    for (const [theme, count] of themes.entries()) {
      if (count >= 2) {
        patterns.push({
          theme,
          frequency: count,
          strength: count / insights.length,
          description: `${theme}是一个重复出现的主题`
        });
      }
    }
    
    return patterns.sort((a, b) => b.strength - a.strength);
  }

  // 寻找连接
  findConnections(insights, problem) {
    const connections = [];
    
    // 寻找洞察之间的关系
    for (let i = 0; i < insights.length; i++) {
      for (let j = i + 1; j < insights.length; j++) {
        const connection = this.findConnection(insights[i], insights[j], problem);
        if (connection) {
          connections.push(connection);
        }
      }
    }
    
    return connections;
  }

  // 寻找单个连接
  findConnection(insight1, insight2, problem) {
    const text1 = (insight1.description || insight1.title || '').toLowerCase();
    const text2 = (insight2.description || insight2.title || '').toLowerCase();
    
    // 寻找共同关键词
    const keywords1 = new Set(this.extractKeywords(text1));
    const keywords2 = new Set(this.extractKeywords(text2));
    const commonKeywords = [...keywords1].filter(k => keywords2.has(k));
    
    if (commonKeywords.length > 0) {
      return {
        type: 'thematic',
        insight1: insight1.title || insight1.description,
        insight2: insight2.title || insight2.description,
        connection: `都涉及${commonKeywords.join('、')}`,
        strength: commonKeywords.length / Math.max(keywords1.size, keywords2.size)
      };
    }
    
    // 寻找因果关系
    if (this.hasCausalRelation(text1, text2)) {
      return {
        type: 'causal',
        insight1: insight1.title || insight1.description,
        insight2: insight2.title || insight2.description,
        connection: '存在潜在的因果关系',
        strength: 0.7
      };
    }
    
    return null;
  }

  // 检查因果关系
  hasCausalRelation(text1, text2) {
    const causalKeywords = ['导致', '引起', '造成', '影响', '结果', '原因'];
    return causalKeywords.some(keyword => 
      text1.includes(keyword) || text2.includes(keyword)
    );
  }

  // 整合洞察
  integrateInsights(insights, patterns) {
    const integrated = [];
    
    // 按模式分组洞察
    for (const pattern of patterns) {
      const relatedInsights = insights.filter(insight => 
        (insight.description || insight.title || '').includes(pattern.theme)
      );
      
      if (relatedInsights.length > 1) {
        integrated.push({
          theme: pattern.theme,
          insights: relatedInsights,
          synthesis: `关于${pattern.theme}的综合洞察：多个来源都指向了这个重要方面`,
          confidence: pattern.strength
        });
      }
    }
    
    return integrated;
  }

  // 执行评估步骤
  async performEvaluation(step, problem, correctedInfo) {
    const evaluation = {
      type: 'evaluation',
      criteria: step.criteria || ['可行性', '效果', '成本', '风险'],
      alternatives: [],
      scores: {},
      recommendation: null
    };
    
    // 生成备选方案（如果还没有）
    if (!correctedInfo.alternatives) {
      evaluation.alternatives = await this.generateAlternatives(problem, correctedInfo);
    } else {
      evaluation.alternatives = correctedInfo.alternatives;
    }
    
    // 评估每个备选方案
    for (const alternative of evaluation.alternatives) {
      evaluation.scores[alternative.id] = this.scoreAlternative(alternative, evaluation.criteria, problem);
    }
    
    // 生成推荐
    evaluation.recommendation = this.generateRecommendation(evaluation.alternatives, evaluation.scores);
    
    return evaluation;
  }

  // 生成备选方案
  async generateAlternatives(problem, correctedInfo) {
    const alternatives = [];
    
    // 基于类比生成方案
    for (const analogy of correctedInfo.analogies || []) {
      if (analogy.similarity > 0.6) {
        alternatives.push({
          id: `analogy_${alternatives.length}`,
          name: `基于${analogy.case}的方案`,
          description: `借鉴${analogy.case}的成功经验`,
          source: 'analogy',
          confidence: analogy.similarity
        });
      }
    }
    
    // 基于先例生成方案
    for (const precedent of correctedInfo.precedents || []) {
      if (precedent.relevance > 0.7) {
        alternatives.push({
          id: `precedent_${alternatives.length}`,
          name: `参考${precedent.title}的方案`,
          description: `采用历史成功案例的方法`,
          source: 'precedent',
          confidence: precedent.relevance
        });
      }
    }
    
    // 生成创新方案
    alternatives.push({
      id: 'innovative',
      name: '创新解决方案',
      description: '结合当前情况的创新方法',
      source: 'innovation',
      confidence: 0.6
    });
    
    // 生成保守方案
    alternatives.push({
      id: 'conservative',
      name: '保守稳妥方案',
      description: '风险较低的传统方法',
      source: 'conservative',
      confidence: 0.8
    });
    
    return alternatives;
  }

  // 评分备选方案
  scoreAlternative(alternative, criteria, problem) {
    const scores = {};
    
    for (const criterion of criteria) {
      scores[criterion] = this.scoreByCriterion(alternative, criterion, problem);
    }
    
    // 计算总分
    const totalScore = Object.values(scores).reduce((sum, score) => sum + score, 0) / criteria.length;
    scores.total = totalScore;
    
    return scores;
  }

  // 按标准评分
  scoreByCriterion(alternative, criterion, problem) {
    // 简化的评分逻辑
    switch (criterion) {
      case '可行性':
        return alternative.source === 'conservative' ? 0.9 : 
               alternative.source === 'precedent' ? 0.8 : 
               alternative.source === 'analogy' ? 0.7 : 0.6;
               
      case '效果':
        return alternative.source === 'innovative' ? 0.9 : 
               alternative.source === 'analogy' ? 0.8 : 
               alternative.source === 'precedent' ? 0.7 : 0.6;
               
      case '成本':
        return alternative.source === 'conservative' ? 0.8 : 
               alternative.source === 'precedent' ? 0.7 : 
               alternative.source === 'analogy' ? 0.6 : 0.5;
               
      case '风险':
        return alternative.source === 'conservative' ? 0.9 : 
               alternative.source === 'precedent' ? 0.8 : 
               alternative.source === 'analogy' ? 0.6 : 0.4;
               
      default:
        return alternative.confidence || 0.5;
    }
  }

  // 生成推荐
  generateRecommendation(alternatives, scores) {
    // 找出总分最高的方案
    let bestAlternative = null;
    let bestScore = -1;
    
    for (const alternative of alternatives) {
      const score = scores[alternative.id].total;
      if (score > bestScore) {
        bestScore = score;
        bestAlternative = alternative;
      }
    }
    
    return {
      recommended: bestAlternative,
      score: bestScore,
      reasoning: `基于综合评估，${bestAlternative.name}获得了最高分${bestScore.toFixed(2)}`,
      considerations: this.generateConsiderations(bestAlternative, scores[bestAlternative.id])
    };
  }

  // 生成考虑因素
  generateConsiderations(alternative, scores) {
    const considerations = [];
    
    // 分析强项和弱项
    const sortedScores = Object.entries(scores)
      .filter(([key]) => key !== 'total')
      .sort(([,a], [,b]) => b - a);
    
    const strengths = sortedScores.slice(0, 2).map(([criterion]) => criterion);
    const weaknesses = sortedScores.slice(-2).map(([criterion]) => criterion);
    
    considerations.push(`优势：在${strengths.join('和')}方面表现突出`);
    considerations.push(`注意：在${weaknesses.join('和')}方面需要特别关注`);
    
    return considerations;
  }

  // 执行生成步骤
  async performGeneration(step, problem, correctedInfo) {
    const generation = {
      type: 'generation',
      generatedItems: [],
      creativity: 0,
      novelty: 0
    };
    
    switch (step.generationType) {
      case 'solutions':
        generation.generatedItems = await this.generateSolutions(problem, correctedInfo);
        break;
        
      case 'ideas':
        generation.generatedItems = await this.generateIdeas(problem, correctedInfo);
        break;
        
      case 'questions':
        generation.generatedItems = await this.generateQuestions(problem, correctedInfo);
        break;
        
      default:
        generation.generatedItems = await this.generateGenericItems(problem, correctedInfo);
    }
    
    // 评估创造性和新颖性
    generation.creativity = this.assessCreativity(generation.generatedItems);
    generation.novelty = this.assessNovelty(generation.generatedItems, correctedInfo);
    
    return generation;
  }

  // 生成解决方案
  async generateSolutions(problem, correctedInfo) {
    const solutions = [];
    
    // 基于类比的解决方案
    for (const analogy of correctedInfo.analogies || []) {
      solutions.push({
        type: 'analogical',
        solution: `采用类似${analogy.case}的解决方法`,
        description: `基于${analogy.case}的成功经验，适应当前情况`,
        confidence: analogy.similarity,
        source: 'analogy'
      });
    }
    
    // 基于组合的解决方案
    const concepts = correctedInfo.relatedConcepts || [];
    if (concepts.length >= 2) {
      solutions.push({
        type: 'combinatorial',
        solution: `结合${concepts[0].concept}和${concepts[1].concept}的方法`,
        description: '通过组合不同概念创造新的解决方案',
        confidence: 0.6,
        source: 'combination'
      });
    }
    
    // 反向思维解决方案
    solutions.push({
      type: 'reverse',
      solution: '反向思考的解决方案',
      description: '从相反的角度思考问题，寻找意外的解决路径',
      confidence: 0.5,
      source: 'reverse_thinking'
    });
    
    return solutions;
  }

  // 生成想法
  async generateIdeas(problem, correctedInfo) {
    const ideas = [];
    
    // 基于头脑风暴的想法
    const keywords = this.extractKeywords(problem);
    for (const keyword of keywords.slice(0, 3)) {
      ideas.push({
        idea: `关于${keyword}的创新想法`,
        description: `从${keyword}的角度重新思考问题`,
        category: 'brainstorming',
        potential: Math.random() * 0.5 + 0.5
      });
    }
    
    // 基于SCAMPER技法的想法
    const scamperPrompts = [
      { action: 'Substitute', idea: '替换某个关键要素' },
      { action: 'Combine', idea: '组合不同的方法' },
      { action: 'Adapt', idea: '适应其他领域的做法' },
      { action: 'Modify', idea: '修改现有的方案' },
      { action: 'Put to other uses', idea: '用于其他用途' },
      { action: 'Eliminate', idea: '消除某些限制' },
      { action: 'Reverse', idea: '颠倒传统做法' }
    ];
    
    for (const prompt of scamperPrompts.slice(0, 3)) {
      ideas.push({
        idea: `${prompt.action}: ${prompt.idea}`,
        description: `使用SCAMPER技法的${prompt.action}方法`,
        category: 'scamper',
        potential: Math.random() * 0.4 + 0.6
      });
    }
    
    return ideas;
  }

  // 生成问题
  async generateQuestions(problem, correctedInfo) {
    const questions = [];
    
    // 澄清性问题
    questions.push({
      type: 'clarification',
      question: '我们是否完全理解了问题的核心？',
      purpose: '确保问题定义的准确性',
      priority: 'high'
    });
    
    // 假设检验问题
    for (const assumption of correctedInfo.hiddenAssumptions || []) {
      questions.push({
        type: 'assumption',
        question: `假设"${assumption.assumption}"是否成立？`,
        purpose: '验证关键假设',
        priority: assumption.confidence < 0.6 ? 'high' : 'medium'
      });
    }
    
    // 探索性问题
    questions.push({
      type: 'exploration',
      question: '还有哪些我们没有考虑到的角度？',
      purpose: '扩展思考范围',
      priority: 'medium'
    });
    
    // 评估性问题
    questions.push({
      type: 'evaluation',
      question: '如何衡量解决方案的成功？',
      purpose: '建立评估标准',
      priority: 'high'
    });
    
    return questions;
  }

  // 生成通用项目
  async generateGenericItems(problem, correctedInfo) {
    return [
      {
        item: '深入分析问题根源',
        description: '进一步挖掘问题的深层原因',
        type: 'analysis'
      },
      {
        item: '收集更多相关信息',
        description: '获取额外的数据和见解',
        type: 'research'
      },
      {
        item: '咨询领域专家',
        description: '寻求专业人士的意见和建议',
        type: 'consultation'
      }
    ];
  }

  // 评估创造性
  assessCreativity(items) {
    let creativityScore = 0;
    
    for (const item of items) {
      // 基于类型评估创造性
      if (item.type === 'reverse' || item.category === 'scamper') {
        creativityScore += 0.8;
      } else if (item.type === 'combinatorial' || item.source === 'combination') {
        creativityScore += 0.7;
      } else if (item.type === 'analogical') {
        creativityScore += 0.6;
      } else {
        creativityScore += 0.4;
      }
    }
    
    return items.length > 0 ? creativityScore / items.length : 0;
  }

  // 评估新颖性
  assessNovelty(items, correctedInfo) {
    let noveltyScore = 0;
    
    for (const item of items) {
      // 检查是否与已知概念重复
      const isNovel = this.isNovelItem(item, correctedInfo);
      noveltyScore += isNovel ? 0.8 : 0.3;
    }
    
    return items.length > 0 ? noveltyScore / items.length : 0;
  }

  // 判断项目是否新颖
  isNovelItem(item, correctedInfo) {
    const itemText = (item.solution || item.idea || item.item || '').toLowerCase();
    
    // 检查是否与已知概念相似
    for (const concept of correctedInfo.relatedConcepts || []) {
      if (itemText.includes(concept.concept.toLowerCase())) {
        return false;
      }
    }
    
    // 检查是否与先例相似
    for (const precedent of correctedInfo.precedents || []) {
      if (itemText.includes(precedent.title.toLowerCase())) {
        return false;
      }
    }
    
    return true;
  }

  // 执行通用步骤
  async performGenericStep(step, problem, correctedInfo) {
    return {
      type: 'generic',
      result: `执行了${step.name}步骤`,
      description: step.description || '完成了指定的思考步骤',
      insights: [`通过${step.name}获得了新的理解`]
    };
  }

  // 提取洞察
  extractInsights(output, step) {
    const insights = [];
    
    if (output.insights) {
      insights.push(...output.insights);
    }
    
    if (output.findings) {
      insights.push(...output.findings.map(f => f.cause || f.finding || f));
    }
    
    if (output.patterns) {
      insights.push(...output.patterns.map(p => p.description));
    }
    
    if (output.generatedItems) {
      insights.push(...output.generatedItems.map(item => 
        item.solution || item.idea || item.item
      ));
    }
    
    return insights.slice(0, 5); // 最多5个洞察
  }

  // 创造性思维激发
  async stimulateCreativity(problem, structuredThoughts) {
    console.log('🎨 激发创造性思维');
    
    const creativity = {
      phase: 'creativity',
      techniques: [],
      creativeIdeas: [],
      innovations: [],
      breakthroughs: []
    };
    
    // 应用创造性技法
    const techniques = await this.creativityStimulator.selectTechniques(problem, structuredThoughts);
    
    for (const technique of techniques) {
      const result = await this.creativityStimulator.applyTechnique(technique, problem, structuredThoughts);
      creativity.techniques.push({
        technique: technique.name,
        result,
        effectiveness: result.effectiveness
      });
      
      creativity.creativeIdeas.push(...result.ideas);
    }
    
    // 识别创新点
    creativity.innovations = this.identifyInnovations(creativity.creativeIdeas);
    
    // 寻找突破性想法
    creativity.breakthroughs = this.identifyBreakthroughs(creativity.creativeIdeas, problem);
    
    return creativity;
  }

  // 识别创新点
  identifyInnovations(ideas) {
    const innovations = [];
    
    for (const idea of ideas) {
      if (idea.novelty > 0.7 && idea.feasibility > 0.5) {
        innovations.push({
          innovation: idea.description,
          novelty: idea.novelty,
          feasibility: idea.feasibility,
          potential: idea.novelty * idea.feasibility
        });
      }
    }
    
    return innovations.sort((a, b) => b.potential - a.potential);
  }

  // 识别突破性想法
  identifyBreakthroughs(ideas, problem) {
    const breakthroughs = [];
    
    for (const idea of ideas) {
      if (idea.disruptive && idea.impact > 0.8) {
        breakthroughs.push({
          breakthrough: idea.description,
          disruptiveLevel: idea.disruptive,
          impact: idea.impact,
          transformationPotential: idea.disruptive * idea.impact
        });
      }
    }
    
    return breakthroughs.sort((a, b) => b.transformationPotential - a.transformationPotential);
  }

  // 决策支持
  async provideDecisionSupport(problem, phases, context) {
    console.log('🎯 提供决策支持');
    
    const decisionSupport = {
      phase: 'decision_support',
      alternatives: [],
      criteria: [],
      analysis: null,
      recommendation: null,
      riskAssessment: null
    };
    
    // 收集所有备选方案
    decisionSupport.alternatives = this.collectAlternatives(phases);
    
    // 确定决策标准
    decisionSupport.criteria = this.determineCriteria(problem, context);
    
    // 执行决策分析
    decisionSupport.analysis = await this.decisionSupport.analyze(
      decisionSupport.alternatives,
      decisionSupport.criteria,
      problem
    );
    
    // 生成推荐
    decisionSupport.recommendation = this.decisionSupport.recommend(
      decisionSupport.analysis,
      context
    );
    
    // 风险评估
    decisionSupport.riskAssessment = this.assessDecisionRisks(
      decisionSupport.recommendation,
      phases
    );
    
    return decisionSupport;
  }

  // 收集备选方案
  collectAlternatives(phases) {
    const alternatives = [];
    
    for (const phase of phases) {
      if (phase.phase === 'guided_thinking') {
        // 从结构化思考中提取方案
        for (const [stepName, stepOutput] of Object.entries(phase.structuredThoughts)) {
          if (stepOutput.alternatives) {
            alternatives.push(...stepOutput.alternatives);
          }
          if (stepOutput.generatedItems) {
            alternatives.push(...stepOutput.generatedItems.filter(item => 
              item.type === 'solution' || item.solution
            ));
          }
        }
      }
      
      if (phase.phase === 'creativity') {
        // 从创造性思维中提取方案
        alternatives.push(...phase.creativeIdeas.filter(idea => 
          idea.feasibility > 0.4
        ));
        alternatives.push(...phase.innovations);
      }
    }
    
    return alternatives;
  }

  // 确定决策标准
  determineCriteria(problem, context) {
    const criteria = [];
    
    // 基本标准
    criteria.push(
      { name: '可行性', weight: 0.25, description: '方案实施的可能性' },
      { name: '效果', weight: 0.3, description: '预期达成目标的程度' },
      { name: '成本', weight: 0.2, description: '实施所需的资源投入' },
      { name: '风险', weight: 0.15, description: '实施过程中的潜在风险' },
      { name: '时间', weight: 0.1, description: '完成所需的时间' }
    );
    
    // 根据上下文调整权重
    if (context.priority === 'cost') {
      criteria.find(c => c.name === '成本').weight = 0.4;
      criteria.find(c => c.name === '效果').weight = 0.2;
    } else if (context.priority === 'speed') {
      criteria.find(c => c.name === '时间').weight = 0.3;
      criteria.find(c => c.name === '可行性').weight = 0.3;
    }
    
    return criteria;
  }

  // 评估决策风险
  assessDecisionRisks(recommendation, phases) {
    const risks = [];
    
    // 从偏见检测阶段获取风险
    const biasPhase = phases.find(p => p.phase === 'bias_correction');
    if (biasPhase) {
      for (const bias of biasPhase.detectedBiases) {
        risks.push({
          type: 'cognitive_bias',
          risk: `可能受到${bias.type}的影响`,
          probability: bias.confidence,
          mitigation: bias.correction
        });
      }
    }
    
    // 从分析阶段获取风险
    const analysisPhase = phases.find(p => p.phase === 'analysis');
    if (analysisPhase && analysisPhase.constraints) {
      for (const constraint of analysisPhase.constraints) {
        if (constraint.severity === 'high') {
          risks.push({
            type: 'constraint_violation',
            risk: `可能违反${constraint.type}约束`,
            probability: 0.6,
            mitigation: `确保遵守${constraint.description}`
          });
        }
      }
    }
    
    return risks;
  }

  // 整合洞察
  consolidateInsights(phases) {
    const allInsights = [];
    
    for (const phase of phases) {
      if (phase.insights) {
        allInsights.push(...phase.insights.map(insight => ({
          insight,
          phase: phase.phase,
          confidence: phase.confidence || 0.7
        })));
      }
    }
    
    // 去重和排序
    const uniqueInsights = this.deduplicateInsights(allInsights);
    return uniqueInsights.sort((a, b) => b.confidence - a.confidence);
  }

  // 去重洞察
  deduplicateInsights(insights) {
    const unique = [];
    const seen = new Set();
    
    for (const insight of insights) {
      const key = insight.insight.toLowerCase().replace(/\s+/g, '');
      if (!seen.has(key)) {
        seen.add(key);
        unique.push(insight);
      }
    }
    
    return unique;
  }

  // 生成建议
  generateRecommendations(phases, problem) {
    const recommendations = [];
    
    // 基于决策支持的建议
    const decisionPhase = phases.find(p => p.phase === 'decision_support');
    if (decisionPhase && decisionPhase.recommendation) {
      recommendations.push({
        type: 'primary',
        recommendation: decisionPhase.recommendation.recommended.name,
        reasoning: decisionPhase.recommendation.reasoning,
        priority: 'high'
      });
    }
    
    // 基于创造性思维的建议
    const creativityPhase = phases.find(p => p.phase === 'creativity');
    if (creativityPhase && creativityPhase.innovations.length > 0) {
      recommendations.push({
        type: 'innovation',
        recommendation: `考虑创新方案：${creativityPhase.innovations[0].innovation}`,
        reasoning: '基于创造性思维分析的创新建议',
        priority: 'medium'
      });
    }
    
    // 基于风险分析的建议
    const analysisPhase = phases.find(p => p.phase === 'analysis');
    if (analysisPhase && analysisPhase.constraints) {
      const highRiskConstraints = analysisPhase.constraints.filter(c => c.severity === 'high');
      if (highRiskConstraints.length > 0) {
        recommendations.push({
          type: 'risk_mitigation',
          recommendation: `优先处理高风险约束：${highRiskConstraints[0].type}`,
          reasoning: '基于风险分析的预防性建议',
          priority: 'high'
        });
      }
    }
    
    return recommendations.sort((a, b) => 
      (b.priority === 'high' ? 2 : b.priority === 'medium' ? 1 : 0) -
      (a.priority === 'high' ? 2 : a.priority === 'medium' ? 1 : 0)
    );
  }

  // 综合解决方案
  synthesizeSolution(phases, problem) {
    const solution = {
      problem,
      approach: 'AI辅助综合分析',
      keyInsights: [],
      recommendedActions: [],
      implementation: {
        phases: [],
        timeline: '',
        resources: [],
        risks: []
      },
      success_metrics: []
    };
    
    // 提取关键洞察
    const insights = this.consolidateInsights(phases);
    solution.keyInsights = insights.slice(0, 5).map(i => i.insight);
    
    // 提取推荐行动
    const recommendations = this.generateRecommendations(phases, problem);
    solution.recommendedActions = recommendations.map(r => r.recommendation);
    
    // 制定实施计划
    solution.implementation = this.createImplementationPlan(phases, recommendations);
    
    // 定义成功指标
    solution.success_metrics = this.defineSuccessMetrics(problem, phases);
    
    return solution;
  }

  // 创建实施计划
  createImplementationPlan(phases, recommendations) {
    const plan = {
      phases: [
        {
          name: '准备阶段',
          duration: '1-2周',
          activities: ['收集必要资源', '组建团队', '制定详细计划']
        },
        {
          name: '执行阶段',
          duration: '根据方案复杂度',
          activities: ['实施推荐方案', '监控进展', '调整策略']
        },
        {
          name: '评估阶段',
          duration: '1周',
          activities: ['评估结果', '总结经验', '优化流程']
        }
      ],
      timeline: '预计2-8周，具体取决于方案复杂度',
      resources: ['项目团队', '必要的技术工具', '预算支持'],
      risks: ['执行偏差', '资源不足', '外部环境变化']
    };
    
    return plan;
  }

  // 定义成功指标
  defineSuccessMetrics(problem, phases) {
    const metrics = [
      '问题解决程度（目标：90%以上）',
      '利益相关者满意度（目标：80%以上）',
      '实施成本控制（目标：预算内）',
      '时间目标达成（目标：按时完成）'
    ];
    
    // 根据问题类型添加特定指标
    const problemType = this.classifyProblem(problem).primary;
    switch (problemType) {
      case 'financial':
        metrics.push('ROI达成（目标：正向回报）');
        break;
      case 'operational':
        metrics.push('效率提升（目标：20%以上）');
        break;
      case 'strategic':
        metrics.push('战略目标对齐度（目标：高度对齐）');
        break;
    }
    
    return metrics;
  }

  // 提取关键词
  extractKeywords(text) {
    // 简化的关键词提取
    const words = text.toLowerCase()
      .replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s]/g, '')
      .split(/\s+/)
      .filter(word => word.length > 1);
    
    // 移除常见停用词
    const stopWords = new Set([
      '的', '了', '在', '是', '我', '有', '和', '就', '不', '人',
      '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去',
      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to',
      'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be'
    ]);
    
    return words.filter(word => !stopWords.has(word));
  }

  // 识别领域
  identifyDomain(problem, context) {
    const domainKeywords = {
      technology: /技术|软件|系统|开发|编程|数据|网络|AI|人工智能/,
      business: /商业|业务|市场|销售|客户|收入|利润|竞争/,
      management: /管理|领导|团队|组织|流程|效率|绩效/,
      finance: /财务|资金|投资|成本|预算|收益|风险/,
      marketing: /营销|推广|品牌|广告|用户|增长|转化/,
      operations: /运营|生产|供应链|物流|质量|服务/,
      hr: /人力资源|招聘|培训|员工|薪酬|文化/,
      legal: /法律|合规|政策|法规|合同|知识产权/
    };
    
    const scores = {};
    for (const [domain, pattern] of Object.entries(domainKeywords)) {
      const matches = (problem.match(pattern) || []).length;
      if (context.domain && context.domain.includes(domain)) {
        matches += 2; // 上下文权重
      }
      scores[domain] = matches;
    }
    
    const topDomain = Object.entries(scores)
      .sort(([,a], [,b]) => b - a)[0];
    
    return {
      primary: topDomain[0],
      confidence: topDomain[1] > 0 ? 0.8 : 0.3,
      allScores: scores
    };
  }

  // 生成会话ID
  generateSessionId() {
    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  // 获取会话历史
  getSessionHistory(userId = null) {
    if (userId) {
      return this.sessionHistory.filter(session => session.userId === userId);
    }
    return this.sessionHistory;
  }

  // 获取系统统计
  getSystemStats() {
    const totalSessions = this.sessionHistory.length;
    const successfulSessions = this.sessionHistory.filter(s => !s.error).length;
    const averageDuration = this.sessionHistory.reduce((sum, s) => sum + (s.duration || 0), 0) / totalSessions;
    
    return {
      totalSessions,
      successfulSessions,
      successRate: totalSessions > 0 ? successfulSessions / totalSessions : 0,
      averageDuration: Math.round(averageDuration),
      totalInsights: this.sessionHistory.reduce((sum, s) => sum + (s.insights?.length || 0), 0)
    };
  }
}

// 认知增强器
class CognitiveEnhancer {
  constructor() {
    this.conceptDatabase = new Map();
    this.analogyDatabase = new Map();
    this.precedentDatabase = new Map();
  }

  // 扩展概念
  async expandConcepts(problem) {
    const keywords = this.extractKeywords(problem);
    const concepts = [];
    
    for (const keyword of keywords.slice(0, 5)) {
      concepts.push({
        concept: keyword,
        relatedConcepts: this.findRelatedConcepts(keyword),
        definition: this.getConceptDefinition(keyword),
        applications: this.getConceptApplications(keyword)
      });
    }
    
    return concepts;
  }

  // 寻找相关概念
  findRelatedConcepts(concept) {
    // 简化的相关概念查找
    const conceptMap = {
      '技术': ['创新', '数字化', '自动化', '效率'],
      '管理': ['领导', '组织', '流程', '绩效'],
      '市场': ['客户', '竞争', '需求', '价值'],
      '成本': ['预算', '投资', '收益', '风险']
    };
    
    return conceptMap[concept] || [];
  }

  // 获取概念定义
  getConceptDefinition(concept) {
    // 简化的概念定义
    const definitions = {
      '技术': '应用科学知识解决实际问题的方法和工具',
      '管理': '通过计划、组织、领导和控制来实现目标的过程',
      '市场': '买卖双方进行交易的场所或机制',
      '成本': '为获得某种资源或服务而付出的代价'
    };
    
    return definitions[concept] || `${concept}的相关概念`;
  }

  // 获取概念应用
  getConceptApplications(concept) {
    // 简化的概念应用
    const applications = {
      '技术': ['软件开发', '自动化生产', '数据分析'],
      '管理': ['项目管理', '团队领导', '战略规划'],
      '市场': ['市场调研', '产品定位', '客户分析'],
      '成本': ['成本控制', '预算管理', '投资分析']
    };
    
    return applications[concept] || [];
  }

  // 寻找类比
  async findAnalogies(problem) {
    const analogies = [];
    
    // 简化的类比查找
    const problemKeywords = this.extractKeywords(problem);
    
    for (const keyword of problemKeywords.slice(0, 3)) {
      const analogy = this.findAnalogy(keyword);
      if (analogy) {
        analogies.push(analogy);
      }
    }
    
    return analogies;
  }

  // 寻找单个类比
  findAnalogy(keyword) {
    const analogyMap = {
      '团队': {
        case: '乐队合奏',
        similarity: 0.8,
        explanation: '团队合作就像乐队合奏，需要协调配合'
      },
      '管理': {
        case: '指挥家指挥乐团',
        similarity: 0.7,
        explanation: '管理者像指挥家，协调各部门发挥最佳效果'
      },
      '创新': {
        case: '厨师创新菜品',
        similarity: 0.6,
        explanation: '创新就像厨师结合不同食材创造新菜品'
      }
    };
    
    return analogyMap[keyword] || null;
  }

  // 寻找先例
  async findPrecedents(problem, context) {
    const precedents = [];
    
    // 简化的先例查找
    const domain = context.domain || 'general';
    const problemType = this.classifyProblemType(problem);
    
    const precedentMap = {
      'technology_innovation': {
        title: 'iPhone的创新突破',
        relevance: 0.9,
        summary: '通过用户体验创新重新定义了手机行业',
        lessons: ['用户体验至上', '简化复杂功能', '生态系统思维']
      },
      'business_transformation': {
        title: 'Netflix的商业模式转型',
        relevance: 0.8,
        summary: '从DVD租赁成功转型为流媒体服务',
        lessons: ['拥抱技术变革', '数据驱动决策', '持续创新']
      },
      'team_management': {
        title: 'Google的团队管理实践',
        relevance: 0.7,
        summary: '通过心理安全感提升团队效能',
        lessons: ['建立心理安全感', '鼓励多元化', '数据驱动管理']
      }
    };
    
    const key = `${domain}_${problemType}`;
    const precedent = precedentMap[key];
    if (precedent) {
      precedents.push(precedent);
    }
    
    return precedents;
  }

  // 分类问题类型
  classifyProblemType(problem) {
    if (/创新|新|突破/.test(problem)) return 'innovation';
    if (/转型|变革|改变/.test(problem)) return 'transformation';
    if (/团队|管理|领导/.test(problem)) return 'management';
    return 'general';
  }

  // 生成视角
  async generatePerspectives(problem) {
    const perspectives = [
      {
        perspective: '用户视角',
        description: '从最终用户的角度思考问题',
        questions: ['用户真正需要什么？', '用户体验如何？']
      },
      {
        perspective: '商业视角',
        description: '从商业价值和盈利角度分析',
        questions: ['商业价值在哪里？', '如何实现盈利？']
      },
      {
        perspective: '技术视角',
        description: '从技术实现和可行性角度考虑',
        questions: ['技术上如何实现？', '有什么技术限制？']
      },
      {
        perspective: '风险视角',
        description: '从风险管理和预防角度思考',
        questions: ['可能的风险是什么？', '如何预防和应对？']
      }
    ];
    
    return perspectives;
  }

  // 识别假设
  async identifyAssumptions(problem) {
    const assumptions = [];
    
    // 简化的假设识别
    const assumptionPatterns = {
      '用户会': { assumption: '用户会按预期使用产品', confidence: 0.6 },
      '市场需要': { assumption: '市场对此有需求', confidence: 0.7 },
      '技术可以': { assumption: '技术能够实现预期功能', confidence: 0.8 },
      '成本控制': { assumption: '成本可以控制在预算内', confidence: 0.5 }
    };
    
    for (const [pattern, data] of Object.entries(assumptionPatterns)) {
      if (problem.includes(pattern)) {
        assumptions.push(data);
      }
    }
    
    return assumptions;
  }

  // 提取关键词
  extractKeywords(text) {
    return text.toLowerCase()
      .replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s]/g, '')
      .split(/\s+/)
      .filter(word => word.length > 1)
      .slice(0, 10);
  }
}

// 思维框架管理器
class ThinkingFrameworks {
  constructor() {
    this.frameworks = new Map();
    this.initializeFrameworks();
  }

  // 初始化框架
  initializeFrameworks() {
    // SWOT分析框架
    this.frameworks.set('swot', {
      name: 'SWOT分析',
      description: '分析优势、劣势、机会和威胁',
      applicableTypes: ['strategic', 'business'],
      steps: [
        { name: '优势分析', type: 'analysis', description: '识别内部优势' },
        { name: '劣势分析', type: 'analysis', description: '识别内部劣势' },
        { name: '机会分析', type: 'analysis', description: '识别外部机会' },
        { name: '威胁分析', type: 'analysis', description: '识别外部威胁' },
        { name: '策略制定', type: 'synthesis', description: '基于SWOT制定策略' }
      ]
    });
    
    // 5W1H分析框架
    this.frameworks.set('5w1h', {
      name: '5W1H分析',
      description: '全面分析问题的六个维度',
      applicableTypes: ['analytical', 'operational'],
      steps: [
        { name: 'What分析', type: 'analysis', description: '分析是什么问题' },
        { name: 'Why分析', type: 'analysis', description: '分析为什么发生' },
        { name: 'Who分析', type: 'analysis', description: '分析涉及哪些人' },
        { name: 'When分析', type: 'analysis', description: '分析时间因素' },
        { name: 'Where分析', type: 'analysis', description: '分析地点因素' },
        { name: 'How分析', type: 'analysis', description: '分析如何解决' }
      ]
    });
    
    // 设计思维框架
    this.frameworks.set('design_thinking', {
      name: '设计思维',
      description: '以用户为中心的创新方法',
      applicableTypes: ['creative', 'innovation'],
      steps: [
        { name: '共情', type: 'analysis', description: '理解用户需求' },
        { name: '定义', type: 'synthesis', description: '定义核心问题' },
        { name: '构思', type: 'generation', generationType: 'ideas', description: '产生创意想法' },
        { name: '原型', type: 'generation', generationType: 'solutions', description: '制作原型' },
        { name: '测试', type: 'evaluation', description: '测试和改进' }
      ]
    });
  }

  // 加载框架
  async loadFrameworks() {
    console.log('📚 加载思维框架');
    // 框架已在构造函数中初始化
    return true;
  }

  // 选择最佳框架
  async selectBestFramework(analysis) {
    const { problemType, complexity, domain } = analysis;
    
    let bestFramework = null;
    let bestScore = 0;
    
    for (const [key, framework] of this.frameworks.entries()) {
      const score = this.scoreFramework(framework, problemType, complexity, domain);
      if (score > bestScore) {
        bestScore = score;
        bestFramework = framework;
      }
    }
    
    return bestFramework || this.frameworks.get('5w1h'); // 默认框架
  }

  // 评分框架适用性
  scoreFramework(framework, problemType, complexity, domain) {
    let score = 0;
    
    // 基于问题类型评分
    if (framework.applicableTypes.includes(problemType.primary)) {
      score += 0.5;
    }
    
    // 基于复杂度评分
    if (complexity > 3 && framework.steps.length > 4) {
      score += 0.3;
    } else if (complexity <= 3 && framework.steps.length <= 4) {
      score += 0.3;
    }
    
    // 基于领域评分
    if (domain.primary === 'business' && framework.name.includes('SWOT')) {
      score += 0.2;
    } else if (domain.primary === 'creative' && framework.name.includes('设计思维')) {
      score += 0.2;
    }
    
    return score;
  }
}

// 偏见检测器
class BiasDetector {
  constructor() {
    this.biasPatterns = new Map();
    this.initializeBiasPatterns();
  }

  // 初始化偏见模式
  initializeBiasPatterns() {
    this.biasPatterns.set('confirmation_bias', {
      name: '确认偏见',
      patterns: [/总是|一直|肯定|绝对/],
      description: '倾向于寻找支持既有观点的信息',
      severity: 'high'
    });
    
    this.biasPatterns.set('anchoring_bias', {
      name: '锚定偏见',
      patterns: [/第一|最初|开始时/],
      description: '过度依赖最初获得的信息',
      severity: 'medium'
    });
    
    this.biasPatterns.set('availability_bias', {
      name: '可得性偏见',
      patterns: [/最近|刚刚|听说/],
      description: '基于容易回忆的信息做判断',
      severity: 'medium'
    });
  }

  // 初始化模型
  async initializeModels() {
    console.log('🔍 初始化偏见检测模型');
    return true;
  }

  // 检测偏见
  async detectBiases(problem, enhancedInfo, context) {
    const detectedBiases = [];
    
    for (const [type, biasInfo] of this.biasPatterns.entries()) {
      const confidence = this.detectBiasType(problem, biasInfo);
      if (confidence > 0.3) {
        detectedBiases.push({
          type,
          name: biasInfo.name,
          confidence,
          description: biasInfo.description,
          severity: biasInfo.severity
        });
      }
    }
    
    return detectedBiases;
  }

  // 检测特定偏见类型
  detectBiasType(problem, biasInfo) {
    let confidence = 0;
    
    for (const pattern of biasInfo.patterns) {
      const matches = (problem.match(pattern) || []).length;
      confidence += matches * 0.2;
    }
    
    return Math.min(confidence, 1);
  }

  // 生成纠正建议
  async generateCorrection(bias, problem, enhancedInfo) {
    const corrections = {
      confirmation_bias: {
        type: 'confirmation_bias',
        correction: '寻找反对观点和证据',
        counterArguments: ['考虑相反的可能性', '寻找不支持的证据'],
        action: '主动寻找挑战现有观点的信息'
      },
      anchoring_bias: {
        type: 'anchoring_bias',
        correction: '考虑多个参考点',
        alternativeAnchors: ['行业平均水平', '历史数据', '竞争对手情况'],
        action: '从多个角度设定基准点'
      },
      availability_bias: {
        type: 'availability_bias',
        correction: '收集统计数据',
        statisticalEvidence: ['行业统计', '历史趋势', '大样本数据'],
        action: '基于数据而非印象做决策'
      }
    };
    
    return corrections[bias.type] || {
      type: bias.type,
      correction: '保持客观和批判性思维',
      action: '多角度验证信息'
    };
  }
}

// 创造力激发器
class CreativityStimulator {
  constructor() {
    this.techniques = new Map();
    this.initializeTechniques();
  }

  // 初始化创造性技法
  initializeTechniques() {
    this.techniques.set('brainstorming', {
      name: '头脑风暴',
      description: '自由联想产生大量想法',
      applicability: ['creative', 'innovation']
    });
    
    this.techniques.set('scamper', {
      name: 'SCAMPER技法',
      description: '通过七种思维方式激发创意',
      applicability: ['creative', 'problem_solving']
    });
    
    this.techniques.set('six_hats', {
      name: '六顶思考帽',
      description: '从六个不同角度思考问题',
      applicability: ['analytical', 'decision_making']
    });
  }

  // 初始化
  async initialize() {
    console.log('🎨 初始化创造力激发器');
    return true;
  }

  // 选择技法
  async selectTechniques(problem, structuredThoughts) {
    const selectedTechniques = [];
    
    // 根据问题特征选择技法
    if (this.needsCreativeThinking(problem)) {
      selectedTechniques.push(this.techniques.get('brainstorming'));
      selectedTechniques.push(this.techniques.get('scamper'));
    }
    
    if (this.needsMultiplePerspectives(problem)) {
      selectedTechniques.push(this.techniques.get('six_hats'));
    }
    
    return selectedTechniques.length > 0 ? selectedTechniques : [this.techniques.get('brainstorming')];
  }

  // 判断是否需要创造性思维
  needsCreativeThinking(problem) {
    const creativeKeywords = ['创新', '新', '突破', '改进', '优化'];
    return creativeKeywords.some(keyword => problem.includes(keyword));
  }

  // 判断是否需要多角度思考
  needsMultiplePerspectives(problem) {
    const complexityKeywords = ['复杂', '多方面', '综合', '全面'];
    return complexityKeywords.some(keyword => problem.includes(keyword));
  }

  // 应用技法
  async applyTechnique(technique, problem, structuredThoughts) {
    const result = {
      technique: technique.name,
      ideas: [],
      effectiveness: 0
    };
    
    switch (technique.name) {
      case '头脑风暴':
        result.ideas = this.applyBrainstorming(problem);
        break;
      case 'SCAMPER技法':
        result.ideas = this.applySCAMPER(problem);
        break;
      case '六顶思考帽':
        result.ideas = this.applySixHats(problem);
        break;
    }
    
    result.effectiveness = this.assessEffectiveness(result.ideas);
    return result;
  }

  // 应用头脑风暴
  applyBrainstorming(problem) {
    const ideas = [];
    const keywords = this.extractKeywords(problem);
    
    for (const keyword of keywords.slice(0, 3)) {
      ideas.push({
        description: `基于${keyword}的创新想法`,
        novelty: Math.random() * 0.5 + 0.5,
        feasibility: Math.random() * 0.4 + 0.6,
        source: 'brainstorming'
      });
    }
    
    return ideas;
  }

  // 应用SCAMPER技法
  applySCAMPER(problem) {
    const ideas = [];
    const scamperActions = [
      { action: 'Substitute', description: '替换关键要素' },
      { action: 'Combine', description: '组合不同方法' },
      { action: 'Adapt', description: '适应其他做法' },
      { action: 'Modify', description: '修改现有方案' }
    ];
    
    for (const scamper of scamperActions) {
      ideas.push({
        description: `${scamper.action}: ${scamper.description}`,
        novelty: Math.random() * 0.6 + 0.4,
        feasibility: Math.random() * 0.5 + 0.5,
        disruptive: Math.random() > 0.7,
        impact: Math.random() * 0.4 + 0.6,
        source: 'scamper'
      });
    }
    
    return ideas;
  }

  // 应用六顶思考帽
  applySixHats(problem) {
    const ideas = [];
    const hats = [
      { color: '白帽', focus: '客观事实', description: '基于事实的分析' },
      { color: '红帽', focus: '情感直觉', description: '基于直觉的想法' },
      { color: '黑帽', focus: '批判思维', description: '识别潜在问题' },
      { color: '黄帽', focus: '积极思维', description: '寻找积极方面' }
    ];
    
    for (const hat of hats) {
      ideas.push({
        description: `${hat.color}思维: ${hat.description}`,
        perspective: hat.focus,
        novelty: Math.random() * 0.4 + 0.3,
        feasibility: Math.random() * 0.3 + 0.7,
        source: 'six_hats'
      });
    }
    
    return ideas;
  }

  // 评估效果
  assessEffectiveness(ideas) {
    if (ideas.length === 0) return 0;
    
    const avgNovelty = ideas.reduce((sum, idea) => sum + (idea.novelty || 0.5), 0) / ideas.length;
    const avgFeasibility = ideas.reduce((sum, idea) => sum + (idea.feasibility || 0.5), 0) / ideas.length;
    
    return (avgNovelty + avgFeasibility) / 2;
  }

  // 提取关键词
  extractKeywords(text) {
    return text.toLowerCase()
      .replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s]/g, '')
      .split(/\s+/)
      .filter(word => word.length > 1)
      .slice(0, 5);
  }
}

// 决策支持引擎
class DecisionSupportEngine {
  constructor() {
    this.rules = new Map();
    this.criteria = [];
  }

  // 加载规则
  async loadRules() {
    console.log('⚖️ 加载决策支持规则');
    
    // 初始化决策规则
    this.rules.set('multi_criteria', {
      name: '多标准决策分析',
      method: 'weighted_sum',
      description: '基于加权求和的多标准决策'
    });
    
    return true;
  }

  // 分析决策
  async analyze(alternatives, criteria, problem) {
    const analysis = {
      method: 'multi_criteria_analysis',
      alternatives,
      criteria,
      scores: new Map(),
      rankings: []
    };
    
    // 为每个备选方案评分
    for (const alternative of alternatives) {
      const scores = this.scoreAlternative(alternative, criteria);
      analysis.scores.set(alternative.id || alternative.name, scores);
    }
    
    // 排序
    analysis.rankings = this.rankAlternatives(alternatives, analysis.scores);
    
    return analysis;
  }

  // 评分备选方案
  scoreAlternative(alternative, criteria) {
    const scores = {};
    let totalScore = 0;
    
    for (const criterion of criteria) {
      const score = this.scoreByCriterion(alternative, criterion);
      scores[criterion.name] = score;
      totalScore += score * criterion.weight;
    }
    
    scores.total = totalScore;
    return scores;
  }

  // 按标准评分
  scoreByCriterion(alternative, criterion) {
    // 简化的评分逻辑
    const baseScore = alternative.confidence || 0.5;
    
    switch (criterion.name) {
      case '可行性':
        return alternative.feasibility || baseScore;
      case '效果':
        return alternative.impact || alternative.effectiveness || baseScore;
      case '成本':
        return 1 - (alternative.cost || 0.5); // 成本越低分数越高
      case '风险':
        return 1 - (alternative.risk || 0.5); // 风险越低分数越高
      case '时间':
        return 1 - (alternative.duration || 0.5); // 时间越短分数越高
      default:
        return baseScore;
    }
  }

  // 排序备选方案
  rankAlternatives(alternatives, scores) {
    return alternatives
      .map(alt => ({
        alternative: alt,
        score: scores.get(alt.id || alt.name).total
      }))
      .sort((a, b) => b.score - a.score);
  }

  // 生成推荐
  recommend(analysis, context) {
    const topRanked = analysis.rankings[0];
    
    return {
      recommended: topRanked.alternative,
      score: topRanked.score,
      reasoning: `基于多标准分析，该方案获得最高综合得分 ${topRanked.score.toFixed(2)}`,
      confidence: topRanked.score,
      alternatives: analysis.rankings.slice(1, 3) // 备选方案
    };
  }
}

// 使用示例
const aiThinkingSystem = new AIAssistedThinkingSystem();

// 示例：产品创新问题
const innovationProblem = `
我们公司需要开发一款新的智能家居产品，目标是提升用户的生活便利性。
当前市场竞争激烈，用户对隐私保护要求很高，同时成本控制也很重要。
我们有技术团队但缺乏市场经验，需要在6个月内推出产品。
`;

const context = {
  domain: 'technology',
  priority: 'innovation',
  constraints: [
    { type: 'time', severity: 'high', description: '6个月内推出' },
    { type: 'budget', severity: 'medium', description: '成本控制' }
  ]
};

// 启动思维辅助会话
aiThinkingSystem.startThinkingSession('user123', innovationProblem, context)
  .then(session => {
    console.log('🎯 思维辅助会话完成');
    console.log('💡 关键洞察:', session.insights.slice(0, 3));
    console.log('📋 推荐行动:', session.recommendations.slice(0, 3));
    console.log('🎯 最终解决方案:', session.finalSolution.recommendedActions);
  })
  .catch(error => {
    console.error('思维辅助出错:', error.message);
  });

---

🎯 学习检验

理论检验

1. 概念理解：解释AI辅助思维与传统决策支持系统的区别
2. 架构分析：描述AI辅助思维系统的核心组件及其作用
3. 方法对比：比较不同思维框架的适用场景和优缺点

实践检验

1. 系统实现：基于提供的代码框架，实现一个简化的AI辅助思维系统
2. 案例分析：选择一个实际问题，使用AI辅助思维方法进行分析
3. 效果评估：设计指标评估AI辅助思维的效果和价值

应用检验

1. 场景适配：为特定领域（如教育、医疗、金融）定制AI辅助思维方案
2. 工具集成：将AI辅助思维功能集成到现有的业务系统中
3. 用户体验：设计友好的用户界面，提升AI辅助思维的可用性

---

🚀 实践项目建议

初级项目

1. 智能问题分析器：开发能够自动分析问题类型和复杂度的工具
2. 思维框架推荐系统：根据问题特征推荐最适合的思维框架
3. 偏见检测工具：实现能够识别常见认知偏见的检测器

中级项目

1. 多模态决策支持系统：结合文本、图像、数据的综合决策支持
2. 协作思维平台：支持团队协作的AI辅助思维工具
3. 个性化思维助手：基于用户历史和偏好的个性化思维辅助

高级项目

1. 企业级智能决策平台：面向企业的全面AI辅助决策解决方案
2. 跨领域知识整合系统：能够整合多个领域知识的智能思维系统
3. 自适应学习思维引擎：能够从用户反馈中学习和改进的AI思维系统

---

📚 延伸阅读

核心理论

• 《思考，快与慢》- 丹尼尔·卡尼曼
• 《决策与判断》- 斯科特·普劳斯
• 《系统思考》- 彼得·圣吉

技术实现

• 《人工智能：一种现代方法》- 斯图尔特·罗素
• 《机器学习》- 周志华
• 《深度学习》- 伊恩·古德费洛

应用案例

• 《AI赋能：人工智能如何重新定义商业》
• 《智能决策：数据驱动的管理革命》
• 《认知计算：开启智能时代的钥匙》

在线资源

• Coursera: Decision Sciences课程
• edX: Artificial Intelligence课程
• MIT OpenCourseWare: 认知科学课程

---

💡 关键要点：AI辅助思维不是要替代人类思考，而是要增强人类的认知能力，帮助我们更好地分析问题、做出决策。通过系统化的方法和工具，我们可以减少认知偏见，提升思维质量，实现更好的决策效果。