Grade 10 AI & Computer Science Practice Questions — Set 6

ExplanationSince w is optimal and only these two points are active constraints, w must be parallel to the vector joining them: d = x⁺ − x⁻ = (4 − 1, 4 − 0) = (3, 4), with ‖d‖ = √(9 + 16) = 5. Writing w = k·d and substituting into the two margin constraints, then subtracting w·x⁻ + b = −1 from w·x⁺ + b = 1, gives w·d = 2, i.e. k‖d‖² = 2, so k = 2/25. This yields w = (6/25, 8/25) = (0.24, 0.32), and ‖w‖ = √(0.24² + 0.32²) = √0.16 = 0.4. Checking the bias: b = 1 − w·x⁺ = 1 − (0.96 + 1.28) = −1.24, and indeed w·x⁻ + b = 0.24 + (−1.24) = −1, so both original constraints hold exactly — the solution is consistent. The margin width is 2/‖w‖ = 2/0.4 = 5 units. This matches ‖x⁺ − x⁻‖ = 5, which makes geometric sense: with only one support vector per class, the maximum-margin hyperplane is exactly the perpendicular bisector of the segment joining them, so the full margin width equals the straight-line distance between the two support vectors — no extra factor of 2, and never just ‖w‖ or half that distance.

ExplanationThe one-standard-error (1-SE) rule does not simply pick the model with the lowest cross-validation error — it picks the simplest model whose error is statistically indistinguishable from the best one, guarding against choosing a needlessly complex model based on noise in the CV estimate. Step 1: Find the minimum mean CV MSE across all degrees. That is degree 5, with mean CV MSE = 6.9. Step 2: Take the SE at that minimum, which is 0.85, and form the threshold: 6.9 + 0.85 = 7.75. Any model with mean CV MSE at or below 7.75 is treated as "as good as" the minimum, since the gap could be explained by fold-to-fold sampling variability. Step 3: Scan from the simplest model (degree 1) upward and stop at the first one meeting the threshold. - Degree 1: 12.4 > 7.75 — fails. - Degree 2: 8.1 > 7.75 — fails. - Degree 3: 7.3 <= 7.75 — passes. This is the simplest qualifying model, so it is selected. Degree 4 (7.0) and degree 5 (6.9) also fall under the threshold, but they are more complex than degree 3 and offer no error reduction beyond what could be explained by fold-to-fold sampling variability — the SE quantifies exactly that. Selecting degree 5 outright because it has the lowest raw error ignores this uncertainty and risks overfitting to quirks of the particular 5-fold split; selecting degree 4 skips over the simpler degree-3 model that already clears the bar; and selecting degree 1 regardless of the threshold misapplies the rule, since "simplest" is constrained by the threshold, not chosen unconditionally.

ExplanationBecause S_W = [[4,0],[0,48]] is already diagonal, its inverse is simply [[1/4,0],[0,1/48]] — reciprocals on the diagonal. Multiplying by μ_A−μ_B = (0−4, −1−(−1)) = (−4,0) gives w ∝ (1/4·(−4), 1/48·0) = (−1,0), so LDA's Fisher direction is the x-axis. Note what dividing by S_W actually does: the y-coordinate's within-class scatter (48) is large, so that term gets divided down to almost nothing, while the x-coordinate's small scatter (4) gets divided down far less — S_W⁻¹ suppresses noisy directions, it does not amplify them. PCA never looks at μ_A or μ_B at all — it only diagonalizes the total scatter S_T = [[28,0],[0,48]], whose eigenvalues are 28 along x and 48 along y. Since 48 > 28, PCA's first principal component is the y-axis, chosen purely because within-class scatter along y (48, identical in both classes) inflates total spread there — not because y helps distinguish the classes. (Consistency check: the between-class scatter S_B = S_T − S_W = [[24,0],[0,0]], confirming all of the class-separating signal lives along x and none along y.) The two axes are exact opposites in usefulness: along x, the class means are 4 units apart (0 vs 4) against a within-class scatter of only 4, giving clean separation; along y, the class means are numerically identical (−1 in both classes), so any variance along y is 100% within-class noise with zero discriminative value. This is exactly why label-blind PCA can be a poor choice ahead of a classifier, and why Fisher's LDA — which weights the class-mean gap by the inverse within-class scatter — is used as a supervised dimensionality-reduction method beyond PCA.

