Applications — Network Analysis and Beyond

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

interface SocialNetworkStats {
    totalUsers: number;
    connectedUsers: number;         // Users in components of size > 1
    isolatedUsers: number;          // Users with no connections
    communities: number;            // Number of components
    giantComponentSize: number;     // Largest component
    giantComponentPct: number;      // % of users in giant component
    avgCommunitySize: number;       // Average component size
    reachability: number;           // Fraction of user pairs that can reach each other
}
 
class SocialNetworkAnalyzer {
    private userConnections: Map<string, string[]>;
    private componentId: Map<string, number>;
    private componentSizes: number[];
    
    constructor(connections: [string, string][]) {
        this.userConnections = new Map();
        this.componentId = new Map();
        this.componentSizes = [];
        
        // Build adjacency list
        for (const [user1, user2] of connections) {
            if (!this.userConnections.has(user1)) 
                this.userConnections.set(user1, []);
            if (!this.userConnections.has(user2)) 
                this.userConnections.set(user2, []);
            this.userConnections.get(user1)!.push(user2);
            this.userConnections.get(user2)!.push(user1);
        }
        
        this.computeComponents();
    }
    
    addUser(userId: string): void {
        if (!this.userConnections.has(userId)) {
            this.userConnections.set(userId, []);
        }
    }
    
    private computeComponents(): void {
        let currentComponent = 0;
        
        const dfs = (user: string, compId: number): number => {
            this.componentId.set(user, compId);
            let size = 1;
            
            for (const friend of this.userConnections.get(user) || []) {
                if (!this.componentId.has(friend)) {
                    size += dfs(friend, compId);
                }
            }
            return size;
        };
        
        for (const user of this.userConnections.keys()) {
            if (!this.componentId.has(user)) {
                const size = dfs(user, currentComponent);
                this.componentSizes.push(size);
                currentComponent++;
            }
        }
    }
    
    analyze(): SocialNetworkStats {
        const totalUsers = this.userConnections.size;
        const isolated = this.componentSizes.filter(s => s === 1).length;
        const connected = totalUsers - isolated;
        const giantSize = Math.max(...this.componentSizes, 0);
        
        // Reachability: fraction of pairs in same component
        // = sum of (size choose 2) / (total choose 2)
        let reachablePairs = 0;
        for (const size of this.componentSizes) {
            if (size >= 2) {
                reachablePairs += (size * (size - 1)) / 2;
            }
        }
        const totalPairs = (totalUsers * (totalUsers - 1)) / 2;
        const reachability = totalPairs > 0 ? reachablePairs / totalPairs : 0;
        
        return {
            totalUsers,
            connectedUsers: connected,
            isolatedUsers: isolated,
            communities: this.componentSizes.length,
            giantComponentSize: giantSize,
            giantComponentPct: totalUsers > 0 ? (giantSize / totalUsers) * 100 : 0,
            avgCommunitySize: totalUsers / this.componentSizes.length,
            reachability
        };
    }
    
    canReach(user1: string, user2: string): boolean {
        return this.componentId.get(user1) === this.componentId.get(user2);
    }
    
    getCommunityMembers(userId: string): string[] {
        const compId = this.componentId.get(userId);
        if (compId === undefined) return [];
        
        const members: string[] = [];
        for (const [user, id] of this.componentId.entries()) {
            if (id === compId) members.push(user);
        }
        return members;
    }
    
