Grade 10 AI & Computer Science Practice Questions — Set 7

ExplanationA Neural ODE replaces the discrete residual update h_{k+1} = h_k + f(h_k) of a ResNet with a continuous rule dh/dt = f(h(t)), and numerically integrating that rule with Euler's method and step size Δt exactly recovers a ResNet whose layers each apply h ← h + Δt·f(h). Here f(h) = −h and h(0) = 2, with Δt = 0.5. First step, from t = 0 to t = 0.5: the slope is f(h(0)) = f(2) = −2, so h(0.5) = h(0) + Δt·f(h(0)) = 2 + 0.5×(−2) = 2 − 1 = 1. Second step, from t = 0.5 to t = 1: the slope must be recomputed at the new state, f(h(0.5)) = f(1) = −1, so h(1) = h(0.5) + Δt·f(h(0.5)) = 1 + 0.5×(−1) = 1 − 0.5 = 0.5. So the Euler-method estimate is h(1) = 0.5. Getting h(1) = 0 comes from forgetting that Euler's method scales the slope by the step size Δt before adding it — adding f(h) directly at each of the two steps (2 + (−2) = 0, then 0 + f(0) = 0) silently turns two half-steps into two full unit-time jumps, which is not what Δt = 0.5 specifies. Getting h(1) ≈ 0.74 confuses the discrete numerical approximation with the true continuous solution: solving dh/dt = −h analytically gives h(t) = h(0)e^(−t) = 2e^(−t), so the exact value at t = 1 is 2/e ≈ 0.736. Euler's method with a finite step size only approximates this curve — with just two steps it overshoots the decay and lands at 0.5, not 0.74; the two values coincide only in the limit Δt → 0, which is the same limit that turns a very deep ResNet into a genuine ODE. Getting h(1) = 4.5 comes from a sign error in the dynamics: using f(h) = h (unstable growth) instead of the learned f(h) = −h (stable decay toward zero) turns the drone's hidden state into an exponentially blowing-up quantity rather than one settling smoothly to zero, the opposite of what a decay-type residual block computes.

ExplanationKirchhoff's Matrix-Tree Theorem states that for a connected graph on n vertices, the number of spanning trees τ(G) equals (1/n) times the product of the n − 1 nonzero eigenvalues of the Laplacian matrix L (equivalently, any (n−1)×(n−1) cofactor of L gives the same value). Here the nonzero eigenvalues are 2, 2, and 4, whose product is 2 × 2 × 4 = 16. Dividing by n = 4 gives τ(C₄) = 16/4 = 4. This matches a direct combinatorial check: C₄ has exactly 4 edges, and removing any single edge from a cycle always leaves the remaining 3 edges connecting all 4 vertices in a path — so every one of the 4 possible single-edge removals produces a valid spanning tree, and no other 3-edge subset exists to check. Four spanning trees is correct. The zero eigenvalue must always be excluded from the product — it exists for every graph because Laplacian rows sum to zero by construction (its eigenvector is the all-ones vector), and its multiplicity counts connected components, not spanning trees. Including it forces the product to 0 regardless of the graph's actual structure, which cannot be right since a connected ring obviously has spanning trees. The normalization is division by n, not by n². This follows from the algebraic fact that L's rows and columns each sum to zero, which makes the product of the nonzero eigenvalues equal to n·τ(G) exactly — so dividing by n² would systematically undercount by a factor of n, and taking the raw product with no normalization at all would overcount by a factor of n. This generalizes cleanly: the cycle graph Cₙ always has exactly n spanning trees, each obtained by deleting one of its n edges, and the Laplacian eigenvalues 2 − 2cos(2πk/n) for k = 0, …, n−1 always reproduce this count through the same (1/n)·(product of nonzero eigenvalues) computation.

