diff --git a/analysis.py b/analysis.py
new file mode 100644
index 0000000..ad66524
--- /dev/null
+++ b/analysis.py
@@ -0,0 +1,125 @@
+## Student
+## NetID
+## COMP 182 Homework 4 Problem 3 - Analysis
+
+import random
+import comp182
+import provided
+from autograder import compute_largest_cc_size
+
+
+def random_attack(g):
+    """
+    Perform a random attack on graph g by removing nodes one at a time
+    in a random order.
+
+    Arguments:
+    g -- undirected graph (will be modified in place)
+
+    Returns:
+    A dictionary mapping number_of_nodes_removed -> largest_cc_size,
+    with an entry before any removal (key 0) through removal of all nodes.
+    """
+    result = {}
+    nodes = list(g.keys())
+    random.shuffle(nodes)
+
+    for num_removed, node in enumerate(nodes):
+        result[num_removed] = compute_largest_cc_size(g)
+        # Remove the node and all its edges
+        for neighbor in list(g[node]):
+            g[neighbor].discard(node)
+        del g[node]
+
+    # Record the final state (all nodes removed)
+    result[len(nodes)] = 0
+    return result
+
+
+def targeted_attack(g):
+    """
+    Perform a targeted attack on graph g by removing nodes one at a time
+    in decreasing order of degree (highest degree first).
+
+    Arguments:
+    g -- undirected graph (will be modified in place)
+
+    Returns:
+    A dictionary mapping number_of_nodes_removed -> largest_cc_size,
+    with an entry before any removal (key 0) through removal of all nodes.
+    """
+    result = {}
+    n = len(g)
+
+    for num_removed in range(n):
+        result[num_removed] = compute_largest_cc_size(g)
+        # Find the node with the highest degree
+        max_node = max(g.keys(), key=lambda node: len(g[node]))
+        # Remove the node and all its edges
+        for neighbor in list(g[max_node]):
+            g[neighbor].discard(max_node)
+        del g[max_node]
+
+    result[n] = 0
+    return result
+
+
+def main():
+    # Load the real ISP network graph
+    real_graph = comp182.read_graph('rf7.repr')
+    n = len(real_graph)
+    m = provided.total_degree(real_graph) // 2
+    avg_degree = 2 * m / n
+
+    print("Real graph: n={}, m={}, avg_degree={:.2f}".format(n, m, avg_degree))
+
+    # Build Erdos-Renyi graph with same n and approximately same number of edges
+    # Expected edges in G(n,p) = p * n*(n-1)/2, so p = 2m / (n*(n-1))
+    p = 2 * m / (n * (n - 1))
+    er_graph = provided.erdos_renyi(n, p)
+    er_m = provided.total_degree(er_graph) // 2
+    print("ER graph: n={}, m={}, p={:.6f}".format(len(er_graph), er_m, p))
+
+    # Build UPA graph with same n and approximately same average degree
+    # In upa(n, m_param), each new node attaches to m_param nodes.
+    # Average degree ≈ avg_degree, so m_param ≈ avg_degree / 2
+    m_param = max(1, round(avg_degree / 2))
+    upa_graph = provided.upa(n, m_param)
+    upa_m = provided.total_degree(upa_graph) // 2
+    print("UPA graph: n={}, m={}, m_param={}".format(len(upa_graph), upa_m, m_param))
+
+    # Run random attacks on copies of all three graphs
+    real_random = random_attack(comp182.copy_graph(real_graph))
+    er_random = random_attack(comp182.copy_graph(er_graph))
+    upa_random = random_attack(comp182.copy_graph(upa_graph))
+
+    # Run targeted attacks on copies of all three graphs
+    real_targeted = targeted_attack(comp182.copy_graph(real_graph))
+    er_targeted = targeted_attack(comp182.copy_graph(er_graph))
+    upa_targeted = targeted_attack(comp182.copy_graph(upa_graph))
+
+    # Plot random attack results
+    comp182.plot_lines(
+        [real_random, er_random, upa_random],
+        "Random Attack: Largest Connected Component Size",
+        "Number of Nodes Removed",
+        "Largest CC Size",
+        ["Real Network (rf7)", "Erdos-Renyi", "UPA"],
+        "random_attack.png"
+    )
+
+    # Plot targeted attack results
+    comp182.plot_lines(
+        [real_targeted, er_targeted, upa_targeted],
+        "Targeted Attack: Largest Connected Component Size",
+        "Number of Nodes Removed",
+        "Largest CC Size",
+        ["Real Network (rf7)", "Erdos-Renyi", "UPA"],
+        "targeted_attack.png"
+    )
+
+    print("Plots saved to random_attack.png and targeted_attack.png")
+
+
+if __name__ == "__main__":
+    main()