    getIsolatedUsers(): string[] {
        return Array.from(this.componentId.entries())
            .filter(([user, id]) => 
                this.componentSizes[id] === 1
            )
            .map(([user]) => user);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

interface Region {
    id: number;
    pixels: [number, number][];
    size: number;
    boundingBox: { minRow: number; maxRow: number; minCol: number; maxCol: number };
}
 
/**
 * Find connected components in a binary image
 * Uses 4-connectivity (up, down, left, right)
 */
class ImageSegmenter {
    private image: number[][];
    private rows: number;
    private cols: number;
    private labels: number[][];
    private regions: Region[] = [];
    
    constructor(image: number[][]) {
        this.image = image;
        this.rows = image.length;
        this.cols = image[0]?.length || 0;
        this.labels = Array.from({ length: this.rows }, 
            () => new Array(this.cols).fill(-1));
        this.findComponents();
    }
    
    private findComponents(): void {
        let currentLabel = 0;
        
        for (let row = 0; row < this.rows; row++) {
            for (let col = 0; col < this.cols; col++) {
                // Only process foreground pixels (value 1) that aren't labeled
                if (this.image[row][col] === 1 && this.labels[row][col] === -1) {
                    const pixels = this.bfs(row, col, currentLabel);
                    this.regions.push(this.createRegion(currentLabel, pixels));
                    currentLabel++;
                }
            }
        }
    }
    
    private bfs(startRow: number, startCol: number, label: number): [number, number][] {
        const pixels: [number, number][] = [];
        const queue: [number, number][] = [[startRow, startCol]];
        this.labels[startRow][startCol] = label;
        
        // 4-way connectivity
        const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
        
        while (queue.length > 0) {
            const [row, col] = queue.shift()!;
            pixels.push([row, col]);
            
            for (const [dr, dc] of directions) {
                const newRow = row + dr;
                const newCol = col + dc;
                
                if (this.isValid(newRow, newCol) && 
                    this.image[newRow][newCol] === 1 && 
                    this.labels[newRow][newCol] === -1) {
                    this.labels[newRow][newCol] = label;
                    queue.push([newRow, newCol]);
                }
            }
        }
        
        return pixels;
    }
    
    private isValid(row: number, col: number): boolean {
        return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
    }
    
    private createRegion(id: number, pixels: [number, number][]): Region {
        let minRow = Infinity, maxRow = -Infinity;
        let minCol = Infinity, maxCol = -Infinity;
        
        for (const [row, col] of pixels) {
            minRow = Math.min(minRow, row);
            maxRow = Math.max(maxRow, row);
            minCol = Math.min(minCol, col);
            maxCol = Math.max(maxCol, col);
        }
        
        return {
            id,
            pixels,
            size: pixels.length,
            boundingBox: { minRow, maxRow, minCol, maxCol }
        };
    }
    
    getRegions(): Region[] {
        return this.regions;
    }
    
    getLabeledImage(): number[][] {
        return this.labels;
    }
    
    getRegionCount(): number {
        return this.regions.length;
    }
    
    getLargestRegion(): Region | null {
        return this.regions.reduce<Region | null>((max, region) => 
            !max || region.size > max.size ? region : max, null);
    }
    
    filterBySize(minSize: number): Region[] {
        return this.regions.filter(r => r.size >= minSize);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Example binary image (1 = foreground, 0 = background)
const binaryImage = [
    [0, 1, 1, 0, 0, 0, 1, 1],
    [0, 1, 1, 0, 0, 1, 1, 1],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [1, 1, 0, 0, 1, 1, 1, 0],
    [1, 1, 0, 0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
];
 
const segmenter = new ImageSegmenter(binaryImage);
 
console.log(`Found ${segmenter.getRegionCount()} distinct objects`);
// Output: Found 4 distinct objects
 
for (const region of segmenter.getRegions()) {
    console.log(`Region ${region.id}: ${region.size} pixels, ` +
                                        `bounding box: (${region.boundingBox.minRow},${region.boundingBox.minCol}) to ` +
                                    `(${region.boundingBox.maxRow},${region.boundingBox.maxCol})`);
}
 
// Filter noise (small regions)
const significantRegions = segmenter.filterBySize(3);
console.log(`${significantRegions.length} regions with size >= 3`);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

interface FailureImpact {
    originalComponents: number;
    afterFailure: number;
    isolatedNodes: string[];
    newComponents: string[][];
    criticalLink: boolean;  // Did this link disconnect the network?
}
 
class NetworkReliabilityAnalyzer {
    private network: Map<string, Set<string>>;
    
    constructor(links: [string, string][]) {
        this.network = new Map();
        for (const [node1, node2] of links) {
            if (!this.network.has(node1)) this.network.set(node1, new Set());
            if (!this.network.has(node2)) this.network.set(node2, new Set());
            this.network.get(node1)!.add(node2);
            this.network.get(node2)!.add(node1);
        }
    }
    
    isFullyConnected(): boolean {
        return this.countComponents() === 1;
    }
    
    countComponents(): number {
        const visited = new Set<string>();
        let count = 0;
        
        for (const node of this.network.keys()) {
            if (!visited.has(node)) {
                this.dfs(node, visited);
                count++;
            }
        }
        
        return count;
    }
    
    private dfs(node: string, visited: Set<string>): void {
        visited.add(node);
        for (const neighbor of this.network.get(node) || []) {
            if (!visited.has(neighbor)) {
                this.dfs(neighbor, visited);
            }
        }
    }
    
    // Analyze impact of removing a specific link
    simulateLinkFailure(node1: string, node2: string): FailureImpact {
        const originalComponents = this.countComponents();
        
        // Temporarily remove the link
        this.network.get(node1)?.delete(node2);
        this.network.get(node2)?.delete(node1);
        
        // Analyze new state
        const newComponentCount = this.countComponents();
        const components = this.getAllComponents();
        
        // Find isolated nodes (in components without critical services)
        const isolatedNodes = components
            .filter(c => c.length === 1)
            .map(c => c[0]);
        
        // Restore the link
        this.network.get(node1)?.add(node2);
        this.network.get(node2)?.add(node1);
        
        return {
            originalComponents,
            afterFailure: newComponentCount,
            isolatedNodes,
            newComponents: components,
            criticalLink: newComponentCount > originalComponents
        };
    }
    
    // Find all links whose removal would disconnect the network
    findCriticalLinks(): [string, string][] {
        const criticalLinks: [string, string][] = [];
        const visited = new Set<string>();
        
        for (const [node, neighbors] of this.network) {
            for (const neighbor of neighbors) {
                const linkKey = [node, neighbor].sort().join('-');
                if (visited.has(linkKey)) continue;
                visited.add(linkKey);
                
                const impact = this.simulateLinkFailure(node, neighbor);
                if (impact.criticalLink) {
                    criticalLinks.push([node, neighbor]);
                }
            }
        }
        
        return criticalLinks;
    }
    
    private getAllComponents(): string[][] {
        const visited = new Set<string>();
        const components: string[][] = [];
        
        for (const node of this.network.keys()) {
            if (!visited.has(node)) {
                const component: string[] = [];
                this.dfsCollect(node, visited, component);
                components.push(component);
            }
        }
        
        return components;
    }
    
    private dfsCollect(node: string, visited: Set<string>, component: string[]): void {
        visited.add(node);
        component.push(node);
        for (const neighbor of this.network.get(node) || []) {
            if (!visited.has(neighbor)) {
                this.dfsCollect(neighbor, visited, component);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Data center network topology
const datacenterLinks: [string, string][] = [
    ['router-main', 'switch-1'],
    ['router-main', 'switch-2'],
    ['switch-1', 'server-a'],
    ['switch-1', 'server-b'],
    ['switch-2', 'server-c'],
    ['switch-2', 'server-d'],
    ['switch-1', 'switch-2'],  // Redundant link
];
 
const analyzer = new NetworkReliabilityAnalyzer(datacenterLinks);
 
console.log(`Network connected: ${analyzer.isFullyConnected()}`);
// Output: Network connected: true
 
const criticalLinks = analyzer.findCriticalLinks();
console.log(`Critical links (removal disconnects network):`);
for (const [a, b] of criticalLinks) {
    console.log(`  ${a} <-> ${b}`);
}
// Critical links depend on topology - main router links are typically critical
 
// What if the router-main to switch-1 link fails?
const impact = analyzer.simulateLinkFailure('router-main', 'switch-1');
console.log(`Link failure impact:`);
console.log(`  Components after: ${impact.afterFailure}`);
console.log(`  Critical link: ${impact.criticalLink}`);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

interface QueryComponent {
    tables: string[];
    joins: [string, string][];
    canExecuteIndependently: boolean;
}
 
class QueryOptimizer {
    /**
     * Analyze a query's join graph to find independent subqueries
     */
    static analyzeJoinGraph(
        tables: string[],
        joinConditions: [string, string][]
    ): QueryComponent[] {
        // Build adjacency list
        const graph = new Map<string, string[]>();
        for (const table of tables) {
            graph.set(table, []);
        }
        for (const [t1, t2] of joinConditions) {
            graph.get(t1)?.push(t2);
            graph.get(t2)?.push(t1);
        }
        
        // Find connected components
        const tableToComponent = new Map<string, number>();
        const components: QueryComponent[] = [];
        let compId = 0;
        
        const dfs = (table: string, componentTables: string[]): void => {
            tableToComponent.set(table, compId);
            componentTables.push(table);
            for (const neighbor of graph.get(table) || []) {
                if (!tableToComponent.has(neighbor)) {
                    dfs(neighbor, componentTables);
                }
            }
        };
        
        for (const table of tables) {
            if (!tableToComponent.has(table)) {
                const componentTables: string[] = [];
                dfs(table, componentTables);
                
                // Get joins within this component
                const componentJoins = joinConditions.filter(
                    ([t1, t2]) => tableToComponent.get(t1) === compId &&
                                 tableToComponent.get(t2) === compId
                );
                
                components.push({
                    tables: componentTables,
                    joins: componentJoins,
                    canExecuteIndependently: true
                });
                
                compId++;
            }
        }
        
        return components;
    }
    
    /**
     * Find equivalence classes in equality conditions
     * e.g., a.x = b.y AND b.y = c.z => {a.x, b.y, c.z} are equivalent
     */
    static findEquivalenceClasses(
        equalityConditions: [string, string][]
    ): string[][] {
        const graph = new Map<string, string[]>();
        const allColumns = new Set<string>();
        
        for (const [col1, col2] of equalityConditions) {
            allColumns.add(col1);
            allColumns.add(col2);
            if (!graph.has(col1)) graph.set(col1, []);
            if (!graph.has(col2)) graph.set(col2, []);
            graph.get(col1)!.push(col2);
            graph.get(col2)!.push(col1);
        }
        
        const visited = new Set<string>();
        const equivalenceClasses: string[][] = [];
        
        const dfs = (col: string, eqClass: string[]): void => {
            visited.add(col);
            eqClass.push(col);
            for (const equiv of graph.get(col) || []) {
                if (!visited.has(equiv)) {
                    dfs(equiv, eqClass);
                }
            }
        };
        
        for (const col of allColumns) {
            if (!visited.has(col)) {
                const eqClass: string[] = [];
                dfs(col, eqClass);
                equivalenceClasses.push(eqClass);
            }
        }
        
        return equivalenceClasses;
    }
}
 
// Example: Analyze a complex query
const tables = ['users', 'orders', 'items', 'categories', 'logs', 'metrics'];
const joins: [string, string][] = [
    ['users', 'orders'],
    ['orders', 'items'],
    ['items', 'categories'],
    ['logs', 'metrics'],  // Independent subquery!
];
 
const components = QueryOptimizer.analyzeJoinGraph(tables, joins);
console.log(`Query has ${components.length} independent components`);
// Output: Query has 2 independent components
// Component 1: users-orders-items-categories
// Component 2: logs-metrics

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

interface Match {
    color: string;
    cells: [number, number][];
    size: number;
}
 
class Match3Detector {
    private grid: string[][];
    private rows: number;
    private cols: number;
    
    constructor(grid: string[][]) {
        this.grid = grid;
        this.rows = grid.length;
        this.cols = grid[0]?.length || 0;
    }
    
    /**
     * Find all groups of 3+ connected same-colored pieces
     */
    findMatches(minSize: number = 3): Match[] {
        const visited: boolean[][] = Array.from({ length: this.rows },
            () => new Array(this.cols).fill(false));
        const matches: Match[] = [];
        
        for (let row = 0; row < this.rows; row++) {
            for (let col = 0; col < this.cols; col++) {
                if (!visited[row][col] && this.grid[row][col] !== '.') {
                    const color = this.grid[row][col];
                    const cells = this.bfsCollect(row, col, color, visited);
                    
                    if (cells.length >= minSize) {
                        matches.push({ color, cells, size: cells.length });
                    }
                }
            }
        }
        
        return matches;
    }
    
    private bfsCollect(
        startRow: number,
        startCol: number,
        color: string,
        visited: boolean[][]
    ): [number, number][] {
        const cells: [number, number][] = [];
        const queue: [number, number][] = [[startRow, startCol]];
        visited[startRow][startCol] = true;
        
        const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
        
        while (queue.length > 0) {
            const [row, col] = queue.shift()!;
            cells.push([row, col]);
            
            for (const [dr, dc] of directions) {
                const newRow = row + dr;
                const newCol = col + dc;
                
                if (this.isValid(newRow, newCol) &&
                    !visited[newRow][newCol] &&
                    this.grid[newRow][newCol] === color) {
                    visited[newRow][newCol] = true;
                    queue.push([newRow, newCol]);
                }
            }
        }
        
        return cells;
    }
    
    private isValid(row: number, col: number): boolean {
        return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
    }
    
    /**
     * Remove matched cells and let pieces fall
     */
    applyGravity(): void {
        for (let col = 0; col < this.cols; col++) {
            // Collect non-empty cells in this column
            const pieces: string[] = [];
            for (let row = this.rows - 1; row >= 0; row--) {
                if (this.grid[row][col] !== '.') {
                    pieces.push(this.grid[row][col]);
                }
            }
            
            // Place them at the bottom
            for (let row = this.rows - 1; row >= 0; row--) {
                const pieceIndex = this.rows - 1 - row;
                this.grid[row][col] = pieceIndex < pieces.length ? pieces[pieceIndex] : '.';
            }
        }
    }
    
    removeMatches(matches: Match[]): void {
        for (const match of matches) {
            for (const [row, col] of match.cells) {
                this.grid[row][col] = '.';
            }
        }
    }
}
 
// Example game grid
const gameGrid = [
    ['R', 'B', 'R', 'R'],
    ['R', 'R', 'B', 'G'],
    ['G', 'R', 'G', 'G'],
    ['G', 'G', 'R', 'G'],
];
 
const detector = new Match3Detector(gameGrid);
const matches = detector.findMatches(3);
 
console.log(`Found ${matches.length} matches:`);
for (const match of matches) {
    console.log(`  ${match.color}: ${match.size} pieces at ${JSON.stringify(match.cells)}`);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

interface ProteinComplex {
    id: number;
    proteins: string[];
    size: number;
    averageInteractionScore: number;
}
 
class ProteinInteractionAnalyzer {
    private network: Map<string, Map<string, number>>;  // protein -> neighbor -> score
    
    constructor(interactions: [string, string, number][]) {
        this.network = new Map();
        
        for (const [protein1, protein2, score] of interactions) {
            if (!this.network.has(protein1)) 
                this.network.set(protein1, new Map());
            if (!this.network.has(protein2)) 
                this.network.set(protein2, new Map());
            this.network.get(protein1)!.set(protein2, score);
            this.network.get(protein2)!.set(protein1, score);
        }
    }
    
    /**
     * Find protein complexes (connected components with score threshold)
     */
    findComplexes(minInteractionScore: number = 0): ProteinComplex[] {
        const visited = new Set<string>();
        const complexes: ProteinComplex[] = [];
        let complexId = 0;
        
        for (const protein of this.network.keys()) {
            if (!visited.has(protein)) {
                const complex = this.bfsComplex(protein, minInteractionScore, visited);
                if (complex.proteins.length > 0) {
                    complex.id = complexId++;
                    complexes.push(complex);
                }
            }
        }
        
        return complexes;
    }
    
    private bfsComplex(
        start: string,
        minScore: number,
        visited: Set<string>
    ): ProteinComplex {
        const proteins: string[] = [];
        const queue: string[] = [start];
        visited.add(start);
        let totalScore = 0;
        let edgeCount = 0;
        
        while (queue.length > 0) {
            const protein = queue.shift()!;
            proteins.push(protein);
            
            for (const [neighbor, score] of this.network.get(protein) || []) {
                if (score >= minScore) {
                    totalScore += score;
                    edgeCount++;
                    
                    if (!visited.has(neighbor)) {
                        visited.add(neighbor);
                        queue.push(neighbor);
                    }
                }
            }
        }
        
        return {
            id: 0,
            proteins,
            size: proteins.length,
            averageInteractionScore: edgeCount > 0 ? totalScore / edgeCount : 0
        };
    }
    
    /**
     * Find potential drug targets
     * Proteins in large complexes with high connectivity are often essential
     */  
    findEssentialProteins(): string[] {
        const complexes = this.findComplexes(0.5);
        const essentials: string[] = [];
        
        for (const complex of complexes) {
            if (complex.size >= 5) {
                // Find hub proteins (high degree within complex)
                const maxConnections = Math.max(
                    ...complex.proteins.map(p => 
                        this.network.get(p)?.size || 0
                    )
                );
                
                for (const protein of complex.proteins) {
                    if ((this.network.get(protein)?.size || 0) === maxConnections) {
                        essentials.push(protein);
                    }
                }
            }
        }
        
        return essentials;
    }
}
 
// Example: Yeast protein interactions (simplified)
const interactions: [string, string, number][] = [
    ['CDC28', 'CLB1', 0.9],
    ['CDC28', 'CLB2', 0.9],
    ['CLB1', 'CLB2', 0.7],
    ['ACT1', 'ARP2', 0.8],
    ['ACT1', 'ARP3', 0.8],
    ['ARP2', 'ARP3', 0.9],
    ['MDH1', 'MDH2', 0.6],  // Separate complex
];
 
const analyzer = new ProteinInteractionAnalyzer(interactions);
const complexes = analyzer.findComplexes(0.5);
 
console.log(`Found ${complexes.length} protein complexes`);
for (const complex of complexes) {
    console.log(`  Complex ${complex.id}: ${complex.proteins.join(', ')}`);
}