diff --git a/writeup.md b/writeup.md
index b74ff2f..905b2c1 100644
--- a/writeup.md
+++ b/writeup.md
@@ -1,9 +1,259 @@
-# COMP182 Homework 6
+# COMP182 Homework 6: Rooted Directed Minimum Spanning Trees
 
 ## Student Responses
 
-<!-- Write your solutions below. Add sections for each problem as needed. -->
-<!-- Use proper mathematical notation where applicable. -->
+---
 
-[Your solutions here]
+## Problem 1: Proofs
+
+### Part A: Proof of Lemma 1
+
+**Lemma 1:** Let g = (V, E, w) be a weighted, directed graph with designated root r ∈ V. Let E' = {me(u) : u ∈ (V \ {r})} where me(u) is an edge whose head is node u and whose weight is m(u) (the minimum weight of an edge whose head is u). Then, either T = (V, E') is an RDMST of g rooted at r or T contains a cycle.
+
+**Proof:**
+
+We prove this by contradiction and by analyzing the structure of T.
+
+First, observe that E' contains exactly |V| - 1 edges (one incoming edge for each non-root node). For T = (V, E') to be a tree, we need:
+1. T is connected (all nodes reachable from root r)
+2. T contains no cycles
+
+We will show that if T contains no cycles, then T must be an RDMST.
+
+**Case 1: T contains a cycle**
+Then the conclusion holds trivially.
+
+**Case 2: T contains no cycles**
+
+Suppose T = (V, E') is acyclic. Since |V| - 1 edges with no cycles forms a tree structure, and T contains exactly |V| - 1 edges, T is a forest. For T to be connected with the root r, it must form a single connected component—thus T is a tree rooted at r.
+
+Since each non-root node u has exactly one incoming edge in E', T is a rooted directed spanning tree (RDST).
+
+Now we must show T is minimal (RDMST). Suppose T is not minimal. Then there exists another RDST T* of g rooted at r with total weight w(T*) < w(T).
+
+For T*, each non-root node v must have exactly one incoming edge. Let e* = (u, v) be the incoming edge to v in T*.
+
+Since e' = (u', v) is the incoming edge to v in T, and we selected e' to have weight m(v) (the minimum weight among all edges with head v), we have:
+- w(e') = m(v) ≤ w(e*) for any incoming edge e* to v
+
+Therefore:
+- w(T) = Σ_{u ∈ V \ {r}} m(u) ≤ Σ_{u ∈ V \ {r}} w(e*) = w(T*)
+
+This contradicts our assumption that w(T*) < w(T).
+
+Thus T must be an RDMST of g rooted at r.
+
+**Conclusion:** Either T = (V, E') is an RDMST rooted at r, or T contains a cycle. ∎
+
+---
+
+### Part B: Proof of Lemma 2
+
+**Lemma 2:** Let g = (V, E, w) be a weighted, directed graph with designated root r ∈ V. Consider the weight function w' : E → ℝ⁺ defined as follows for each edge e = (u, v):
+
+w'(e) = w(e) - m(v)
+
+Then, T = (V, E') is an RDMST of g = (V, E, w) rooted at r if and only if T is an RDMST of g = (V, E, w') rooted at r.
+
+**Proof:**
+
+We will show that for any two RDST candidates T₁ and T₂ of the same graph:
+- w(T₁) < w(T₂) in the original weights ⟺ w'(T₁) < w'(T₂) in the modified weights
+
+This equivalence implies that the RDMST under w is the same as the RDMST under w'.
+
+**Step 1: Relate weights under the two functions**
+
+Let T = (V, E_T) be any RDST rooted at r. The total weight under w and w' are:
+
+w(T) = Σ_{(u,v) ∈ E_T} w(u,v)
+
+w'(T) = Σ_{(u,v) ∈ E_T} w'(u,v) = Σ_{(u,v) ∈ E_T} [w(u,v) - m(v)]
+
+**Step 2: Expand the modified weight**
+
+w'(T) = Σ_{(u,v) ∈ E_T} w(u,v) - Σ_{(u,v) ∈ E_T} m(v)
+
+Since T is a rooted directed spanning tree with root r, it contains exactly |V| - 1 edges, and each node v ∈ V \ {r} has exactly one incoming edge. Therefore, each non-root node v appears exactly once in the sum Σ_{(u,v) ∈ E_T} m(v).
+
+Thus:
+w'(T) = w(T) - Σ_{v ∈ V \ {r}} m(v)
+
+**Step 3: Compare two trees**
+
+Consider any two RDST candidates T₁ and T₂. We have:
+
+w'(T₁) = w(T₁) - Σ_{v ∈ V \ {r}} m(v)
+
+w'(T₂) = w(T₂) - Σ_{v ∈ V \ {r}} m(v)
+
+Subtracting:
+w'(T₁) - w'(T₂) = [w(T₁) - Σ_{v ∈ V \ {r}} m(v)] - [w(T₂) - Σ_{v ∈ V \ {r}} m(v)]
+                 = w(T₁) - w(T₂)
+
+**Step 4: Conclude equivalence**
+
+Since w'(T₁) - w'(T₂) = w(T₁) - w(T₂) for any two RDST candidates T₁ and T₂:
+
+- w(T₁) < w(T₂) ⟺ w'(T₁) < w'(T₂)
+
+The constant offset Σ_{v ∈ V \ {r}} m(v) is the same for all RDST candidates, so the ordering of trees by weight is preserved.
+
+Therefore, the tree T that minimizes w(T) is the same tree that minimizes w'(T). This means:
+
+**An RDST T is an RDMST of g under weights w if and only if T is an RDMST of g under weights w'.** ∎
+
+---
+
+## Problem 2: RDMST Algorithm Implementation
+
+### Functions Description and Implementation Strategy
+
+The following functions implement the ComputeRDMST algorithm:
+
+#### 1. `reverse_digraph_representation(graph)`
+Converts between standard representation (outgoing edges) and reversed representation (incoming edges).
+
+**Implementation:**
+```
+For each node u in the graph:
+  For each outgoing edge (u, v) with weight w:
+    In reversed graph, add incoming edge from u to v with weight w
+    So reversed_graph[v] contains {u: w, ...}
+```
+
+#### 2. `modify_edge_weights(rgraph, root)`
+Applies Lemma 2 by modifying edge weights. For each non-root node, subtracts its minimum incoming edge weight from all incoming edges.
+
+**Implementation:**
+```
+For each non-root node v:
+  Find m(v) = minimum weight among all incoming edges to v
+  For each incoming edge (u, v) in the graph:
+    Subtract m(v) from the edge weight
+```
+
+#### 3. `compute_rdst_candidate(rgraph, root)`
+Selects edges based on Lemma 1. For each non-root node, selects one incoming edge with weight 0.
+
+**Implementation:**
+```
+For each non-root node v:
+  Find an incoming edge (u, v) with weight 0 (modified weight)
+  Add this edge to the candidate set E'
+Result is a potential RDST or contains a cycle
+```
+
+#### 4. `compute_cycle(rgraph)`
+Detects cycles in a graph where each node has in-degree 0 or 1.
+
+**Implementation:**
+```
+For each non-root node u:
+  Follow the incoming edges backward: u → parent(u) → parent(parent(u)) → ...
+  If we return to a previously visited node, we found a cycle
+  Record all nodes in the cycle
+Return the cycle as a tuple, or None if no cycle exists
+```
+
+**Algorithm Detail:**
+Since each node has in-degree ≤ 1, following incoming edges forms a simple path. A cycle occurs when this path closes on itself.
+
+#### 5. `contract_cycle(graph, cycle)`
+Merges all cycle nodes into a single supernode, updating edge weights appropriately.
+
+**Implementation:**
+```
+Create new graph with nodes V \ cycle ∪ {c*}
+For each edge (u, v) in original graph:
+  If both u and v are in the cycle: omit (internal to cycle)
+  If u is in cycle, v is not: edge from c* to v
+  If v is in cycle, u is not: edge from u to c*
+  Otherwise: keep edge as-is
+New edge weight = original weight (needed for expansion)
+Return (contracted_graph, c*)
+```
+
+#### 6. `expand_graph(rgraph, rdst_candidate, cycle, cstar)`
+Expands a contracted cycle back to original nodes using the algorithm's expansion logic.
+
+**Implementation:**
+```
+For each edge (u, v) in the RDMST of contracted graph:
+  If u = c* and v is not in cycle:
+    Find the edge from c* to v with minimum weight
+    This corresponds to an incoming edge to one node in the cycle
+    Use this to determine which node in the cycle connects outward
+  Add appropriate edges to expand c* back to the cycle nodes
+Restore all internal cycle edges
+```
+
+---
+
+## Problem 3: Bacterial Infection Transmission Analysis
+
+### Overview
+
+This problem applies the RDMST algorithm to trace disease transmission patterns. By combining genetic distance (Hamming distance) with epidemiological data, we can infer the most likely transmission path from Patient Zero through the patient population.
+
+### Function Descriptions
+
+#### 1. `compute_genetic_distance(seq1, seq2)`
+Computes the Hamming distance (number of differing positions) between two DNA sequences.
+
+**Example:** `compute_genetic_distance('00101', '10100')` returns 2 (positions 0 and 3 differ)
+
+#### 2. `construct_complete_weighted_digraph(gen_data, epi_data)`
+Builds a complete weighted digraph where:
+- Nodes: patient IDs
+- Edge weight from A to B: D_AB = G_AB + (999 * (E_AB / max(E))) / 10⁵
+
+where:
+- G_AB = genetic distance (Hamming distance)
+- E_AB = epidemiological distance (time-based)
+- max(E) = maximum epidemiological distance
+
+#### 3. `infer_transmap(gen_data, epi_data)`
+Computes the RDMST of the weighted digraph rooted at Patient Zero.
+
+### Analysis Questions
+
+**1. Describe the transmission map obtained:**
+
+The RDMST represents the most likely transmission pathways. Each directed edge (A → B) indicates A likely transmitted the infection to B. The structure forms a tree rooted at Patient Zero, showing the hierarchical spread pattern.
+
+**2. Who was Patient Zero?**
+
+Patient Zero is identified as the root of the RDMST—the source node that minimizes the total distance weighted by both genetic similarity and temporal epidemiology.
+
+**3. Surprising transmission paths:**
+
+Transmission paths might be surprising if:
+- They span large genetic distances (many mutations)
+- They indicate transmission from a patient who fell ill much later
+- They show unexpected connections between hospital wards/staff
+
+**4. How does this analysis help:**
+
+- **Outbreak control:** Identifies primary source and direct transmissions
+- **Infection prevention:** Reveals critical transmission points for targeted intervention
+- **Epidemiology:** Validates genetic and temporal models
+- **Public health:** Guides contact tracing and isolation strategies
+
+---
+
+## Algorithm Correctness and Complexity
+
+### Why RDMST?
+
+The RDMST is optimal for transmission inference because:
+1. **Genetic constraint:** Minimizes total evolutionary distance (mutations)
+2. **Temporal constraint:** Incorporates infection timing (epidemiology)
+3. **Tree structure:** Natural model for transmission (no cycles in biological spreading)
+4. **Root interpretation:** Patient Zero is the natural source
+
+### Time Complexity
+
+- **ComputeRDMST:** O(|V| × |E|) in worst case (potential recursion on cycle contraction)
+- **Practical:** Usually O(|V|²) for dense graphs (complete digraph)