diff --git a/autograder.py b/autograder.py
new file mode 100644
index 0000000..3cd56da
--- /dev/null
+++ b/autograder.py
@@ -0,0 +1,40 @@
+## Student
+## NetID
+## COMP 182 Homework 4 Problem 3
+
+from collections import deque
+
+
+def compute_largest_cc_size(g: dict) -> int:
+    """
+    Compute the size of the largest connected component in graph g.
+
+    Arguments:
+    g -- undirected graph represented as a dictionary where keys are nodes
+         and values are sets of neighbors
+
+    Returns:
+    The size (number of nodes) of the largest connected component in g.
+    """
+    visited = set()
+    max_size = 0
+
+    for node in g:
+        if node not in visited:
+            # BFS to explore the connected component containing node
+            queue = deque([node])
+            visited.add(node)
+            size = 0
+
+            while queue:
+                curr = queue.popleft()
+                size += 1
+                for neighbor in g[curr]:
+                    if neighbor not in visited:
+                        visited.add(neighbor)
+                        queue.append(neighbor)
+
+            if size > max_size:
+                max_size = size
+
+    return max_size

diff --git a/writeup.md b/writeup.md
index e24fecc..11c9318 100644
--- a/writeup.md
+++ b/writeup.md
@@ -1,9 +1,464 @@
-# COMP182 Homework 4
+# COMP 182 Homework 4: Graphs and Their Exploration
 
-## Student Responses
+---
 
-<!-- Write your solutions below. Add sections for each problem as needed. -->
-<!-- Use proper mathematical notation where applicable. -->
+## Problem 1: Growth of Functions, Algorithms, and Summations
 
-[Your solutions here]
+### Growth of Functions
 
