discoverImplicitPatterns method

List<Pattern> discoverImplicitPatterns()

Discovers implicit patterns: clusters of highly interconnected concepts.

Uses a simple density-based heuristic — groups of ≥ 3 nodes where every pair has at least one path of length ≤ 2.

Implementation

List<Pattern> discoverImplicitPatterns() {
  final patterns = <Pattern>[];
  final nodes = _nodes.values.toList();
  final visited = <String>{};

  for (final node in nodes) {
    if (visited.contains(node.id)) continue;

    final cluster = [node.id];
    final neighbors = findRelatedConcepts(node.id, 2)
        .map((n) => n.id)
        .take(6)
        .toList();

    for (final neighbor in neighbors) {
      // Check if this neighbor is also connected back (bidirectional cluster)
      final backNeighbors =
          findRelatedConcepts(neighbor, 1).map((n) => n.id).toSet();
      if (backNeighbors.contains(node.id) ||
          backNeighbors.intersection(cluster.toSet()).isNotEmpty) {
        cluster.add(neighbor);
      }
    }

    if (cluster.length >= 3) {
      final conceptNames = cluster
          .map((id) => _nodes[id]?.concept.content ?? id)
          .take(5)
          .join(', ');
      patterns.add(Pattern(
        id: _uuid.v4(),
        description: 'Conceptual cluster: $conceptNames',
        involvedConceptIds: cluster,
        confidence: math.min(1.0, cluster.length / 10.0),
      ));
      visited.addAll(cluster);
    }
  }

  _logger.debug('Discovered ${patterns.length} implicit pattern(s)');
  return patterns;
}