ExplanationStart by listing every pairwise distance among the 4 sensors. The four plot sides AB, BC, CD, DA each have length 1 km. The two diagonals AC and BD each have length √(1²+1²) = √2 km ≈ 1.4142 km. These are the only two distinct distance values in the point cloud, so they are the only two filtration values at which anything new can happen. Birth of the loop: a k-simplex enters the Vietoris–Rips complex at ε equal to the largest pairwise distance among its vertices. The four side-edges all have length 1, so all four enter simultaneously at ε = 1 km, closing the boundary A–B–C–D–A into a 4-cycle. At this exact ε, no diagonal edge exists yet (√2 > 1), so no triangle can exist either (a 2-simplex needs all three of its edges present). With edges but no 2-simplices, this 4-cycle is not the boundary of any 2-chain, so it represents a genuinely new, nonzero class in H₁. Hence birth = 1 km. Death of the loop: the class dies once some 2-chain appears whose boundary fills it in. Consider triangle ABC: its three edges are AB = 1, BC = 1, AC = √2, so its largest side is √2, meaning this triangle enters the complex exactly when ε = √2. The same holds for triangles ABD, ACD, and BCD — each contains exactly one diagonal (length √2) and two sides (length 1), so each has largest side √2 and enters at ε = √2. So at ε = √2 km, both diagonals AC and BD appear together with all four triangles at once, and these triangles jointly tile the entire square, filling the hole completely. The rank of H₁ drops from 1 to 0 at this instant, so death = √2 km. Persistence = death − birth = √2 − 1 ≈ 1.4142 − 1 = 0.4142 km ≈ 0.41 km. The distractors correspond to real errors: treating the "sum of two adjacent sides" (1+1=2) as the relevant threshold instead of the true Euclidean diagonal √2; conflating the birth of the loop with the later moment the graph becomes complete (which is actually when it dies, not when it's born); and forgetting that at ε = 0 the complex consists of four isolated points with no edges at all, so no cycle can exist until ε reaches the side length.

ExplanationThe do-operator do(L=l) mutilates the causal graph by deleting every edge pointing INTO L, while leaving edges that point OUT of L untouched — this is exactly what a physical intervention (a load balancer forcing CPU load regardless of anything else) does: it severs L from its natural causes without touching what L itself causes. Apply this to each candidate DAG. In L → Q → F, the edge L→Q points out of L, so it survives the intervention; Q's distribution is mechanically driven by whatever value l the load balancer sets, so P(Q ∣ do(L=l)) must vary with l — exactly the systematic shift the engineers observed. In L ← Q → F, the only edge touching L is Q→L, which points INTO L and is therefore deleted by do(L=l); L then has zero causal influence on Q, so P(Q ∣ do(L=l)) = P(Q) for every l, predicting no shift at all. In F → Q → L, the edge touching L is again Q→L (into L), deleted the same way, giving the same false prediction of no shift. So two of the three Markov-equivalent structures make a testable prediction that the actual experiment falsifies, and only L → Q → F survives: it is confirmed. This is precisely why the ρ(L,F)=0.62 vs ρ(L,F∣Q)≈0.02 pattern in the question, on its own, could never settle the direction — all three DAGs are indistinguishable under any observational conditional-independence test, since Q is a non-collider (not a common effect of L and F) in every one of them. Distinguishing them requires exactly the kind of interventional data the engineers collected, which is the central idea separating causal discovery from mere correlation analysis: observational data pins down the Markov equivalence class (the skeleton plus which nodes are colliders), while interventions are needed to orient the remaining edges.

ExplanationApply the layer's cross-correlation formula y'_i = x'_i − x'_{(i+1) mod 4} directly to x' = (4, 1, 2, 3): y'_0 = 4 − 1 = 3, y'_1 = 1 − 2 = −1, y'_2 = 2 − 3 = −1, y'_3 = 3 − 4 = −1, giving y' = (3, −1, −1, −1). Now compare this to y = (−1, −1, −1, 3) shifted by the same cyclic operator T that turned x into x' (each entry moves to the next higher index, and the entry that falls off the end wraps to the front): T(y) = (y_3, y_0, y_1, y_2) = (3, −1, −1, −1). This is exactly y'. That equality, f(Tx) = T(f(x)), is the defining condition for equivariance under a symmetry group — here the cyclic-shift group Z4 acting on length-4 sequences. It is a strictly stronger and more useful property than invariance (which would require f(Tx) = f(x), i.e. y' = y unchanged, the claim in the first option): equivariance guarantees that the location of a feature detected by the kernel moves correctly with the input, which is essential when the layer's output feeds into later stages that must localize events in the shifted signal. The kernel-flipped computation (1, −3, 1, 1) illustrates a separate, common confusion in the equivariance literature: deep learning frameworks label their operation "convolution" while actually implementing cross-correlation (no kernel flip), and silently switching to the true, flipped convolution changes which neighbor is subtracted from which, breaking the clean shift relationship demonstrated above. The remaining option shifts y one position in the wrong direction, which would only arise from misreading which way x was translated into x'.

ExplanationGroup the exponential series by powers of G. Since G² = -I, the powers cycle with period 4: G⁰ = I, G¹ = G, G² = -I, G³ = -G, G⁴ = I, and so on. Splitting the series into the coefficient of I (even powers of θ) and the coefficient of G (odd powers of θ) gives exp(θG) = (1 - θ²/2! + θ⁴/4! - ⋯)·I + (θ - θ³/3! + θ⁵/5! - ⋯)·G. The first bracket is exactly the Taylor series for cosθ and the second is exactly the Taylor series for sinθ, so exp(θG) = cosθ·I + sinθ·G = [[cosθ, -sinθ], [sinθ, cosθ]], the standard 2D rotation matrix. Norm preservation follows from a structural property of G, not from the specific angle: G is skew-symmetric, meaning Gᵀ = -G (transposing [[0,-1],[1,0]] moves the -1 and 1 to swap positions, giving [[0,1],[-1,0]], which is exactly -G). Taking the transpose of the exponential series term by term gives exp(θG)ᵀ = exp(θGᵀ) = exp(-θG). Because θG commutes with itself, exp(θG)·exp(-θG) = exp(θG - θG) = exp(0) = I, so exp(θG)ᵀ·exp(θG) = I for every θ — the matrix is orthogonal for all θ, not just approximately or for special angles. Orthogonality is exactly the condition ‖Rv‖² = vᵀRᵀRv = vᵀIv = vᵀv = ‖v‖², so magnitude is preserved exactly, not approximately. This is the general principle behind equivariant deep learning layers: any generator satisfying Gᵀ = -G exponentiates to an orthogonal, norm-preserving transformation, which is why skew-symmetric generators are the standard tool for building rotation-equivariant layers for tasks like detecting rotated objects in satellite imagery.

ExplanationFor a simplicial complex, the Euler characteristic χ can be computed two ways: as an alternating sum of simplex counts, χ = (vertices) − (edges) + (triangular faces), and — by the Euler–Poincaré theorem — as an alternating sum of Betti numbers, χ = b₀ − b₁ + b₂ for a 2-dimensional complex. Here V = 10, E = 16, F = 4, so χ = 10 − 16 + 4 = −2. The complex is given as connected, so b₀ = 1, and since no triangle encloses a three-dimensional cavity, b₂ = 0. Substituting into the Euler–Poincaré relation: −2 = 1 − b₁ + 0, so b₁ = 1 − (−2) = 3. The complex therefore carries three independent, unfilled one-dimensional loops — three genuine topological gaps that no ground-station triangle patches over. The value 7 comes from computing the cyclomatic number of the bare connectivity graph alone (E − V + b₀ = 16 − 10 + 1 = 7) while forgetting that each filled triangle kills off one of those loops; the four filled 2-simplices are exactly what bring 7 down to 3. The value 4 comes from wrongly assuming the four filled triangles enclose a three-dimensional void (b₂ = 1) rather than lying flat with b₂ = 0, giving 1 − (−2) + 1 = 4. The value 2 comes from misremembering the Euler–Poincaré relation as χ = −b₁, which silently drops the b₀ = 1 term for connectedness and gives b₁ = −χ = 2.

ExplanationEach region has a 0.1% (0.001) probability of being down in a given month, since 100% − 99.9% = 0.1%. Because the architecture fails over to whichever region is healthy, the combined system goes down only in the rare case that both regions are simultaneously down. For independent events, the probability of both failing together is the product of their individual failure probabilities: 0.001 × 0.001 = 0.000001, i.e., 0.0001%. Subtracting this joint failure probability from 100% gives the combined availability: 100% − 0.0001% = 99.9999%. Counting the digits in 99.9999% (two 9s before the decimal point plus four 9s after it) gives six nines total — three orders of magnitude better than either region alone. This is why AWS, Azure, and GCP all recommend multi-region failover for mission-critical systems like payment gateways: independent redundancy multiplies failure probabilities down (an OR-style rescue condition), whereas treating both regions as jointly required (an AND-style series dependency, as in the last option) or naively averaging or halving the single-region SLA figures both misrepresent how independent probabilities combine.

ExplanationThe total time to process one batch of n records is T(n) = 8 + 0.004n + 0.000002n², combining the fixed connection/transaction overhead, the linear per-record extract-transform-load cost, and the total cost of the pairwise deduplication scan (which grows as n² because every record must be compared against every other record in the batch). The quantity the pipeline actually wants to minimize is the average time per record, f(n) = T(n)/n = 8/n + 0.004 + 0.000002n. Differentiating with respect to n gives f'(n) = -8/n² + 0.000002. Setting f'(n) = 0 gives n² = 8/0.000002 = 4,000,000, so n = 2000 (the positive root, since a batch size can't be negative). Since f''(n) = 16/n³ > 0 for n > 0, this critical point is indeed a minimum, not a maximum. Substituting n = 2000 back in: f(2000) = 8/2000 + 0.004 + 0.000002(2000) = 0.004 + 0.004 + 0.004 = 0.012 seconds/record. Notice that at the optimum, the amortized fixed-overhead term (8/n) exactly equals the quadratic dedup term (0.000002n) — this is a general feature of minimizing any function of the form A/n + Cn: the minimum occurs where the two competing terms balance. The batch-size-4,000,000 answer comes from a common algebra slip: stopping at n² = 4,000,000 and mistaking the squared value itself for n, instead of taking the square root. The "no finite optimum" claim ignores that the deduplication term grows quadratically and will eventually overwhelm any savings from amortizing the fixed overhead — average time actually turns upward for large n. The n = 1 claim makes the opposite error: it correctly avoids the quadratic dedup cost but ignores that the fixed 8-second overhead then gets amortized over a single record, giving a per-record time of roughly 8.006 seconds — far worse than the true minimum.

ExplanationGitHub's contribution graph does not simply count "commits you authored" — it counts commits that satisfy a specific set of rules: the commit's email must be linked to the account, the commit must sit in a repository's default branch (or its gh-pages branch), and critically, that repository must not be a fork. Riya's 45 commits live only on her fork's branch, so they fail the "non-fork default branch" condition and none of them register, no matter how many she makes or how many months she works on them. The commits would start appearing only if the original repository's maintainer merged a pull request built from her fork's changes into that repository's own default branch — at that point the merged commits (still attributed to Riya as author) become part of a non-fork default branch and count. This is exactly why portfolio advice for students emphasizes opening pull requests rather than assuming that forking a repo and committing to it is, by itself, visible activity: a recruiter skimming a green contribution graph will never see work that sits unmerged on a personal fork. The lines-changed theory is wrong because the graph counts qualifying commits (and other events like issues, PRs, and reviews), not net lines of code, so volume of edits doesn't matter once the fork condition already disqualifies every commit. The private-repository theory is also wrong: GitHub does let users opt in to showing private contributions as anonymized squares, so private content is not invisible to the graph by design — it is simply hidden by a user setting, not a technical inability to index it.

ExplanationModel each hosting plan as a linear cost function of call volume. Let x be the number of API calls in thousands. Serverless: C₁(x) = 0.40x. Dedicated server: C₂(x) = 18,000 + 0.10x. At x = 50,000 (50 million calls), C₁ = 0.40 × 50,000 = ₹20,000, and C₂ = 18,000 + 0.10 × 50,000 = 18,000 + 5,000 = ₹23,000. Serverless costs ₹3,000 less per month. This can be cross-checked with the break-even volume, found by setting C₁(x) = C₂(x): 0.40x = 18,000 + 0.10x, so 0.30x = 18,000, giving x = 60,000, i.e. 60 million calls/month. Below this break-even, the plan with zero fixed cost (serverless) wins even though its per-call rate is higher, because the fixed ₹18,000 hasn't yet been overcome by the marginal-rate savings (₹0.10 vs ₹0.40 per 1,000 calls) of the dedicated server. Above 60 million calls/month, the dedicated server becomes cheaper. Since PayEase's projected 50 million calls/month sits below the 60-million break-even, serverless remains the cheaper choice, by exactly ₹3,000/month. The distractors correspond to real modeling errors founders make when comparing infrastructure pricing: assuming a fixed-cost plan always wins at "large" volumes without solving for the actual break-even point; dropping a plan's fixed cost or its marginal cost entirely from the comparison; and comparing only per-unit rates while ignoring that total cost is the sum of a fixed term and a volume-dependent term.

ExplanationThe eigenvalue computation itself is fine: A applied to (2,1) gives (4·2+2·1, 1·2+3·1) = (10,5) = 5·(2,1), so 5 is a genuine eigenvalue of A with eigenvector (2,1). But an eigenvalue only measures stretch along its own eigenvector's direction, and it equals the true maximum stretch (the operator norm) only when the matrix is symmetric — because only then are the eigenvectors orthogonal and the eigenvalues automatically equal to the singular values. Here A = [[4,2],[1,3]] is not symmetric (its off-diagonal entries, 2 and 1, differ), so this shortcut fails. The correct way to find the true maximum stretch factor of A over all unit vectors is the singular value decomposition: compute AᵀA = [[4,1],[2,3]]·[[4,2],[1,3]] = [[17,11],[11,13]]. Its eigenvalues solve λ² − 30λ + 100 = 0 (trace 30, determinant 100), giving λ = 15 ± 5√5, approximately 26.18 and 3.82. The largest singular value of A is the square root of the larger eigenvalue: σ_max = √26.18 ≈ 5.12. This is the true maximum factor by which A stretches a unit vector — larger than the eigenvalue-based estimate of 5.00 — and it occurs along the top eigenvector of AᵀA, a direction different from (2,1). This distinction — eigenvalues describe scaling only along special invariant directions, while singular values describe the true maximum (and minimum) stretch over all directions — is exactly why practical machine learning tools rely on singular values, not eigenvalues, to analyze how a general (non-symmetric) weight matrix reshapes data.

ExplanationLet F mean "the transaction is fraudulent" and S mean "the AI flags it as suspicious." The prior is P(F) = 0.005 (so P(¬F) = 0.995), the detection rate is P(S|F) = 0.98, and the false-alarm rate is P(S|¬F) = 0.03. By the law of total probability, P(S) = P(S|F)P(F) + P(S|¬F)P(¬F) = (0.98)(0.005) + (0.03)(0.995) = 0.0049 + 0.02985 = 0.03475. Bayes' theorem then gives P(F|S) = P(S|F)P(F) / P(S) = 0.0049 / 0.03475 ≈ 0.1410, i.e. about 14.1%. A natural-frequency check confirms this: imagine 100,000 transactions. Only 500 (0.5%) are fraudulent, and the AI catches 98% of these, giving 490 true positives. Among the 99,500 genuine transactions, 3% are wrongly flagged, giving 2,985 false positives. Of the 490 + 2,985 = 3,475 total flags, only 490 are real fraud, so 490/3,475 ≈ 14.1% — matching Bayes' theorem exactly. Because genuine transactions vastly outnumber fraudulent ones, even a small 3% false-alarm rate generates far more false flags than the 98% detection rate generates true ones — this base-rate effect is exactly how a well-built AI system must reason probabilistically instead of trusting raw accuracy figures. Treating the posterior as equal to the 98% detection rate commits the classic base-rate fallacy, ignoring how rare fraud actually is. Computing 0.98 ÷ (0.98 + 0.03) silently assumes fraud and legitimate transactions occur equally often, which contradicts the given 0.5% base rate. And answering with the 0.5% prior ignores that being flagged is real evidence that should shift the belief upward, even though it doesn't push it all the way to certainty.

ExplanationThe standard error of the sample mean is s/√n = 0.45/√36 = 0.45/6 = 0.075 seconds, so the test statistic is z = (x̄ − μ0)/SE = (2.15 − 2.00)/0.075 = 2.00. For a two-tailed test at α = 0.05, the outer 2.5% of the standard normal distribution on each side begins at z = ±1.96, so H0 is rejected whenever |z| exceeds 1.96. Since 2.00 > 1.96, the observed statistic falls in the rejection region: the data give statistically significant evidence that the true mean processing time differs from the claimed 2.00 seconds. This is confirmed by building the 95% confidence interval directly: x̄ ± 1.96·SE = 2.15 ± 1.96(0.075) = 2.15 ± 0.147, giving (2.003, 2.297) seconds — an interval that excludes 2.00, exactly the signature of a significant result at matching confidence. The fail-to-reject claims each rest on a genuine but distinct error: one confuses the 5% critical value (1.96) with the 1% critical value (2.576), silently demanding stronger evidence than the stated significance level requires; the other compares the 0.15-second gap to the sample standard deviation s = 0.45, which measures how spread out individual transactions are, instead of to the standard error 0.075, which measures how spread out the sample mean is and shrinks as √n grows — conflating those two very different quantities is one of the most common errors in this topic. The "overwhelming evidence" claim makes the reverse mistake, dividing by n = 36 instead of √n = 6, which artificially shrinks the standard error and inflates z to an implausible 12.00.

ExplanationDifferentiating term by term, L'(w) = 4w³ − 12w² + 8w, which factors as 4w(w−1)(w−2), so the slope is zero exactly at w = 0, w = 1, and w = 2 — these are the only points where gradient descent can stop moving. The second derivative is L''(w) = 12w² − 24w + 8. At w = 0, L''(0) = 8 > 0, confirming a local minimum with L(0) = 0. At w = 1, L''(1) = 12 − 24 + 8 = −4 < 0, confirming a local maximum with L(1) = 1. At w = 2, L''(2) = 48 − 48 + 8 = 8 > 0, confirming another local minimum with L(2) = 16 − 32 + 16 = 0. Because the leading term w⁴ forces L(w) → ∞ as w → ±∞, no point outside these three can beat the two minima, so w = 0 and w = 2 are both global minima with identical loss value 0, separated by a local-maximum "hill" at w = 1. This is exactly why gradient descent's outcome here depends on where training starts: an initial weight below 1 slides down to w = 0, while an initial weight above 1 slides down to w = 2 — the algorithm has no way of preferring one basin over the other once both reach the same minimum loss, and it never crosses the hill at w = 1 on its own because the gradient always points away from that peak, not toward it.

ExplanationWorking forward step by step: z = wx + b = (2)(1.5) + (−1) = 3 − 1 = 2. So p = σ(2) = e²/(1 + e²) = 7.389/8.389 ≈ 0.881, meaning the model currently gives an 88.1% chance the waitlisted ticket confirms. Since y = 1, the "error signal" p − y = 0.881 − 1 = −0.119: the model is slightly under-confident, and the loss wants w to increase to push p toward 1. The full chain-rule computation is ∂L/∂p = (p−y)/[p(1−p)], and ∂p/∂z = p(1−p), so their product is exactly p − y — the p(1−p) terms cancel algebraically, not by coincidence. That's what makes ∂L/∂w = (p − y)·x = (−0.119)(1.5) ≈ −0.179 so clean. This cancellation is precisely why cross-entropy is paired with sigmoid (and softmax) throughout neural networks: every output-layer gradient in a deep classifier reduces to the same (prediction − label)·input form, regardless of how deep the network is, which is what makes logistic regression the literal output layer of most neural classifiers. The −0.179 gradient tells gradient descent to increase w (move opposite the negative gradient), correctly pushing p closer to 1. The second option comes from confusing two related but opposite conventions: (y − p)·x is the gradient of the log-likelihood used when doing gradient ASCENT to maximize likelihood, while (p − y)·x is the gradient of the loss (negative log-likelihood) used for gradient DESCENT — mixing them up flips the sign and would make the optimizer move the wrong way. The third option comes from forgetting the cancellation entirely and treating this like squared-error loss, where the chain rule genuinely does leave an uncancelled σ'(z) = p(1−p) factor; multiplying that in shrinks the gradient to roughly −0.019, which is why plain MSE trains logistic units much more slowly than cross-entropy does. The fourth option confuses the predicted probability itself with the loss gradient — p = 0.881 measures the model's current belief, not how the loss changes with w, and it never involves y or x at all, so it cannot be a gradient.

ExplanationLloyd's algorithm alternates two steps every round: assign each point to its nearest centroid, then move each centroid to the mean of the points now assigned to it. Using squared Euclidean distance from C1 = (2, 3) and C2 = (8, 5): Z1(2,3): d²(C1)=0, d²(C2)=(2-8)²+(3-5)²=36+4=40 → nearer to C1 Z2(3,3): d²(C1)=(3-2)²+0²=1, d²(C2)=(3-8)²+(3-5)²=25+4=29 → nearer to C1 Z3(6,6): d²(C1)=(6-2)²+(6-3)²=16+9=25, d²(C2)=(6-8)²+(6-5)²=4+1=5 → nearer to C2 Z4(8,5): d²(C1)=(8-2)²+(5-3)²=36+4=40, d²(C2)=0 → nearer to C2 Z5(2,8): d²(C1)=0²+(8-3)²=25, d²(C2)=(2-8)²+(8-5)²=36+9=45 → nearer to C1 So Cluster 1 = {Z1, Z2, Z5} and Cluster 2 = {Z3, Z4}. The update step replaces C1 with the mean of exactly these three zones — not all five, and not the other cluster's members. This is not arbitrary: for a fixed cluster assignment, the mean is the unique minimizer of the within-cluster sum of squared distances J(c) = Σ(xᵢ − c)². Differentiating, dJ/dc = −2Σ(xᵢ − c), which equals zero precisely when c = (1/n)Σxᵢ, the mean — and since d²J/dc² = 2n > 0, this is a minimum, not just a stationary point. Applying that here: new C1 = ((2+3+2)/3, (3+3+8)/3) = (7/3, 14/3) ≈ (2.33 km, 4.67 km) from Ekta Chowk. Averaging all five zones conflates the two clusters into one point that minimizes nothing meaningful for K-means; reporting (7, 5.5) mixes up which cluster's mean is which; and leaving C1 at (2, 3) skips the update step altogether — a centroid coinciding with one data point initially is coincidental and does not exempt it from being recomputed once the assignment step redraws cluster membership.

ExplanationDifferentiating L(w) = 3w² gives dL/dw = 6w, so the update becomes w_{t+1} = w_t − η(6w_t) = (1 − 6η)w_t. This is a linear recurrence with multiplier m = 1 − 6η, so after t steps w_t = m^t·w0: it shrinks toward zero if |m| < 1 and blows up if |m| > 1. With η = 0.4, m = 1 − 6(0.4) = 1 − 2.4 = −1.4, and |m| = 1.4 > 1, so the sequence diverges, flipping sign every step because m is negative. Tracing the loop by hand confirms this: w1 = (−1.4)(4) = −5.6, w2 = (−1.4)(−5.6) = 7.84, w3 = (−1.4)(7.84) = −10.976. For any quadratic loss L(w) = cw², the stability condition |1 − 2cη| < 1 reduces to 0 < η < 1/c; here c = 3, so the boundary is η < 1/3, and 0.4 sits well past it. This is why convexity alone (ruled out by the first distractor) does not guarantee convergence -- a convex loss with high curvature (a large second derivative) needs a correspondingly small learning rate, and the same η that converges smoothly on a flatter loss can explode on a steeper one. The idea that gradient descent simply rescales w by η each step ignores that the update depends on the gradient (which itself scales with w here), not on w alone, and the "constant-amplitude oscillation" scenario is what happens only at the exact boundary η = 1/3, not at η = 0.4.

ExplanationWith y = 1 and z = -3, the predicted probability is p = σ(-3) = 1/(1+e³) ≈ 0.0474, so the network is confidently wrong. For cross-entropy, L_BCE = -[y ln p + (1-y) ln(1-p)] gives dL/dp = -y/p + (1-y)/(1-p); multiplying by dp/dz = p(1-p) and simplifying, every p(1-p) term cancels, leaving the clean result ∂L_BCE/∂z = p - y = 0.0474 - 1 ≈ -0.953. For mean-squared error, L_MSE = (y-p)² gives dL/dp = -2(y-p); multiplying by dp/dz = p(1-p) = 0.0474 × 0.9526 ≈ 0.0452 (no cancellation happens this time), so ∂L_MSE/∂z = -2(1-0.0474)(0.0452) ≈ -0.086. The cross-entropy gradient is roughly 11 times larger in magnitude. This is precisely the vanishing-gradient problem MSE has with sigmoid outputs: when a prediction saturates near 0 or 1 while being badly wrong, the p(1-p) factor in the MSE gradient shrinks toward zero right when the network most needs a strong correction signal, so learning stalls. Cross-entropy avoids this because its gradient depends only on the raw error (p - y), staying large whenever the prediction is far from the true label — which is exactly why cross-entropy, not MSE, is the standard loss for classification networks with sigmoid or softmax outputs.

ExplanationFor the fraud (positive) class, Precision = TP/(TP+FP) = 70/200 = 0.35 and Recall = TP/(TP+FN) = 70/100 = 0.70. The F1-score is the harmonic mean of these two: F1 = 2·P·R/(P+R) = (2 × 0.35 × 0.70)/(0.35 + 0.70) = 0.49/1.05 ≈ 0.4667, about 46.7%. Compare this to the deceptively high accuracy, (TP+TN)/Total = (70+9770)/10000 = 98.4%: because fraud is rare (only 100 of 10,000 transactions), a model can call almost everything "not fraud" and still look accurate, even while catching fraud poorly — accuracy is not F1. The harmonic mean is also not the same as the arithmetic mean (0.35+0.70)/2 = 0.525: the harmonic mean always sits closer to the smaller of the two numbers, so it punishes an imbalance between precision and recall far more harshly. That gap matters in practice — with precision at just 35%, only 70 of the 200 transactions the model flags are genuinely fraudulent, meaning the bank's fraud team wastes most of its effort chasing false alarms, a weakness the arithmetic mean of 52.5% would understate. Finally, precision must not be confused with specificity, TN/(TN+FP) = 9770/9900 ≈ 98.7%, which measures how well the model avoids false alarms among genuine transactions, not how trustworthy a fraud flag is once it is raised — that confusion is what produces the inflated 81.9% figure.