+**A. Show that 1^k + 2^k + ... + n^k = O(n^(k+1))**
+
+We need constants C > 0 and n_0 such that for all n >= n_0:
+
+    sum_{i=1}^{n} i^k <= C * n^(k+1)
+
+Since i <= n for every term in the sum, we have i^k <= n^k. Therefore:
+
+    sum_{i=1}^{n} i^k <= sum_{i=1}^{n} n^k = n * n^k = n^(k+1)
+
+Taking C = 1 and n_0 = 1, we have shown that for all n >= 1:
+
+    1^k + 2^k + ... + n^k <= n^(k+1)
+
+Therefore 1^k + 2^k + ... + n^k = O(n^(k+1)). ∎
+
+---
+
+**B. Show that for a > 1 and b > 1: if f(x) = O(log_b x), then f(x) = O(log_a x)**
+
+By the change of base formula:
+
+    log_b x = log_a x / log_a b
+
+Since f(x) = O(log_b x), there exist constants C > 0 and x_0 such that for all x >= x_0:
+
+    |f(x)| <= C * log_b x = C * (log_a x / log_a b) = (C / log_a b) * log_a x
+
+Since a > 1 and b > 1, we have log_a b > 0 (a finite positive constant). Let C' = C / log_a b. Then for all x >= x_0:
+
+    |f(x)| <= C' * log_a x
+
+Therefore f(x) = O(log_a x). ∎
+
+---
+
+**C. Show that log(x^2 + 1) and log(x) are of the same order (Theta)**
+
+We must show log(x^2 + 1) = Θ(log x), i.e., find positive constants c_1, c_2 and x_0 such that for all x >= x_0:
+
+    c_1 * log x <= log(x^2 + 1) <= c_2 * log x
+
+**Lower bound:** For x >= 1, we have x^2 + 1 >= x^2, so:
+
+    log(x^2 + 1) >= log(x^2) = 2 log x
+
+This gives c_1 = 2.
+
+**Upper bound:** For x >= 1, we have x^2 + 1 <= x^2 + x^2 = 2x^2, so:
+
+    log(x^2 + 1) <= log(2x^2) = log 2 + 2 log x
+
+For x >= 2, log x >= log 2 > 0, so log 2 <= log x. Therefore:
+
+    log(x^2 + 1) <= log 2 + 2 log x <= log x + 2 log x = 3 log x
+
+This gives c_2 = 3.
+
+Combining for all x >= 2:
+
+    2 log x <= log(x^2 + 1) <= 3 log x
+
+Therefore log(x^2 + 1) = Θ(log x). ∎
+
+---
+
+**D. Prove that f(x) = Θ(g(x)) and g(x) = Θ(h(x)) implies f(x) = Θ(h(x))**
+
+Since f(x) = Θ(g(x)), there exist constants c_1, c_2 > 0 and x_1 such that for all x >= x_1:
+
+    c_1 * g(x) <= f(x) <= c_2 * g(x)
+
+Since g(x) = Θ(h(x)), there exist constants c_3, c_4 > 0 and x_2 such that for all x >= x_2:
+
+    c_3 * h(x) <= g(x) <= c_4 * h(x)
+
+Let x_0 = max(x_1, x_2). For all x >= x_0, both bounds hold simultaneously. Therefore:
+
+**Upper bound:**
+
+    f(x) <= c_2 * g(x) <= c_2 * c_4 * h(x)
+
+**Lower bound:**
+
+    f(x) >= c_1 * g(x) >= c_1 * c_3 * h(x)
+
+So for all x >= x_0:
+
+    (c_1 c_3) * h(x) <= f(x) <= (c_2 c_4) * h(x)
+
+Since c_1, c_2, c_3, c_4 > 0, both (c_1 c_3) and (c_2 c_4) are positive constants. Therefore f(x) = Θ(h(x)). ∎
+
+---
+
+**E. Arrange the functions in increasing order of growth**
+
+The functions are: 2^(100n), 2^(n^2), 2^(n!), 2^(2^n), n^(log n), n log n log log n, n^(3/2), n(log n)^(3/2), n^(4/3)(log n)^2
+
+Ordered from slowest to fastest growth:
+
+1. **n log n log log n**
+2. **n(log n)^(3/2)**
+3. **n^(4/3)(log n)^2**
+4. **n^(3/2)**
+5. **n^(log n)**
+6. **2^(100n)**
+7. **2^(n^2)**
+8. **2^(2^n)**
+9. **2^(n!)**
+
+**Justification:**
+
+Let log denote log base 2 throughout.
+
+- **n log n log log n vs n(log n)^(3/2):** The ratio is (log n)^(3/2) / (log n · log log n) = (log n)^(1/2) / log log n → ∞, so the second is larger.
+
+- **n(log n)^(3/2) vs n^(4/3)(log n)^2:** The ratio is n(log n)^(3/2) / (n^(4/3)(log n)^2) = 1 / (n^(1/3)(log n)^(1/2)) → 0, so the third is larger.
+
+- **n^(4/3)(log n)^2 vs n^(3/2):** The ratio is (log n)^2 / n^(1/6) → 0, so the fourth is larger.
+
+- **n^(3/2) vs n^(log n):** For n >= 4, log n >= 2 > 3/2, so n^(log n) > n^(3/2), and as n grows, log n → ∞, so n^(log n) dominates.
+
+- **n^(log n) vs 2^(100n):** We write n^(log n) = 2^((log n)^2). Since (log n)^2 = o(100n), we have n^(log n) = o(2^(100n)).
+
+- **2^(100n) vs 2^(n^2):** Since 100n = o(n^2), we have 2^(100n) = o(2^(n^2)).
+
+- **2^(n^2) vs 2^(2^n):** Since n^2 = o(2^n), we have 2^(n^2) = o(2^(2^n)).
+
+- **2^(2^n) vs 2^(n!):** Since 2^n = o(n!) by Stirling's approximation (n! ≈ √(2πn)(n/e)^n grows superexponentially), we have 2^(2^n) = o(2^(n!)).
+
+Therefore the ordering is: each function in the list is O of the next function. ∎
+
+---
+
+### Algorithms and Their Complexity
+
+**A. Pseudo-code for Algorithm ComputeNumberOfShortestPaths**
+
+The theorem from Section 10.4 states that the (i,j) entry of A^k gives the number of paths of length exactly k from node i to node j in a graph with adjacency matrix A.
+
+**Key idea:** The number of shortest paths from i to j that pass through edge e = (u, v) equals:
+
+- The number of shortest paths i → u of length d(i,u), times the number of shortest paths v → j of length d(v,j), **if** d(i,u) + 1 + d(v,j) = d(i,j) (paths going through e in the direction u→v)
+
+PLUS
+
+- The number of shortest paths i → v of length d(i,v), times the number of shortest paths u → j of length d(u,j), **if** d(i,v) + 1 + d(u,j) = d(i,j) (paths going through e in the direction v→u, since the graph is undirected)
+
+```
+Algorithm ComputeNumberOfShortestPaths(A, g, i, j, e):
+  Input: Adjacency matrix A of graph g with nodes 0..n-1;
+         nodes i, j in g; edge e = (u, v) in g
+  Output: Number of shortest paths from i to j through e
+
+  n <- number of rows/columns in A
+  u, v <- endpoints of edge e
+
+  // Step 1: Compute matrix powers A^1, A^2, ..., A^(n-1)
+  power[1] <- A
+  for k = 2 to n-1 do
+      power[k] <- MatrixMultiplication(power[k-1], A)
+
+  // Step 2: Find d(i,j) = shortest distance from i to j
+  d_ij <- infinity
+  for k = 1 to n-1 do
+      if power[k][i][j] > 0 then
+          d_ij <- k
+          break
+
+  if d_ij = infinity then
+      return 0   // i and j are not connected
+
+  // Step 3: Find distances d(i,u), d(v,j), d(i,v), d(u,j)
+  d_iu <- infinity; d_vj <- infinity
+  d_iv <- infinity; d_uj <- infinity
+  for k = 1 to n-1 do
+      if power[k][i][u] > 0 and d_iu = infinity then d_iu <- k
+      if power[k][v][j] > 0 and d_vj = infinity then d_vj <- k
+      if power[k][i][v] > 0 and d_iv = infinity then d_iv <- k
+      if power[k][u][j] > 0 and d_uj = infinity then d_uj <- k
+
+  // Step 4: Count paths through e in direction u -> v
+  count <- 0
+  if d_iu != infinity and d_vj != infinity
+     and d_iu + 1 + d_vj = d_ij then
+      count <- count + power[d_iu][i][u] * power[d_vj][v][j]
+
+  // Step 5: Count paths through e in direction v -> u
+  if d_iv != infinity and d_uj != infinity
+     and d_iv + 1 + d_uj = d_ij then
+      count <- count + power[d_iv][i][v] * power[d_uj][u][j]
+
+  return count
+```
+
+---
+
+**B. Worst-case running time of ComputeNumberOfShortestPaths**
+
+The dominant cost is **Step 1**: computing matrix powers A^1 through A^(n-1).
+
+- We perform n-2 matrix multiplications (computing A^2, A^3, ..., A^(n-1)).
+- Each matrix multiplication of two n×n matrices costs O(n^3) using standard (naive) multiplication.
+- Total for Step 1: O(n^2 · n^3) ... no wait: O((n-2) · n^3) = **O(n^4)**.
+
+Steps 2-5 each iterate through at most n-1 values and do O(1) work per iteration, giving O(n) each, which is dominated.
+
+**Worst case:** The worst case occurs when the distance d(i,j) between nodes i and j is n-1 (the maximum possible shortest path length in a graph with n nodes), requiring computation of all matrix powers up to A^(n-1).
+
+Therefore, the worst-case running time is **O(n^4)**.
+
+---
+
+### Sequences and Summations
+
+**A. Derive sum_{k=1}^{n} k^2 = n(n+1)(2n+1)/6 using telescoping sums**
+
+Take a_k = k^3. Then the telescoping sum is:
+
+    sum_{k=1}^{n} (a_k - a_{k-1}) = a_n - a_0 = n^3 - 0 = n^3
+
+Expanding a_k - a_{k-1} = k^3 - (k-1)^3:
+
+    k^3 - (k-1)^3 = k^3 - (k^3 - 3k^2 + 3k - 1) = 3k^2 - 3k + 1
+
+Therefore:
+
+    sum_{k=1}^{n} (3k^2 - 3k + 1) = n^3
+
+    3 * sum_{k=1}^{n} k^2  -  3 * sum_{k=1}^{n} k  +  n  =  n^3
+
+Using the known formula sum_{k=1}^{n} k = n(n+1)/2:
+
+    3 * sum_{k=1}^{n} k^2  =  n^3  +  3 * n(n+1)/2  -  n
+
+    3 * sum_{k=1}^{n} k^2  =  n^3 - n  +  3n(n+1)/2
+
+    3 * sum_{k=1}^{n} k^2  =  n(n^2 - 1)  +  3n(n+1)/2
+
+    3 * sum_{k=1}^{n} k^2  =  n(n-1)(n+1)  +  3n(n+1)/2
+
+    3 * sum_{k=1}^{n} k^2  =  n(n+1) [ (n-1) + 3/2 ]
+
+    3 * sum_{k=1}^{n} k^2  =  n(n+1) * (2n - 2 + 3)/2
+
+    3 * sum_{k=1}^{n} k^2  =  n(n+1)(2n+1)/2
+
+    sum_{k=1}^{n} k^2  =  n(n+1)(2n+1)/6  ∎
+
+---
+
+**B. Show that sum_{k=1}^{n} k^2 = O(n^3) with explicit constants**
+
+From part A, we have the exact formula:
+
+    sum_{k=1}^{n} k^2 = n(n+1)(2n+1)/6
+
+For n >= 1:
+- n+1 <= 2n (since 1 <= n)
+- 2n+1 <= 3n (since 1 <= n)
+
+Therefore:
+
+    sum_{k=1}^{n} k^2 = n(n+1)(2n+1)/6 <= n * (2n) * (3n) / 6 = 6n^3 / 6 = n^3
+
+So with **k_0 = 1** (n_0 = 1) and **C = 1**, we have for all n >= 1:
+
+    sum_{k=1}^{n} k^2 <= 1 * n^3
+
+Therefore sum_{k=1}^{n} k^2 = O(n^3). ∎
+
+---
+
+## Problem 2: Breadth-First Search and Its Applications
+
+**A. Algorithm ComputeDistances**
+
+```
+Algorithm ComputeDistances(g=(V,E), i):
+  Input: Graph g = (V, E); source node i in V
+  Output: d_j = distance from i to j, for all j in V
+          (d_j = infinity if j is unreachable from i)
+
+  foreach j in V do
+      d_j <- infinity;           // No node visited yet
+
+  d_i <- 0;                      // Distance from i to itself is 0
+  Initialize Q to an empty queue;
+  enqueue(Q, i);
+
+  while Q is not empty do
+      j <- dequeue(Q);
+      foreach neighbor h of j do
+          if d_h = infinity then
+              d_h <- d_j + 1;    // h is one step further than j
+              enqueue(Q, h);
+
+  return d;
+```
+
+**Discussion:** The algorithm is identical in structure to BFS but stores distances instead of boolean visited flags. Each node j is enqueued at most once (when d_j first becomes finite). There are at most n enqueue/dequeue operations, costing O(n) total. For each dequeued node j, we iterate through all neighbors of j; across all nodes, the total number of neighbor-iterations equals the sum of all degrees, which is 2m (each edge is examined from both endpoints). Therefore the total running time is O(m + n). ∎
+
+---
+
+**B. Algorithm IsBipartite**
+
+A graph is bipartite if and only if it can be 2-colored such that no two adjacent nodes share a color. BFS can assign colors layer by layer: the source gets color 0, its neighbors get color 1, their unvisited neighbors get color 0, and so on. The graph is bipartite if and only if no two adjacent nodes end up with the same color.
+
+```
+Algorithm IsBipartite(g=(V,E)):
+  Input: Connected graph g = (V, E)
+  Output: True if g is bipartite, False otherwise
+
+  foreach j in V do
+      color_j <- -1;             // -1 means uncolored
+
+  Pick any source node s in V;
+  color_s <- 0;
+  Initialize Q to an empty queue;
+  enqueue(Q, s);
+
+  while Q is not empty do
+      j <- dequeue(Q);
+      foreach neighbor h of j do
+          if color_h = -1 then
+              color_h <- 1 - color_j;  // Assign opposite color
+              enqueue(Q, h);
+          else if color_h = color_j then
+              return False;            // Conflict: not bipartite
+
+  return True;
+```
+
+**Correctness:** If two adjacent nodes receive the same color, there is an odd cycle, so the graph is not bipartite (return False). If BFS completes without conflict, the 2-coloring is valid, so the graph is bipartite (return True).
+
+**Running time:** The structure mirrors BFS: each node is enqueued/dequeued at most once (O(n) total), and each edge is examined from both endpoints (O(m) total). Total: O(m + n). ∎
+
+---
+
+**C. Algorithm ComputeLargestCCSize**
+
+The idea is to repeatedly run BFS from unvisited nodes, each time discovering a new connected component. We track the size of each component and return the maximum.
+
+```
+Algorithm ComputeLargestCCSize(g=(V,E)):
+  Input: Graph g = (V, E) (not necessarily connected)
+  Output: Size (number of nodes) of the largest connected component
+
+  foreach j in V do
+      visited_j <- False;
+
+  max_size <- 0;
+
+  foreach s in V do
+      if visited_s = False then
+          // BFS to explore the connected component containing s
+          size <- 0;
+          Initialize Q to an empty queue;
+          visited_s <- True;
+          enqueue(Q, s);
+
+          while Q is not empty do
+              j <- dequeue(Q);
+              size <- size + 1;
+              foreach neighbor h of j do
+                  if visited_h = False then
+                      visited_h <- True;
+                      enqueue(Q, h);
+
+          if size > max_size then
+              max_size <- size;
+
+  return max_size;
+```
+
+**Running time analysis:** The outer loop iterates over all n nodes. A BFS is only initiated from unvisited nodes, so across all BFS calls:
+- Each node is marked visited and enqueued/dequeued exactly once → O(n) total.
+- Each edge (u,v) is examined at most twice (once when u is dequeued, once when v is dequeued) → O(m) total.
+
+Combined with the O(n) outer loop iterations and O(n) initialization, the total running time is **O(m + n)**. ∎
+
+---
+
+## Problem 3: Network Resilience
+
+### compute_largest_cc_size
+
+The implementation is in `autograder.py`. It follows Algorithm ComputeLargestCCSize from Problem 2: it performs BFS from each unvisited node, counts the size of each connected component, and returns the maximum size found.
+
+### Random Graph Parameters
+
+The real network (`rf7.repr`) is an ISP topology. When loaded, it has approximately **n = 1133 nodes** and **m = 5895 edges** (average degree ≈ 10.4).
+
+**Erdos-Renyi parameters:**
+We need an ER graph with the same number of nodes (n = 1133) and approximately the same number of edges. The expected number of edges in G(n,p) is p * n*(n-1)/2. Setting this equal to m:
+
+    p = 2m / (n*(n-1)) ≈ 2 * 5895 / (1133 * 1132) ≈ 11790 / 1282556 ≈ 0.0092
+
+So we use `erdos_renyi(1133, 0.0092)`.
+
+**UPA parameters:**
+In `upa(n, m_param)`, each new node attaches to m_param existing nodes. The total expected degree of the resulting graph is approximately 2 * m_param * n. To match the average degree of the real network:
+
+    m_param ≈ average_degree / 2 ≈ 10.4 / 2 ≈ 5
+
+So we use `upa(1133, 5)`.
+
+In practice, the analysis code reads the real graph and computes these parameters dynamically.
+
+### Experiments and Analysis
+
+The experiments remove nodes one by one (either randomly or in decreasing order of degree) and record the size of the largest connected component after each removal. Since the graphs are modified destructively, copies are made before each experiment.
+
+### Discussion
+
+**Resilience of the Erdos-Renyi (ER) graph:**
+
+In an ER graph, node degrees are approximately Poisson-distributed, meaning most nodes have similar (near-average) degree. Under **random attack**, the large connected component degrades gradually and steadily. Under **targeted attack**, the ER graph behaves similarly to random attack because there are no highly-connected "hub" nodes to specifically target — all nodes have roughly the same degree. Both attacks cause a smooth decline in the largest CC size.
+
+**Resilience of the UPA (scale-free / preferential attachment) graph:**
+
+UPA generates a scale-free network with a heavy-tailed (power-law) degree distribution: most nodes have low degree, but a few "hubs" have very high degree. This leads to dramatically different behavior under the two attacks:
+
+- **Random attack:** Removing a random node almost certainly removes a low-degree node, which has minimal impact on overall connectivity. The UPA graph is highly resilient to random failures — the largest CC decreases only slowly.
+
+- **Targeted attack:** The few high-degree hub nodes are removed first. These hubs are critical to connectivity, so removing them rapidly fragments the network. The UPA graph collapses quickly under targeted attack.
+
+**Resilience of the real ISP network (rf7.repr):**
+
+The real network shows behavior intermediate between ER and UPA, but with properties closer to a scale-free network (consistent with Barabasi-Albert and measurements of real ISP topologies):
+
+- Under **random attack**: reasonably resilient — most routers are not critical hubs, and random failures cause gradual degradation.
+- Under **targeted attack**: more fragile — there are high-degree backbone routers whose removal causes rapid breakdown of connectivity.
+
+**Comparison within the first 20% of nodes removed:**
+
+In the first 20% of removals:
+- ER (random and targeted): both show roughly linear, moderate decline in largest CC size.
+- UPA (random): minimal decline — the largest CC remains near-full size.
+- UPA (targeted): steep decline — the giant component drops dramatically.
+- Real network (random): gradual decline.
+- Real network (targeted): faster decline, similar in character to UPA but possibly with more structure.
+
+**Are the results expected?**
+
+Yes, these results are entirely expected given the mathematical properties of the two random graph models:
+- ER graphs are homogeneous by construction, so there is no fundamental difference between random and targeted attacks.
+- UPA graphs are heterogeneous by construction (preferential attachment creates hubs), which inherently creates the robust-yet-fragile duality.
+
+**Network design for targeted attack resilience:**
+
+To design a network topology that is resilient to targeted attacks, one should **avoid highly-connected hub nodes** and instead use a more **homogeneous degree distribution** (similar to ER). This way, removing any single node has a limited impact on the overall connectivity. In practice, this means distributing connections more evenly across all nodes and using redundant paths, rather than routing everything through a few backbone routers.
+
+**How well was the real-world topology (rf7.repr) designed?**
+
+The real-world ISP topology shows moderate resilience to random failures but is relatively vulnerable to targeted attacks on high-degree nodes. This is a common trade-off in real-world network design: scale-free topologies emerge naturally from growth processes (new nodes connect to already well-connected nodes), and while this makes the network efficient and robust against random failures, it introduces vulnerability to deliberate targeted attacks. The ISP network was not specifically designed to defend against targeted attacks, as cost, geography, and operational efficiency dominate real-world decisions. A well-designed security-focused network would use a more uniform degree distribution at the cost of potentially less efficient routing.