ExplanationBreak the query-time cost into its two distinct phases and analyse each separately. Phase 1 — distance computation. The Euclidean distance between the query vector and one training vector requires subtracting corresponding features, squaring each difference, and summing: for d = 50 features that is Θ(d) arithmetic operations. This must be repeated against every one of the n = 10,000 training points, giving a total cost of Θ(nd) for this phase alone — it cannot be avoided or reduced, since every feature of every training point must be touched at least once to know how far it is from the query. Phase 2 — finding the k nearest. Rather than sorting all n distances, the algorithm streams them through a bounded max-heap of size k: each of the n distances triggers either a comparison against the heap's current maximum (O(1) when it's larger) or a compare-and-replace-then-sift operation (O(log k) when it's smaller). Across n distances this costs O(n log k). Adding the two independent phases gives the tight bound O(nd + n log k), which is exactly the first option. Since d and log k are unrelated parameters (here d = 50 vs. log₂5 ≈ 2.3), neither term can be dropped in general — this sum is the honest, non-simplifiable answer. The other options each misplace one piece of this reasoning. O(n²d) is the cost of building a full pairwise distance matrix among all n training points (needed for algorithms like DBSCAN or hierarchical clustering), not for answering a single query, which only ever computes n distances, not n². O(nd log n) comes from fully sorting all n distances with an O(n log n) comparison sort instead of using the bounded heap — wasteful here since only the top k = 5 of n = 10,000 values are needed, and n log n grows strictly faster than n log k when k is held fixed and much smaller than n. O(n²) drops the dimensionality factor d entirely, which is impossible: computing even one distance between two 50-dimensional points inherently costs work proportional to d, so d cannot disappear from a correct complexity expression.

ExplanationLogistic regression models the log-odds (logit) as a linear function of the predictors: ln(p/(1−p)) = β0 + β1x1 + β2x2. This linear structure lives on the log-odds scale, not on the probability or odds scale directly, which is exactly what makes the coefficients easy to misread. Holding x2 fixed, increasing x1 by Δx = 5 changes the log-odds by β1·Δx = 0.4 × 5 = 2. Because log-odds are additive, exponentiating both sides shows that odds are multiplicative: odds_new = odds_old × e^(β1Δx) = odds_old × e^2. Since e^2 ≈ 7.39, the second transaction's predicted odds of fraud are about 7.39 times the first transaction's odds — not the odds plus 2 (odds don't add linearly the way log-odds do), not the probability plus 2 (impossible, since probabilities are capped at 1), and not a flat e^0.4 ≈ 1.49, which would only be correct for a 1-unit change and ignores that x1 actually moved by 5 units. This exponential amplification is why a modest-looking coefficient like 0.4 can correspond to a nearly 7.4-fold swing in relative risk once the predictor changes by several units — a routine trap when interpreting fitted models on real transaction data.

ExplanationStart with the parent entropy H(S), using H = −Σ pᵢ log₂(pᵢ). With 6 Yes and 4 No out of 10, p(Yes) = 0.6 and p(No) = 0.4: H(S) = −0.6·log₂(0.6) − 0.4·log₂(0.4) = 0.6(0.737) + 0.4(1.322) = 0.442 + 0.529 ≈ 0.971 bits. Next compute the entropy of each child subset produced by the split on "CGPA ≥ 8." CGPA ≥ 8 subset (n = 6, 5 Yes/1 No): p(Yes) = 5/6, p(No) = 1/6. H = −(5/6)log₂(5/6) − (1/6)log₂(1/6) = (5/6)(0.263) + (1/6)(2.585) = 0.219 + 0.431 ≈ 0.650 bits. This subset is heavily skewed toward Yes but is not pure — one "No" still remains, so its entropy is well above 0. CGPA < 8 subset (n = 4, 1 Yes/3 No): p(Yes) = 1/4, p(No) = 3/4. H = −(1/4)log₂(1/4) − (3/4)log₂(3/4) = (1/4)(2) + (3/4)(0.415) = 0.500 + 0.311 ≈ 0.811 bits. The weighted average entropy after the split must weight each branch by n_branch/n_total, since a branch covering more of the data should count more heavily: H_split = (6/10)(0.650) + (4/10)(0.811) = 0.390 + 0.325 ≈ 0.715 bits. Information Gain = H(S) − H_split = 0.971 − 0.715 ≈ 0.256 bits. The distractors correspond to real, specific errors students make with this formula. Reading the CGPA ≥ 8 subset's "5 Yes, 1 No" as effectively pure and rounding its entropy to 0 (instead of the true 0.650 bits) drops H_split to (6/10)(0) + (4/10)(0.811) ≈ 0.325, inflating the apparent gain to ≈0.646 bits — this is the mistake of eyeballing a skewed-but-impure subset as a leaf. Averaging the two branch entropies as (0.650 + 0.811)/2 ≈ 0.731 instead of weighting by subset size (6/10 and 4/10) gives H_split ≈ 0.731 and a gain of ≈0.240 bits — this ignores that the branches contain different numbers of students, which the entropy-weighting step of ID3 explicitly accounts for. Finally, computing every entropy term with ln instead of log₂ produces values in nats rather than bits (nats = bits × ln 2 ≈ bits × 0.693); carrying that unit mismatch through the whole calculation and calling the final number "bits" yields ≈0.178, silently understating the true information gain by a factor of ln 2.

ExplanationWhen testing a claimed proportion, the standard error under the null hypothesis must be built from the claimed value p0 = 0.80, not from the sample proportion — this is what distinguishes a hypothesis test's standard error from a confidence interval's. Here SE = sqrt(p0(1-p0)/n) = sqrt(0.8 x 0.2 / 400) = sqrt(0.0004) = 0.02. The audit's sample proportion is phat = 306/400 = 0.765, so the test statistic is z = (phat - p0)/SE = (0.765 - 0.80)/0.02 = -1.75. Because the alternative hypothesis is one-sided (Ha: p < 0.80), the rejection region uses the one-tailed critical value at alpha = 0.05, which is -1.645 — not the two-tailed value of -1.96 that would apply if the alternative were two-sided. Since -1.75 lies further left (more extreme) than -1.645, the observed 3.5-percentage-point shortfall is unlikely to arise from sampling variability alone, so the null hypothesis is rejected: there is statistically significant evidence at the 5% level that the model's real-world accuracy on this holdout set falls short of the vendor's 80% claim. A large sample size (via the Central Limit Theorem) only justifies using the normal approximation for the sampling distribution of phat — it does not by itself prove or disprove the claim; that judgment comes strictly from comparing the computed z-statistic to the chosen critical value. Reversing the numerator's subtraction order flips the sign of z and would incorrectly point the conclusion toward the opposite, wrong-direction alternative.

ExplanationPrecision measures how many of the flagged transactions are truly fraudulent: TP/(TP+FP) = 150/250 = 0.60, i.e. 60%. Recall measures how many of the actual fraud cases were caught: TP/(TP+FN) = 150/200 = 0.75, i.e. 75% (FN = 200 − 150 = 50 fraud cases missed entirely). F1 is defined as the harmonic mean of precision and recall, not the arithmetic mean, because the harmonic mean punishes a gap between the two far more severely: F1 = 2·P·R/(P+R) = 2×0.60×0.75/(0.60+0.75) = 0.90/1.35 = 2/3 ≈ 66.7%. Averaging precision and recall arithmetically, (0.60+0.75)/2 = 0.675, overstates how balanced the model actually is — the arithmetic mean is dragged upward by the larger of the two values, while the harmonic mean is always ≤ the arithmetic mean whenever precision and recall differ, which is exactly the imbalance F1 is built to expose. Reporting overall accuracy, (150+9700)/10000 = 98.5%, is dangerously misleading here precisely because fraud is rare (200 of 10,000 transactions): a model that flagged nothing at all would still score 98% accuracy while catching zero fraud, so accuracy cannot separate a genuinely useful detector from a useless one on this skewed dataset. Quoting only precision (60%) ignores the 50 fraud cases the model let through — recall is what captures that cost, and F1 exists specifically to prevent either number from being reported in isolation.

ExplanationSetting both partial derivatives to zero, ∂L/∂w1 = 2w1 − 4w2 = 0 and ∂L/∂w2 = 2w2 − 4w1 = 0, gives w1 = 2w2 and w2 = 2w1 simultaneously. Substituting one into the other forces w2 = 4w2, so w2 = 0 and hence w1 = 0 — the origin is the only critical point on this surface, not a whole line of them. The Hessian of second partials is H = [[2, −4], [−4, 2]]. The second-derivative discriminant is det(H) = (2)(2) − (−4)² = 4 − 16 = −12. A negative determinant means the two directional curvatures have opposite signs, which is precisely the definition of a saddle point — it does not, by itself, tell you the point is a maximum, and checking only the positive diagonal entries fxx and fyy while ignoring the −4 cross-term (the off-diagonal partials) misses the mixed curvature entirely. Solving det(H − λI) = 0 confirms this: (2 − λ)² − 16 = 0 gives λ = −2 and λ = 6, one negative and one positive eigenvalue. Along the eigenvector for λ = 6 (the direction w1 = −w2), the surface curves upward like the bottom of a bowl; along the eigenvector for λ = −2 (the direction w1 = w2), it curves downward like the top of a ridge. Near the origin, the gradient's component along that ridge direction is proportional to the distance from the origin, so it shrinks toward zero exactly where the optimizer needs to move away fastest — a vanilla gradient-descent step, being scaled directly by the current gradient, becomes tiny and progress stalls. Momentum keeps a running fraction of previous update vectors, so the velocity built up while approaching the saddle persists even as the instantaneous gradient shrinks, pushing the optimizer through this near-flat region and out along the descending ridge rather than stalling — this is exactly why momentum (and its variants like Nesterov acceleration or Adam) is valuable on the highly non-convex loss surfaces of real neural networks, which are dominated by saddle points rather than true local minima in high dimensions.

ExplanationThe dot product x · y = (2)(1) + (1)(3) = 2 + 3 = 5, so K(x, y) = 5² = 25 — obtained with one multiplication-add and one squaring on the original 2-dimensional vectors, never touching a 3-dimensional array. To confirm this really is an inner product in feature space, expand φ(x) = (x1², √2 x1x2, x2²) = (4, 2√2, 1) and φ(y) = (y1², √2 y1y2, y2²) = (1, 3√2, 9). Their dot product is (4)(1) + (2√2)(3√2) + (1)(9) = 4 + 12 + 9 = 25, exactly matching K(x, y). This is Mercer's theorem in miniature: (x·y)² qualifies as a valid kernel precisely because it equals φ(x)·φ(y) for an explicit feature map φ. The value 13 comes from dropping the cross term when expanding the square: (x1y1 + x2y2)² correctly expands to x1²y1² + 2x1x2y1y2 + x2²y2² = 4 + 12 + 9 = 25, not just the two square terms 4 + 9 = 13 — omitting 2x1x2y1y2 = 12 is the classic algebra slip when hand-expanding a polynomial kernel, and it is also exactly the middle component contributed by the √2 x1x2 term in φ. The value 5 confuses a similarity kernel with a distance metric. Squared Euclidean distance ||x − y||² is what RBF/Gaussian kernels build on to measure how far apart two points are; the polynomial kernel (x·y)^d instead measures how aligned x and y are after the feature mapping, so it is fundamentally a dot-product-based similarity, not a distance. The real payoff of the kernel trick is dimensional, not about storage. For n original features and a degree-d polynomial kernel, the explicit feature space has O(n^d) components, so explicitly computing φ(x) and φ(y) and then dotting them costs O(n^d) work; computing K(x, y) = (x·y)^d directly costs only O(n). The claim that the trick "only skips storage, not computation" has it backwards — the entire saving comes from never computing φ(x) and φ(y) in the first place, which is exactly what makes kernels with infinite-dimensional feature spaces, like the Gaussian/RBF kernel, usable at all.

ExplanationWork in odds form, since Bayesian updating with conditionally independent evidence multiplies odds by successive likelihood ratios (Bayes factors) — this is the cleanest way to see "updating beliefs" as a chain. Prior odds: P(Fraud) = 1%, so prior odds = 1:99 (Fraud : Not Fraud). Update on Flag₁: the Bayes factor is LR₁ = P(Flag₁|Fraud) / P(Flag₁|Not Fraud) = 0.90 / 0.05 = 18. Posterior odds after Flag₁ = 18 × (1:99) = 18:99 = 2:11. As a probability, P(Fraud | Flag₁) = 2/(2+11) = 2/13 ≈ 15.4%. This is the correct intermediate belief, and it becomes the prior for the next update — it must carry forward the full weight of Flag₁'s evidence, not reset to 1%. Update on Flag₂, using 2:11 as the new prior odds: LR₂ = P(Flag₂|Fraud) / P(Flag₂|Not Fraud) = 0.80 / 0.10 = 8. Posterior odds after both flags = 8 × (2:11) = 16:11. Converting to a probability: P(Fraud | Flag₁ and Flag₂) = 16/(16+11) = 16/27 ≈ 0.5926, i.e., ≈59.3%. Check by the direct joint-likelihood route (valid because Flag₁ and Flag₂ are conditionally independent given the fraud status): numerator for Fraud = 0.01 × 0.90 × 0.80 = 0.0072; numerator for Not Fraud = 0.99 × 0.05 × 0.10 = 0.00495; total = 0.01215; posterior = 0.0072/0.01215 = 16/27 ≈ 59.3%. Both routes agree, confirming the answer. The 15.4% figure is only the belief after the first flag — stopping there ignores the device-fingerprint evidence entirely. The 7.5% figure comes from applying Rule 2's likelihoods to the original 1% base rate rather than to the 15.4% posterior that Rule 1 already established — this discards the first update instead of building on it, which defeats the entire point of sequential Bayesian updating. The 72% figure confuses the likelihoods P(Flag|Fraud) — how likely the evidence is if fraud is true — with the posterior P(Fraud|Flag) — how likely fraud is given the evidence; multiplying sensitivities together is not a valid probability calculation at all.

ExplanationThe second-order Taylor expansion of L(θ) about a = 2 is L(θ) ≈ L(a) + L′(a)(θ−a) + (1/2)L″(a)(θ−a)². Substituting L(2) = 5, L′(2) = 3, L″(2) = 4 gives the local quadratic model L(θ) ≈ 5 + 3(θ−2) + 2(θ−2)². Since the coefficient of (θ−2)² is 2 > 0 (because L″(2) = 4 > 0), this parabola opens upward and has a genuine minimum rather than a maximum, so minimizing it is well-posed. Differentiate with respect to θ and set the result to zero: d/dθ[5 + 3(θ−2) + 2(θ−2)²] = 3 + 4(θ−2) = 0, so θ − 2 = −3/4, giving θ = 2 − 3/4 = 1.25. Notice this is algebraically identical to the Newton's-method update rule θ_new = θ_old − L′(θ_old)/L″(θ_old) = 2 − 3/4 = 1.25 — Newton's method is nothing more than repeatedly building a second-order Taylor (quadratic) local model of the loss and jumping straight to that model's minimum, which is why it converges much faster than plain gradient descent near a well-behaved minimum. As a check, plugging θ = 1.25 back into the quadratic model gives a predicted loss of 5 + 3(−0.75) + 2(0.5625) = 3.875, lower than L(2) = 5, confirming the step moves toward a lower-loss region. The distractors correspond to real slip-ups: dropping the minus sign in the update rule (θ = 2.75), forgetting the factor of 1/2 that Taylor's theorem attaches to the second-derivative term (θ = 1.625), and reporting only the correction term instead of the updated parameter (θ = 0.75).

ExplanationAfter n bisection passes, the interval width shrinks from (b − a) = 1 to exactly 1/2ⁿ, since every pass keeps exactly one half of the current interval regardless of which half contains the sign change. The while-loop keeps executing as long as the width is still ≥ 0.0001, i.e. as long as 1/2ⁿ ≥ 0.0001, which means it stops only once 2ⁿ exceeds 10000. Solving n > log₂(10000) = ln(10000)/ln(2) ≈ 9.2103/0.6931 ≈ 13.288 shows the smallest whole number of completed passes satisfying this is 14. A direct check confirms it: after 13 passes the width is 1/2¹³ = 1/8192 ≈ 0.0001221, which is still ≥ 0.0001, so the loop body runs one more time; after 14 passes the width is 1/2¹⁴ = 1/16384 ≈ 0.0000610, which finally drops below 0.0001 and the loop exits with n = 14. Reading off the four digits after the decimal point in ε and using that directly as the iteration count mistakes bisection's geometric halving (factor of 2 per step) for a decimal factor-of-10 reduction per step, which is not how the method works. Taking the natural logarithm of 10000 alone without dividing by ln(2) — giving ln(10000) ≈ 9.21, rounded up to 10 — forgets that each loop pass corresponds to one halving of the interval, not one factor-of-e reduction, so the base of the logarithm must match the base of the shrinking process. Rounding log₂(10000) ≈ 13.288 down to 13 instead of up describes a count at which the width, 1/8192 ≈ 0.000122, is still above the tolerance, meaning the loop condition is still true and one more pass is still required before termination.

ExplanationBecause v(t) jumps from −A to +A right at t = 0, it is an odd function of t, so its Fourier series contains only sine terms: v(t) = Σ bₙ sin(nω₀t), with no cosine (aₙ) terms at all. The sine coefficients are bₙ = (2/T)∫_{-T/2}^{T/2} v(t) sin(nω₀t) dt. Since v(t) is odd and sin(nω₀t) is odd, their product is even, so this reduces to bₙ = (4/T)∫₀^{T/2} A sin(nω₀t) dt. Evaluating the integral: ∫₀^{T/2} sin(nω₀t) dt = [1 − cos(nω₀·T/2)]/(nω₀) = [1 − cos(nπ)]/(nω₀), using ω₀T/2 = π. Since cos(nπ) = (−1)ⁿ, this bracket equals 2 when n is odd and 0 when n is even — square waves contain only odd harmonics. For odd n, this gives bₙ = (4A/T)·[2/(nω₀)] = 8A/(nω₀T) = 8A/(2nπ) = 4A/(nπ), since ω₀T = 2π. With A = 5 V and n = 3, b₃ = 4(5)/(3π) = 20/(3π) ≈ 2.12 V. Note the two things happening together: the constant 4/π scales every harmonic relative to the peak voltage A, and the factor 1/n further shrinks each successive odd harmonic — dropping either piece (as in the A/π-only or A/n-only distractors) misrepresents the actual spectrum, and the harmonic is very much nonzero since 3 is odd.

ExplanationIn a 2×2 game with no dominant strategies, a player's equilibrium mixing probability is pinned down by making the OTHER player indifferent — not by that player's own payoffs. To find the bank's audit probability q, weight the fraudster's two payoffs by q and (1−q): the expected payoff from Fraud is q(−4) + (1−q)(9) = 9 − 13q, and the expected payoff from Honest is q(0) + (1−q)(0) = 0. If these weren't equal, the fraudster would always pick the strictly better pure action and mixing could not be an equilibrium, so set 9 − 13q = 0, giving q = 9/13 ≈ 69.2%. Checking: at q = 9/13, the fraudster's expected payoff from Fraud is 9 − 13(9/13) = 0, exactly matching Honest, confirming genuine indifference. Auditing less often than 9/13 of the time would make Fraud strictly profitable for the fraudster, breaking the equilibrium; auditing more often wastes the ₹2 audit cost against a fraudster who would already strictly prefer Honesty. (Running the symmetric calculation on the bank's own payoffs — 8p + (−2)(1−p) = −10p + 0(1−p), i.e., 10p − 2 = −10p — instead gives p = 1/10, the fraudster's equilibrium fraud probability, which answers a different question about the fraudster's strategy, not the bank's.)

ExplanationEach trial Zᵢ is Bernoulli with success probability p = π/4, so Var(Zᵢ) = p(1 − p) = (π/4)(1 − π/4) = (π/4)·(4 − π)/4 = π(4 − π)/16. Averaging N independent copies divides the variance by N: Var(Z̄) = Var(Zᵢ)/N = π(4 − π)/(16N). The estimator is not Z̄ itself but π̂ = 4Z̄, and for any constant c, Var(cX) = c²·Var(X) — variance scales with the square of the constant, not the constant itself. So Var(π̂) = Var(4Z̄) = 4²·Var(Z̄) = 16 · π(4 − π)/(16N) = π(4 − π)/N ≈ 2.697/N. This is the standard asymptotic variance of the quarter-circle Monte Carlo estimator, and it shows the characteristic √N convergence of Monte Carlo methods: to halve the standard error of the π estimate, N must be quadrupled, regardless of how large N already is. The distractors each correspond to a specific, traceable slip in this derivation rather than a random wrong number. Skipping the rescaling step entirely — treating π̂ as if it equalled Z̄ rather than 4Z̄ — leaves just Var(Z̄) = π(4 − π)/(16N), never applying the factor-of-16 correction at all. Applying the rescaling linearly instead of quadratically — multiplying by 4 instead of 4² = 16, as if Var(cX) = c·Var(X) — gives 4 · π(4 − π)/(16N) = π(4 − π)/(4N). And approximating Var(Zᵢ) ≈ p by dropping the (1 − p) factor (reasonable-looking when p is small, but p = π/4 ≈ 0.785 here is far from small) while still correctly rescaling by 16 gives 16 · (π/4)/N = 4π/N. Each of these lands on a plausible-looking formula precisely because it corresponds to omitting exactly one real piece of the calculation — not to an arbitrary arithmetic error.

ExplanationFor a Gaussian Mixture Model, the responsibility of a component is a Bayes'-rule posterior: γ_k(x) = π_k·N(x∣μ_k,σ_k²) / Σⱼ πⱼ·N(x∣μⱼ,σⱼ²), where the mixing weight πₖ acts as the prior and the component density acts as the likelihood. Because both components share σ = 2, the normalizing factor 1/(σ√(2π)) inside N(x∣μ,σ²) is identical for both terms and cancels out of the ratio, leaving only the exponential parts to compare. Squared distances from x = 11: (11−10)² = 1 for Cluster 1, and (11−14)² = 9 for Cluster 2 — x is actually nine times closer in squared distance to μ₁ than to μ₂, not the other way around. Exponents: for Cluster 1, −(1)/(2·2²) = −0.125; for Cluster 2, −(9)/(2·2²) = −1.125. Factoring e^(−0.125) out of numerator and denominator: γ₁(x) = π₁ / (π₁ + π₂·e^(−(1.125−0.125))) = 0.7 / (0.7 + 0.3·e⁻¹) Substituting e⁻¹ ≈ 0.368: 0.3 × 0.368 = 0.1104, so the denominator is 0.7 + 0.1104 = 0.8104, giving γ₁(x) = 0.7 / 0.8104 ≈ 0.86. This is higher than the bare mixing weight (0.70) because the likelihood term also favours Cluster 1, and it's higher than 0.73 — the value you'd get by comparing the two Gaussian densities with equal 0.5/0.5 weights and ignoring the actual priors — because π₁ = 0.7 compounds with that same likelihood advantage. The complementary responsibility goes to Cluster 2: γ₂(x) ≈ 0.14, not the reverse, since the point sits closer to μ₁.

ExplanationReverse-mode AD does a forward pass to record values, then a backward pass where every node that fans out to multiple children must have its incoming gradients **summed**, each first multiplied by the correct local derivative. Forward pass at x = 1, y = 2: u = x·y = 2, v = x·u = 2, w = sin(u) = sin(2) ≈ 0.909, f = v + w ≈ 2.909. Backward pass, seeding ∂f/∂f = 1: Since f = v + w: ∂f/∂v = 1 and ∂f/∂w = 1. Node v = x·u has two parents, x and u, so it sends gradient to both: ∂v/∂x = u = 2 and ∂v/∂u = x = 1. This gives x a direct contribution of 1·2 = 2, and gives u a contribution of 1·1 = 1 from this path. Node w = sin(u) sends gradient to u via ∂w/∂u = cos(u) = cos(2) ≈ −0.4161, contributing 1·(−0.4161) = −0.4161 to u. Because u fans out to both v and w, its total upstream gradient is the **sum** of everything that arrived: ∂f/∂u = 1 + (−0.4161) = 0.5839. Node u = x·y then passes this total on to x through ∂u/∂x = y = 2, contributing 0.5839 × 2 ≈ 1.1677 to x. Adding the direct-path contribution and the indirect-path contribution gives the full gradient: ∂f/∂x = 2 + 1.1677 ≈ 3.168. This matches direct symbolic differentiation as a check: f = x²y + sin(xy), so ∂f/∂x = 2xy + y·cos(xy) = 2(1)(2) + 2·cos(2) = 4 − 0.8323 = 3.1677 ≈ 3.168. The distractors correspond to real bugs students write when hand-coding backprop: dropping a path entirely at a fan-out node, multiplying instead of accumulating (summing) gradients at a shared node, and forgetting to multiply an accumulated upstream gradient by the local derivative before passing it further back.

ExplanationWork each confusion matrix directly. Urban: accuracy = (TP+TN)/total = (180+240)/500 = 420/500 = 84%; true positive rate (recall among genuinely qualified applicants) = TP/(TP+FN) = 180/200 = 90%; false positive rate = FP/(FP+TN) = 60/300 = 20%. Rural: accuracy = (50+370)/500 = 420/500 = 84%; true positive rate = TP/(TP+FN) = 50/100 = 50%; false positive rate = FP/(FP+TN) = 30/400 = 7.5%. The two groups land on exactly the same overall accuracy, 84%, which is precisely what makes this case instructive: a single aggregate accuracy number hides a large disparity underneath. Equal opportunity is the fairness criterion that asks a narrower, more targeted question than overall accuracy: among people who are actually qualified, does the model shortlist them at the same rate regardless of group? Here it does not — 90% of genuinely qualified Urban applicants are correctly shortlisted, but only 50% of genuinely qualified Rural applicants are, a 40-percentage-point gap in who gets recognized for merit they actually have. That is the statement with correct, internally consistent numbers. Equal accuracy does not imply equal TPR or FPR, because accuracy is a weighted blend of correct decisions on both the positive and negative class, and very different TP/FN/FP/TN splits can average out to the same overall score — exactly what happens here, so the claim that matching accuracy guarantees equalized odds inverts the actual definition of equalized odds (which requires TPR and FPR to match directly, not accuracy). Reporting only the false positive rate and calling that sufficient for equalized odds ignores half of the definition; equalized odds requires both TPR and FPR to match across groups, and the 40-point TPR gap (90% vs 50%) here is the more consequential harm, since it directly determines which qualified students lose out on the scholarship. Finally, a lower base rate of qualification in one group is not, by itself, evidence that the model's differential ability to recognize qualified candidates is justified. The base rate (100 vs 200 truly qualified) and the model's conditional accuracy at finding those qualified candidates are separate questions; a fairness audit specifically isolates the second one — given that someone is qualified, does the model find them equally often? — and dismissing that gap as "just reflecting merit" conflates the two and forecloses exactly the scrutiny a responsible AI audit is meant to apply.

ExplanationThe transform X = exp(Z) is strictly increasing everywhere, so it is invertible with inverse Z = ln X, and the change-of-variables formula for a scalar transform reads p_X(x) = p_Z(f⁻¹(x)) · |d/dx f⁻¹(x)|. Here d/dx[ln x] = 1/x, and the base density is p_Z(z) = (1/√(2π))·exp(−z²/2). Substituting z = ln x and multiplying by the Jacobian factor 1/x gives p_X(x) = [1/(x√(2π))]·exp(−(ln x)²/2) for x > 0 — precisely the log-normal density with parameters μ = 0 and σ = 1, the standard model for strictly positive, right-skewed quantities such as UPI transaction amounts. The Jacobian term is essential: dropping it, as in the second option, would make the density fail to integrate to 1 over x > 0, since areas under the curve in z-space and x-space are related by exactly this stretching factor. Using the forward derivative dx/dz = exp(z) = x in place of its reciprocal, as in the third option, inverts the direction of the required correction — normalizing flows must divide by |det ∂f/∂z|, not multiply by it, when converting a latent density into a data density. And keeping the Gaussian's exponent in terms of x rather than substituting the latent value z = ln x, as in the fourth option, evaluates the base density at entirely the wrong point.