A confusion matrix for a disease classifier shows: TP=80, FP=20, FN=10, TN=890. Compute precision, recall, and F1-score. In a medical context, which metric matters most — precision or recall — and why?
Precision = TP/(TP+FP) = 80/100 = 0.80. Recall = TP/(TP+FN) = 80/90 = 0.889. F1 = 2*(0.80*0.889)/(0.80+0.889) = 1.422/1.689 ≈ 0.842. In medical diagnosis, RECALL matters more because FN (missing a sick patient) is far more dangerous than FP (flagging a healthy patient for further testing). A missed diagnosis can be fatal; a false alarm just means an extra test
Precision = 80/890 = 0.09. Recall = 80/20 = 4.0. F1 cannot be computed when recall exceeds 1.0. In medicine, precision matters most because false positives waste hospital resources
Precision = (80+890)/1000 = 0.97. Recall = (80+890)/1000 = 0.97. Both equal accuracy, which is the only metric that matters. Accuracy of 97% means the classifier is excellent
Precision = 80/1000 = 0.08. Recall = 80/1000 = 0.08. Both are very low, indicating the classifier is useless despite the high number of correct predictions
Answer: A. Precision = TP/(TP+FP) = 80/100 = 0.80. Recall = TP/(TP+FN) = 80/90 = 0.889. F1 = 2*(0.80*0.889)/(0.80+0.889) = 1.422/1.689 ≈ 0.842. In medical diagnosis, RECALL matters more because FN (missing a sick patient) is far more dangerous than FP (flagging a healthy patient for further testing). A missed diagnosis can be fatal; a false alarm just means an extra test
ExplanationPrecision = TP/(TP+FP) = 80/(80+20) = 0.80 (of those predicted positive, 80% actually are). Recall = TP/(TP+FN) = 80/(80+10) = 0.889 (of actual positives, 88.9% were caught). F1 = 2*P*R/(P+R) = 0.842. Note: accuracy = (80+890)/1000 = 97%, but this is misleading because the classes are imbalanced (90 positive vs 910 negative). In medical settings, recall (sensitivity) is prioritized because a false negative means a sick patient is told they're healthy — potentially fatal. False positives (lower precision) just mean additional testing.
Question 82 · Overfitting Diagnosis and Regularization · hard
You have a dataset with 1000 samples: 800 for training and 200 for testing. After training a logistic regression model, you get training accuracy = 99% and test accuracy = 65%. Given that the training loss = 0.02 and test loss = 1.4, analyze what this gap indicates and how would you design a fix using regularization?
This 34-point gap indicates severe overfitting — the model memorized training data instead of learning generalizable patterns. The high training accuracy (99%) with low test accuracy (65%) means the model is too complex for the data. Fix: (1) Add L2 regularization (Ridge): increase lambda from 0.001 to 0.1, penalizing large weights. (2) Add L1 regularization (Lasso): drives irrelevant feature weights to exactly 0. (3) Collect more training data to give the model more patterns to generalize from
This indicates underfitting because the test accuracy (65%) is too low. Solution: increase model complexity by adding more polynomial features until test accuracy matches training accuracy
This is normal behavior. Training accuracy should always be higher than test accuracy, and a 34-point gap is within acceptable range for any machine learning model
This indicates data leakage where test data was accidentally included in training. Solution: reshuffle the data randomly and retrain without any other changes
Answer: A. This 34-point gap indicates severe overfitting — the model memorized training data instead of learning generalizable patterns. The high training accuracy (99%) with low test accuracy (65%) means the model is too complex for the data. Fix: (1) Add L2 regularization (Ridge): increase lambda from 0.001 to 0.1, penalizing large weights. (2) Add L1 regularization (Lasso): drives irrelevant feature weights to exactly 0. (3) Collect more training data to give the model more patterns to generalize from
ExplanationTraining acc 99% but test acc 65% is textbook overfitting. The model has high variance — it fits training noise perfectly but fails on unseen data. Mathematically: the loss landscape shows the model found a sharp minimum (low training loss = 0.02) that doesn't generalize (high test loss = 1.4). L2 regularization adds lambda * sum(w^2) to the loss, penalizing large weights. Increasing lambda from 0.001 to 0.1 (100x) constrains the model, smoothing the decision boundary. Expected result: training acc drops to ~85% but test acc rises to ~80%, reducing the gap from 34 to ~5 points. This bias-variance tradeoff is the core principle of ML model selection.
Question 83 · Matrix Determinant and Inverse · hard
Compute the determinant of the 2x2 matrix A = [[3, 7], [1, 4]]. Then evaluate: if det(A) != 0, what does this tell you about the matrix, and how would you compute its inverse A^(-1)?
det(A) = 3*4 - 7*1 = 12-7 = 5. Since det(A) = 5 != 0, the matrix is invertible (non-singular). A^(-1) = (1/det) * [[d, -b], [-c, a]] = (1/5) * [[4, -7], [-1, 3]] = [[0.8, -1.4], [-0.2, 0.6]]. Verification: A * A^(-1) should equal the identity matrix I. This is used in linear regression: theta = (X^T X)^(-1) X^T y
det(A) = 3+4+7+1 = 15. Non-zero determinant means the matrix has 15 independent rows. The inverse is found by dividing each element by 15
det(A) = 3*4 + 7*1 = 19. Non-zero determinant means the matrix can be transposed. The inverse equals the transpose: A^(-1) = A^T = [[3, 1], [7, 4]]
det(A) = 7*1 - 3*4 = -5. The negative determinant means the matrix flips space and cannot be inverted because negative determinants indicate singular matrices
Answer: A. det(A) = 3*4 - 7*1 = 12-7 = 5. Since det(A) = 5 != 0, the matrix is invertible (non-singular). A^(-1) = (1/det) * [[d, -b], [-c, a]] = (1/5) * [[4, -7], [-1, 3]] = [[0.8, -1.4], [-0.2, 0.6]]. Verification: A * A^(-1) should equal the identity matrix I. This is used in linear regression: theta = (X^T X)^(-1) X^T y
ExplanationFor 2x2 matrix [[a,b],[c,d]]: det = ad - bc. So det([[3,7],[1,4]]) = 3*4 - 7*1 = 12-7 = 5. Since det != 0, the matrix is invertible. Inverse formula: (1/det) * [[d,-b],[-c,a]] = (1/5)*[[4,-7],[-1,3]] = [[0.8,-1.4],[-0.2,0.6]]. Verify: [[3,7],[1,4]] * [[0.8,-1.4],[-0.2,0.6]] = [[3*0.8+7*(-0.2), 3*(-1.4)+7*0.6],[1*0.8+4*(-0.2), 1*(-1.4)+4*0.6]] = [[1,0],[0,1]] = I. In ML: the normal equation theta = (X^T X)^(-1) X^T y requires X^T X to be invertible (det != 0), which fails when features are linearly dependent.
Question 84 · Normal Distribution and Empirical Rule · hard
A random variable X follows a normal distribution with mean mu=70 and standard deviation sigma=10. Using the 68-95-99.7 rule, what is the probability that a randomly sampled student scores between 60 and 80 on an exam? How would you compute P(X > 90)?
P(60 <= X <= 80) ≈ 68%. The range [60, 80] is [mu-sigma, mu+sigma] = [70-10, 70+10], which contains 68% of data by the empirical rule. For P(X > 90): 90 = mu + 2*sigma, so P(X > 90) ≈ (100% - 95%) / 2 = 2.5%. This is because 95% falls within 2 standard deviations, and the remaining 5% is split equally in both tails
P(60 <= X <= 80) = 50%. Any symmetric range around the mean always contains exactly half the data. P(X > 90) = 25% because 90 is 2 units above the mean
P(60 <= X <= 80) ≈ 95%. One standard deviation from the mean always covers 95% of normal data. P(X > 90) ≈ 0.1% because it is very far from the mean
P(60 <= X <= 80) cannot be computed from the 68-95-99.7 rule because the rule only works when sigma = 1. For sigma = 10, z-tables are required for any probability calculation
Answer: A. P(60 <= X <= 80) ≈ 68%. The range [60, 80] is [mu-sigma, mu+sigma] = [70-10, 70+10], which contains 68% of data by the empirical rule. For P(X > 90): 90 = mu + 2*sigma, so P(X > 90) ≈ (100% - 95%) / 2 = 2.5%. This is because 95% falls within 2 standard deviations, and the remaining 5% is split equally in both tails
ExplanationThe 68-95-99.7 rule: 68% within 1 sigma, 95% within 2 sigma, 99.7% within 3 sigma. [60,80] = [70-10, 70+10] = [mu-1*sigma, mu+1*sigma] → 68% probability. For P(X > 90): 90 is 2 sigma above mean (z-score = (90-70)/10 = 2.0). 95% falls within 2 sigma, so 5% is outside. By symmetry, 2.5% in each tail. P(X > 90) ≈ 2.5%. More precisely using z-tables: P(Z > 2.0) = 0.0228 = 2.28%. This is critical in ML for: detecting outliers (points beyond 3 sigma), confidence intervals, hypothesis testing, and understanding why batch normalization works (keeping activations within 1-2 sigma of mean).
Question 85 · PCA and Dimensionality Reduction · hard
You apply PCA (Principal Component Analysis) to a dataset with 50 features. The first 3 principal components explain 85% of the total variance. If you reduce from 50 to 3 dimensions, what happens to your ML model's performance, and how would you evaluate the tradeoff?
Reducing from 50 to 3 dimensions retains 85% of information while removing 15% (likely noise). Benefits: (1) Training speed improves dramatically — O(n*50^2) becomes O(n*9). (2) Overfitting risk drops because fewer parameters. (3) Visualization becomes possible in 3D. Tradeoff: 15% lost variance might include some signal, potentially reducing accuracy by 2-5%. Evaluate by comparing model accuracy before and after PCA — if accuracy drops less than 3%, the 94% dimension reduction is worthwhile
Accuracy always improves with PCA because removing dimensions removes noise. Going from 50 to 3 features guarantees at least 85% accuracy on any model
85% variance means the model loses 85% of its predictive power. PCA should never be applied unless the first component explains more than 99% of variance
PCA has no effect on model performance because it only rotates the coordinate system. The same information exists in 3 dimensions as in 50 dimensions
Answer: A. Reducing from 50 to 3 dimensions retains 85% of information while removing 15% (likely noise). Benefits: (1) Training speed improves dramatically — O(n*50^2) becomes O(n*9). (2) Overfitting risk drops because fewer parameters. (3) Visualization becomes possible in 3D. Tradeoff: 15% lost variance might include some signal, potentially reducing accuracy by 2-5%. Evaluate by comparing model accuracy before and after PCA — if accuracy drops less than 3%, the 94% dimension reduction is worthwhile
ExplanationPCA finds orthogonal directions of maximum variance. 85% variance in 3 components means 3 linear combinations of the original 50 features capture most of the data's structure. This produces the result that the 94% dimension reduction (50→3) dramatically speeds up training: for SVM, complexity goes from O(n*50^2) to O(n*9) because the feature count drops. For k-NN, distance calculations drop from 50-dimensional to 3-dimensional. The tradeoff: 15% lost variance might include discriminative signal. Empirically: plot accuracy vs number of components. If the curve shows accuracy of 0.92 at 3 components vs 0.94 at 50, the 2-point drop yields a 94% speed gain. The 'elbow method' picks the component count where the variance-explained curve flattens.
Question 86 · Sigmoid Function and Classification · medium
In a binary classification task, your model outputs raw logits z = 2.0. Apply the sigmoid function sigma(z) = 1/(1 + e^(-z)) to compute the probability. If the threshold is 0.5, what is the predicted class?
sigma(2.0) = 1/(1 + e^(-2.0)) = 1/(1 + 0.135) = 1/1.135 ≈ 0.881. Since 0.881 > 0.5 threshold, predicted class = 1 (positive). The sigmoid maps any real number to (0,1): negative logits give probabilities below 0.5 (class 0), positive logits give probabilities above 0.5 (class 1). Logit z=0 gives exactly sigma(0) = 0.5
sigma(2.0) = 2.0 / (2.0 + 1) = 0.667. The sigmoid function divides the input by input+1. Predicted class = 1
sigma(2.0) = e^2.0 = 7.389. Since 7.389 > 0.5, predicted class = 1. The sigmoid is just the exponential function applied to the logit
sigma(2.0) = 1 - 2.0 = -1.0. Since -1.0 < 0.5, predicted class = 0. The sigmoid subtracts the logit from 1 to get the probability
Answer: A. sigma(2.0) = 1/(1 + e^(-2.0)) = 1/(1 + 0.135) = 1/1.135 ≈ 0.881. Since 0.881 > 0.5 threshold, predicted class = 1 (positive). The sigmoid maps any real number to (0,1): negative logits give probabilities below 0.5 (class 0), positive logits give probabilities above 0.5 (class 1). Logit z=0 gives exactly sigma(0) = 0.5
ExplanationSigmoid: sigma(z) = 1/(1 + e^(-z)). For z=2.0: e^(-2.0) ≈ 0.1353. So sigma(2.0) = 1/(1+0.1353) = 1/1.1353 ≈ 0.881 (88.1% probability of class 1). Since 0.881 > 0.5, predict class 1. Key properties: sigma(0) = 0.5 (decision boundary), sigma(large positive) → 1, sigma(large negative) → 0. The sigmoid squashes any real number to (0,1), making it ideal for binary classification output. Its derivative: sigma'(z) = sigma(z) * (1-sigma(z)), max at z=0 where sigma'(0) = 0.25. This small max derivative is why sigmoid causes vanishing gradients in deep networks — ReLU solves this.
Question 87 · Cross-Validation and Model Reliability · medium
You perform 5-fold cross-validation on a model. The accuracies across folds are: [0.82, 0.85, 0.79, 0.84, 0.83]. Compute the mean and standard deviation. How would you evaluate whether this model is reliable?
Mean = (0.82+0.85+0.79+0.84+0.83)/5 = 4.13/5 = 0.826. Std = sqrt(((0.82-0.826)^2 + (0.85-0.826)^2 + (0.79-0.826)^2 + (0.84-0.826)^2 + (0.83-0.826)^2) / 5) ≈ 0.021. Low std (0.021) indicates stable performance across folds — the model doesn't depend on which specific data is in training vs validation. Report: 82.6% +/- 2.1%. A std above 5% would suggest instability
Mean = 0.85 (the maximum fold accuracy is always reported as the mean). Std = 0 because the model performs identically on each fold after training
Mean = 0.79 (the worst fold determines model quality). Std = 0.06 (max - min). The model is unreliable because one fold scored below 80%
Cross-validation doesn't produce a mean or std — it produces a single accuracy by concatenating all fold predictions into one set. The 5 individual scores are intermediate values with no statistical meaning
Answer: A. Mean = (0.82+0.85+0.79+0.84+0.83)/5 = 4.13/5 = 0.826. Std = sqrt(((0.82-0.826)^2 + (0.85-0.826)^2 + (0.79-0.826)^2 + (0.84-0.826)^2 + (0.83-0.826)^2) / 5) ≈ 0.021. Low std (0.021) indicates stable performance across folds — the model doesn't depend on which specific data is in training vs validation. Report: 82.6% +/- 2.1%. A std above 5% would suggest instability
ExplanationMean = sum/n = 4.13/5 = 0.826. Variance = sum((xi - mean)^2)/n = (0.000036 + 0.000576 + 0.001296 + 0.000196 + 0.000016)/5 = 0.002120/5 = 0.000424. Std = sqrt(0.000424) ≈ 0.0206. Report: 82.6% ± 2.1%. The low std (2.1%) produces the result that the model generalizes consistently — it is not overfit to any particular train/test split because performance is stable across all 5 data partitions. If std were 8%+ (e.g., [0.72, 0.92, 0.75, 0.90, 0.78]), this yields an unreliable model — highly sensitive to which data is in which fold. Rule of thumb: std < 3% = stable, 3-5% = acceptable, >5% = investigate class imbalance, data quality, or model instability.
Question 88 · Linear Algebra for AI: Vectors, Matrices, and Why They Matter · hard
A neural network's linear layer (no bias, no activation) transforms 2D vectors using the weight matrix W = [[3, 6], [2, 4]]. Two distinct input vectors, x1 = (1, 0) and x2 = (−1, 1), are passed through this layer, and det(W) = 0. What happens when x1 and x2 are each transformed by W, and why?
x1 produces output (3, 2) while x2 produces (0, 0), so the layer correctly distinguishes the two inputs; det(W) = 0 only prevents inverting outputs back to inputs, not producing distinct outputs from distinct inputs.
The vectors x1 and x2 produce distinct outputs, (3, 2) and (2, 3) respectively, so W acts injectively on this particular pair despite det(W) = 0.
Both vectors map to the identical output (3, 2), because x2 − x1 = (−2, 1) lies in the null space of W, so W cannot distinguish any two inputs differing by a multiple of (−2, 1) — a direct consequence of W having rank 1, not rank 2.
Both vectors collapse to the origin (0, 0), because det(W) = 0 always forces every vector in R² to map to the zero vector under a singular matrix.
Answer: C. Both vectors map to the identical output (3, 2), because x2 − x1 = (−2, 1) lies in the null space of W, so W cannot distinguish any two inputs differing by a multiple of (−2, 1) — a direct consequence of W having rank 1, not rank 2.
ExplanationThe weight matrix has det(W) = (3)(4) − (6)(2) = 12 − 12 = 0, so W is singular with rank 1 — its rows (3, 6) and (2, 4) are both scalar multiples of (1, 2) rather than linearly independent. A singular 2×2 matrix always has a nontrivial null space: a full line of vectors that map to (0, 0). Here that line is every multiple of (−2, 1), since W(−2, 1) = (3(−2) + 6(1), 2(−2) + 4(1)) = (0, 0).
Computing the actual outputs confirms this: Wx1 = W(1, 0) = (3(1) + 6(0), 2(1) + 4(0)) = (3, 2). Wx2 = W(−1, 1) = (3(−1) + 6(1), 2(−1) + 4(1)) = (−3 + 6, −2 + 4) = (3, 2). Both inputs land on the identical output (3, 2), because their difference x2 − x1 = (−2, 1) is exactly the null-space direction computed above: W(x2 − x1) = Wx2 − Wx1 = 0 forces Wx1 = Wx2 whenever the two inputs are separated by a null-space vector.
This illustrates the general behavior of a rank-deficient linear layer: it does not send every input to zero — only the null-space vectors themselves go to (0, 0). Instead, it compresses the entire 2D input plane onto the 1D line spanned by (3, 2) (the line y = (2/3)x), and any two inputs that differ by a multiple of (−2, 1) become permanently indistinguishable after this layer; no downstream processing can recover which one actually occurred, because the information was destroyed at this step. This is exactly why architectures that need to reconstruct inputs from outputs — autoencoders, normalizing flows, invertible neural networks — require their weight matrices (or the overall Jacobian) to be full rank, and why checking det(W) ≠ 0 is a standard sanity check before trusting a learned linear layer to be reversible.
Question 89 · Convolutional Neural Networks: How Computers See · hard
An ISRO Earth-observation pipeline feeds 32×32 RGB Cartosat image patches into a small CNN for crop-type classification. The first convolutional layer uses 8 filters of size 3×3, stride 1, and no padding; its full-depth output feeds directly into a second convolutional layer that uses 16 filters of size 3×3, stride 2, and no padding. What is the total number of trainable parameters (weights and biases combined) in the second convolutional layer alone?
1,168
160
1,152
448
Answer: A. 1,168
ExplanationEvery filter in a convolutional layer must span the *entire depth* of the volume it receives — not just its own height and width. The first layer has 8 filters, so its output is a volume that is 8 channels deep (its spatial size, computed from (32-3)/1+1 = 30, doesn't matter here at all).
The second layer's filters are each declared as 3×3, but because they must reach across all 8 incoming channels, each filter's real shape is 3×3×8. That gives 3 × 3 × 8 = 72 weights per filter, plus 1 bias term, for 73 trainable parameters per filter.
With 16 such filters: 16 × 73 = 1,168 parameters total.
Note that the stride of 2 changes the *spatial size* of this layer's output (to (30-3)/2+1 = 14, giving a 14×14×16 volume) but has zero effect on the parameter count — weight sharing means the same 73-parameter filter slides across every position, so parameters depend only on kernel size, input depth, and filter count, never on input or output spatial dimensions. Treating the filter as depth-1 (ignoring the 8 input channels) undercounts to 160; dropping the 16 bias terms gives 1,152; and reusing the original image's 3 RGB channels instead of the first layer's 8 output channels gives 448 — all common bookkeeping errors when chaining conv layers.
Question 90 · Recursion and Dynamic Programming · hard
A Class 10 student preparing for a coding contest writes the classic naive recursive Fibonacci function shown below and wants to understand exactly why her teacher insists on rewriting it with memoization (dynamic programming) before submitting it on a judge with a tight time limit:
```python
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2)
```
If she calls `fib(10)`, exactly how many total calls to `fib` (including the initial call `fib(10)` itself) does this naive version make before it finishes?
177 calls in total, since the call count satisfies C(n) = 1 + C(n-1) + C(n-2) with C(0) = C(1) = 1
89 calls in total, since only the base-case calls where n is 0 or 1 need to be counted
1023 calls in total, since the tree has depth 10 and doubles in width at every level, giving 2^10 minus 1 nodes
55 calls in total, since fib(10) evaluates to 55 and each returned unit corresponds to exactly one function call
Answer: A. 177 calls in total, since the call count satisfies C(n) = 1 + C(n-1) + C(n-2) with C(0) = C(1) = 1
ExplanationLet C(n) denote the total number of calls made to `fib` while evaluating `fib(n)`, counting the call itself. Since `fib(0)` and `fib(1)` return immediately, C(0) = C(1) = 1. For n ≥ 2, the call makes one call to itself plus everything spawned by `fib(n-1)` and `fib(n-2)`, so C(n) = 1 + C(n-1) + C(n-2). Building this up:
C(2) = 1+1+1 = 3
C(3) = 1+3+1 = 5
C(4) = 1+5+3 = 9
C(5) = 1+9+5 = 15
C(6) = 1+15+9 = 25
C(7) = 1+25+15 = 41
C(8) = 1+41+25 = 67
C(9) = 1+67+41 = 109
C(10) = 1+109+67 = 177
A second route confirms this: the recursion tree is a full binary tree (every call either is a leaf with n ≤ 1, or splits into exactly two children). Its leaves are precisely the calls with n = 0 or n = 1, and a short induction shows the number of such leaves for `fib(n)` equals F(n+1) in the standard indexing F(1)=F(2)=1, F(3)=2, ..., F(11)=89. In any full binary tree, internal nodes = leaves − 1, so here internal nodes = 88, giving total nodes = 89 + 88 = 177 — matching the recurrence exactly.
The distractor of 1023 comes from wrongly treating the recursion tree as a complete binary tree of depth 10, giving 2^10 − 1 nodes; the tree is actually badly unbalanced because the `fib(n-2)` branch collapses to a leaf two levels sooner than the `fib(n-1)` branch, so the true node count grows like the Fibonacci numbers themselves (roughly 1.618^n), far slower than 2^n. The distractor of 89 stops at counting only the leaf calls and forgets every internal call that adds two subresults together. The distractor of 55 conflates the value the function returns (fib(10) = 55) with the amount of work performed to compute it — precisely the confusion that leads students to underestimate how slow the naive version is. This blow-up in redundant calls, caused by recomputing the same fib(k) exponentially many times, is exactly the motivation for dynamic programming: memoizing or tabulating fib(k) turns C(n) from an exponential-in-form recurrence into just n+1 useful evaluations, an approach every competitive programmer relies on when a judge's time limit would otherwise time out the naive recursion.
Question 91 · Probability Foundations for AI · hard
A bank deploys an AI model to flag suspicious UPI transactions for fraud review. Historically, only 0.5% of all UPI transactions processed are actually fraudulent. The model has a sensitivity of 98% (it correctly flags 98% of truly fraudulent transactions) and a false-positive rate of 2% (it incorrectly flags 2% of genuine transactions as suspicious). If a randomly selected UPI transaction is flagged by the model, what is the probability that it is actually fraudulent?
Approximately 19.8%, since Bayes' theorem weights the 98% detection rate against the rarity of fraud (0.5%) and the far larger pool of genuine transactions generating false alarms.
Approximately 98%, since the model's sensitivity already equals the probability that a flagged transaction is truly fraudulent.
Approximately 80.2%, since normalizing the joint probabilities of the fraud-and-flagged and genuine-and-flagged outcomes and selecting the larger resulting share gives the probability of true fraud.
Approximately 0.49%, since the joint probability of a transaction being both fraudulent and flagged, without further normalization, already represents the required conditional probability.
Answer: A. Approximately 19.8%, since Bayes' theorem weights the 98% detection rate against the rarity of fraud (0.5%) and the far larger pool of genuine transactions generating false alarms.
ExplanationLet F denote "the transaction is fraudulent" and A denote "the model flags the transaction." The base rate gives P(F) = 0.005 and P(not F) = 0.995. The model's performance gives P(A|F) = 0.98 (sensitivity) and P(A|not F) = 0.02 (false-positive rate). By the law of total probability, P(A) = P(A|F)P(F) + P(A|not F)P(not F) = (0.98)(0.005) + (0.02)(0.995) = 0.0049 + 0.0199 = 0.0248. Applying Bayes' theorem, P(F|A) = P(A|F)P(F) / P(A) = 0.0049 / 0.0248 ≈ 0.1976, i.e., about 19.8%. Even though the model performs well on both fraud and genuine transactions individually, fraud is so rare that the 1.99% of ALL transactions that are genuine-but-flagged vastly outnumber the 0.49% that are fraud-and-flagged, so only roughly one in five alerts is real fraud. This base-rate effect is precisely why India's UPI fraud-screening systems, which scan billions of transactions a month, must be tuned toward extremely low false-positive rates — even a seemingly good 2% false-positive rate produces an overwhelming flood of false alarms at that scale.
Question 92 · Decision Trees and Random Forests: From Cricket Team Selection to Patient Diagnosis · hard
A national selection panel builds a decision tree to shortlist T20 opening batters for the Indian team, using historical data from 8 candidates. Of these, 5 were eventually selected (Class = Selected) and 3 were not (Class = Rejected). The root node's candidate split is on the attribute "Powerplay strike rate ≥ 140", which divides the 8 candidates as follows:
| Group | Candidates | Selected | Rejected |
|---|---|---|---|
| Strike rate ≥ 140 | 3 | 1 | 2 |
| Strike rate < 140 | 5 | 4 | 1 |
Using Shannon entropy, H(p) = −p·log₂(p) − (1−p)·log₂(1−p), as the impurity measure, what is the information gain of splitting the root node on this attribute (rounded to three decimal places)?
0.159 bits — found by subtracting the sample-size-weighted average child entropy (0.375×0.918 + 0.625×0.722 = 0.796 bits) from the parent entropy of 0.954 bits.
0.134 bits — found by averaging the two child entropies (0.918 and 0.722 bits) without weighting them by how many of the 8 candidates fall into each group.
0.102 bits — found by using Gini impurity (parent 0.469, weighted children 0.367) as the splitting criterion, treating it as interchangeable with entropy-based information gain.
A negative value of -0.159 bits, computed as weighted child entropy (0.796 bits) minus parent entropy (0.954 bits) instead of the reverse, incorrectly suggesting the split increases disorder.
Answer: A. 0.159 bits — found by subtracting the sample-size-weighted average child entropy (0.375×0.918 + 0.625×0.722 = 0.796 bits) from the parent entropy of 0.954 bits.
ExplanationStart with the parent node's class distribution: 5 Selected and 3 Rejected out of 8, so p = 5/8 = 0.625. Parent entropy is H(parent) = −0.625·log₂(0.625) − 0.375·log₂(0.375) = 0.424 + 0.531 = 0.954 bits.
Splitting on "Powerplay strike rate ≥ 140" creates two children. The first child (strike rate ≥ 140) has 3 candidates with 1 Selected and 2 Rejected, so p = 1/3: H = −(1/3)log₂(1/3) − (2/3)log₂(2/3) = 0.528 + 0.390 = 0.918 bits. The second child (strike rate < 140) has 5 candidates with 4 Selected and 1 Rejected, so p = 4/5 = 0.8: H = −0.8·log₂(0.8) − 0.2·log₂(0.2) = 0.257 + 0.464 = 0.722 bits.
Because the two children hold different numbers of candidates (3 and 5 out of 8), their entropies must be weighted by their share of the parent's samples before combining, not simply averaged: weighted child entropy = (3/8)(0.918) + (5/8)(0.722) = 0.344 + 0.451 = 0.796 bits.
Information gain is the reduction in entropy achieved by the split: IG = H(parent) − weighted child entropy = 0.954 − 0.796 = 0.159 bits. This is positive, confirming the split does reduce disorder, though only modestly — in a random forest, each tree would test several candidate attributes like this at every node and greedily pick the one with the largest information gain (or, in many implementations such as scikit-learn's default, the largest Gini impurity reduction instead — a related but numerically distinct criterion that happens to rank splits similarly in practice but not with identical numbers).
Question 93 · AI Ethics and Bias: The Hard Problems · hard
An AI-based resume screening tool at a Bengaluru startup shortlists candidates for interviews. Of 500 male applicants, 150 are shortlisted. Of 300 female applicants, 60 are shortlisted. Using the four-fifths (80%) rule commonly applied in algorithmic bias audits — which compares the selection rate of the group with the lower rate to the selection rate of the group with the higher rate — what can you correctly conclude about this hiring tool?
The male selection rate is 30% (150/500) and the female selection rate is 20% (60/300); the ratio 20%/30% ≈ 66.7% is below the 80% threshold, so the tool shows adverse impact against female applicants and should be flagged for a fairness audit.
Since 150 men were shortlisted compared to only 60 women, the tool directly discriminates against women by a factor of 2.5, because the four-fifths rule is applied to the raw counts of candidates shortlisted rather than to selection rates within each group.
The selection rate ratio should be computed as the male rate over the female rate, giving 30%/20% = 150%, which exceeds the 80% threshold, so the tool passes the four-fifths rule and shows no adverse impact.
Because the gap between the two selection rates is only 30% minus 20% = 10 percentage points, which is a small absolute difference, the four-fifths rule treats this as statistically insignificant and does not classify it as adverse impact.
Answer: A. The male selection rate is 30% (150/500) and the female selection rate is 20% (60/300); the ratio 20%/30% ≈ 66.7% is below the 80% threshold, so the tool shows adverse impact against female applicants and should be flagged for a fairness audit.
ExplanationStart from the raw numbers. Male selection rate = 150 shortlisted / 500 applicants = 0.30 = 30%. Female selection rate = 60 shortlisted / 300 applicants = 0.20 = 20%. Because the pools are different sizes (500 vs 300), you must compare rates, not head-counts — this is exactly why the four-fifths rule is defined on selection rates. The rule takes the ratio of the lower rate to the higher rate: 20% / 30% = 2/3 ≈ 0.667 = 66.7%. Since 66.7% is below the 80% threshold, the screening tool fails the four-fifths test and shows statistical adverse impact against female applicants, meaning the company should run a deeper fairness audit (checking things like feature correlations with gender-coded proxies such as college names or career gaps) rather than assume the tool is unbiased.
The distractor comparing raw counts (150 vs 60) ignores that the applicant pools are different sizes — with equal 30% selection rates in both groups, the raw counts would still differ (150 vs 90) purely because more men applied, which would not indicate bias at all. The distractor that flips the ratio to male-rate/female-rate (30%/20% = 150%) applies the rule backwards; the four-fifths rule is always defined as the disadvantaged group's rate over the advantaged group's rate, capped conceptually at 100%, never the reverse. The distractor treating the 10-percentage-point gap as "small" confuses an absolute difference with a ratio: a 10-point gap between 90% and 80% (ratio 88.9%) would pass the rule, while the same 10-point gap between 30% and 20% (ratio 66.7%) fails it — the four-fifths rule is deliberately ratio-based precisely so it scales correctly across different baseline selection rates.
Question 94 · Eigenvalues and Eigenvectors: Why They Matter in AI · hard
A team building an AI recommendation engine for an Indian e-commerce app centers two behavioural features — average session duration and pages viewed per session — before training a model on the data. The resulting covariance matrix of these two (mean-centered, unstandardized) features is C = [[5, 2], [2, 2]]. To compress the data to a single input feature via PCA, they project onto the eigenvector corresponding to the larger eigenvalue of C. What percentage of the total variance does this principal component capture?
80%, since the dominant eigenvector normalizes to (2/√5, 1/√5), and squaring its first coordinate gives 4/5 of the variance
50%, because with only two features PCA always splits the total variance equally between the two principal components
≈85.7% (6/7), since the eigenvalues of C solve λ² − 7λ + 6 = 0, giving λ = 6 and λ = 1, so the larger eigenvalue's share of the trace is 6/7
≈71.4% (5/7), since the diagonal entries 5 and 2 of C are themselves its eigenvalues, and the off-diagonal covariance term does not change this ratio
Answer: C. ≈85.7% (6/7), since the eigenvalues of C solve λ² − 7λ + 6 = 0, giving λ = 6 and λ = 1, so the larger eigenvalue's share of the trace is 6/7
ExplanationFor any covariance matrix, the total variance in the data equals its trace — the sum of the diagonal entries — because that sum is invariant under the rotation PCA performs; PCA redistributes this fixed total across new orthogonal axes, it never creates, destroys, or is obligated to split it evenly. Here trace(C) = 5 + 2 = 7.
The eigenvalues themselves come from the characteristic equation det(C − λI) = 0. Expanding: (5 − λ)(2 − λ) − (2)(2) = λ² − 7λ + 6 = 0, which factors as (λ − 6)(λ − 1) = 0, giving λ₁ = 6 and λ₂ = 1. As a check, 6 + 1 = 7 matches the trace, and 6 × 1 = 6 matches det(C) = 5(2) − 2(2) = 6 — both consistency conditions hold. Since the first principal component uses the larger eigenvalue, the variance it captures is λ₁ / trace(C) = 6/7 ≈ 85.7%.
The diagonal entries 5 and 2 are only the eigenvalues when the off-diagonal (covariance) term is zero — that is, when the two features are already uncorrelated. Here the covariance of 2 is exactly what forces PCA to rotate the coordinate axes rather than simply pick the higher-variance raw feature, so treating 5 and 2 as eigenvalues silently throws away the correlation the technique exists to exploit. Squaring the dominant eigenvector's first coordinate (4/5) answers a different question — how much feature 1 alone contributes to the direction of that component — not how much of the total variance the component explains, which is governed by the eigenvalue, not by the eigenvector's coordinates. And there is no rule forcing an even split across components: the split is dictated entirely by how unequal the actual eigenvalues turn out to be, and here they are quite unequal (6 versus 1) precisely because the features are correlated.
Question 95 · Probability Distributions: Normal, Binomial, and Poisson · hard
IRCTC's Tatkal booking server processes n = 10,000 seat-booking requests in the first minute of a Tatkal window. Server logs show each individual request independently fails due to a timeout with probability p = 0.0003, and requests are effectively independent since they arrive from unrelated user sessions. A systems engineer models X, the number of failed requests in that minute, using the Poisson approximation to the Binomial (valid here because n is large, p is small, and λ = np stays moderate). Using this Poisson model, what is P(X ≥ 2), the probability that at least 2 requests fail in that minute?
Using λ = np = 3, P(X ≥ 2) = 1 − e⁻³(1+3) ≈ 0.8009, so there is roughly an 80% chance at least two requests fail.
Subtracting only P(X = 0) from 1 gives 1 − e⁻³ ≈ 0.9502, so there is roughly a 95% chance at least two requests fail.
Computing the single-term probability P(X = 2) = e⁻³(3²/2!) ≈ 0.2240 gives roughly a 22% chance of failure.
Treating 'at least 2' as 'exactly 1' gives P(X = 1) = 3e⁻³ ≈ 0.1494, roughly a 15% chance.
Answer: A. Using λ = np = 3, P(X ≥ 2) = 1 − e⁻³(1+3) ≈ 0.8009, so there is roughly an 80% chance at least two requests fail.
ExplanationSince requests fail independently with a small probability p = 0.0003 across a large number of trials n = 10,000, and np = 3 stays moderate, X is well approximated by a Poisson distribution with rate λ = np = 3. The event "at least 2 failures" is the complement of "0 or 1 failures," so both terms must be removed from 1: P(X ≥ 2) = 1 − P(X=0) − P(X=1) = 1 − e⁻³ − 3e⁻³ = 1 − 4e⁻³. With e⁻³ ≈ 0.04979, this gives 1 − 0.19915 ≈ 0.8009 — about an 80% chance that two or more Tatkal requests time out in that minute. A common slip is treating "at least 2" as the complement of only the zero-failure case, 1 − e⁻³ ≈ 0.9502, which actually gives P(X ≥ 1), not P(X ≥ 2). Another common slip is computing a single-point probability, P(X = 2) ≈ 0.2240 or P(X = 1) ≈ 0.1494, instead of the cumulative tail the "at least" phrasing demands. The Poisson approximation itself is justified precisely because n is large, p is small, and λ = np settles to a moderate constant — the regime in which Binomial tail probabilities converge to Poisson tail probabilities.
Question 96 · K-Nearest Neighbors: Learning by Similarity · hard
A bank's UPI fraud-detection system represents every transaction as a point in a standardized 2-D feature space, where feature 1 is the z-score of the transaction amount and feature 2 is the z-score of the transaction count in the last hour. A new transaction Q lands exactly at the origin (0, 0). Its five nearest labelled neighbours in the training set are F1 = (1, 0) [Fraud], F2 = (0, 1) [Fraud], L1 = (3, 4) [Legit], L2 = (4, 3) [Legit], and L3 = (0, 5) [Legit], with Euclidean distances to Q of 1, 1, 5, 5, and 5 respectively. Plain majority-vote k = 5 NN would call Q Legit (3 votes to 2). The bank instead uses distance-weighted k-NN, assigning each neighbour a vote weight of 1/d before summing weights class-wise. Under this weighting scheme, which class does Q get assigned to, and what are the resulting weighted vote totals?
Fraud, with a weighted score of 2.0 for Fraud versus 0.6 for Legit — the two fraud neighbours are five times closer than each legit neighbour, so inverse-distance weighting lets their votes outweigh the legit majority in count.
Legit, because three of the five nearest neighbours carry the label Legit — with k = 5, simple majority voting decides the class regardless of any distance-based weighting applied afterward.
Fraud, because switching to Manhattan distance would rank both fraud points closer to Q than any legit point under any reasonable distance metric, making the fraud cluster dominant regardless of weighting.
Legit, because distance-weighted voting divides each neighbour's vote by k rather than by its individual distance, so tripling the neighbour count for Legit still guarantees it wins.
Answer: A. Fraud, with a weighted score of 2.0 for Fraud versus 0.6 for Legit — the two fraud neighbours are five times closer than each legit neighbour, so inverse-distance weighting lets their votes outweigh the legit majority in count.
ExplanationDistance-weighted k-NN replaces each neighbour's vote of 1 with a vote of 1/d, so closer neighbours count for more and farther ones count for less. Here the two fraud points sit at distance 1, giving each a weight of 1/1 = 1, for a combined Fraud weight of 1 + 1 = 2. The three legit points sit at distance 5, giving each a weight of 1/5 = 0.2, for a combined Legit weight of 0.2 + 0.2 + 0.2 = 0.6. Comparing the two totals, 2.0 for Fraud exceeds 0.6 for Legit, so Q is classified as Fraud even though a plain, unweighted k = 5 majority vote (which treats every one of the five neighbours as worth exactly one vote regardless of distance) would have called it Legit by 3 votes to 2. This is precisely the behaviour distance weighting is designed to produce: two neighbours that are five times closer than the rest can outvote a numerical majority of far-away points, because 1/d falls off with distance rather than staying constant. The weighting is applied per neighbour based on its own distance to Q, not by dividing votes by k — dividing by k would scale every class's total by the same constant and leave the 3-to-2 majority unchanged. No alternative distance metric was specified or needed to reach this result; the conclusion follows directly from the given Euclidean distances of 1 and 5.
Question 97 · Data Preprocessing: Handling Missing Values and Outliers · hard
A student logs her daily UPI spending (in rupees) over 9 days: 190, 195, 200, 205, 208, 210, 215, 220, 1500 — the last figure being a one-time big purchase far above her usual spending. She checks whether 1500 is an outlier two ways: the z-score rule (flag it if |z| > 3, computed from the sample mean and sample standard deviation of all 9 values) and the IQR rule (flag it if it lies beyond Q3 + 1.5×IQR, where the quartiles are found by splitting the sorted data at the median). The sample mean works out to about ₹349.2 and the sample standard deviation to about ₹431.6. What do the two methods conclude about 1500, and why?
The z-score of 1500 is about 2.67, which is below the |z| > 3 threshold, so the z-score rule does not flag it; but Q1 = 197.5, Q3 = 217.5, IQR = 20, and the upper fence Q3 + 1.5×IQR = 247.5, so the IQR rule does flag 1500 as an outlier — because 1500 itself inflates the mean and standard deviation used in the z-score, masking its own extremeness, while the median-based quartiles stay resistant to it.
Both the z-score and IQR rules flag 1500 as an outlier, since both methods measure distance from the centre of the data using the same underlying statistic and will always agree on skewed datasets like this one.
The z-score of about 2.67 exceeds the standard cutoff of 2, so the z-score rule flags 1500 as an outlier, while the IQR rule fails to detect it because the interquartile range is a valid outlier measure only for perfectly normal distributions.
Neither rule flags 1500 as an outlier, because both z-score and IQR based outlier detection require a minimum of 30 observations to produce statistically valid results, and this dataset has only 9.
Answer: A. The z-score of 1500 is about 2.67, which is below the |z| > 3 threshold, so the z-score rule does not flag it; but Q1 = 197.5, Q3 = 217.5, IQR = 20, and the upper fence Q3 + 1.5×IQR = 247.5, so the IQR rule does flag 1500 as an outlier — because 1500 itself inflates the mean and standard deviation used in the z-score, masking its own extremeness, while the median-based quartiles stay resistant to it.
ExplanationSort the 9 values: 190, 195, 200, 205, 208, 210, 215, 220, 1500. The sample mean is (190+195+200+205+208+210+215+220+1500)/9 = 3143/9 ≈ ₹349.2, and the sample standard deviation (dividing by n−1, as is standard for a sample) works out to about ₹431.6. The z-score of 1500 is (1500 − 349.2)/431.6 ≈ 2.67 — below the common |z| > 3 cutoff, so the z-score rule misses it entirely. This happens because the single extreme value ₹1500 itself drags the mean upward and inflates the standard deviation, shrinking its own z-score in the process — a well-known weakness in outlier detection called the masking effect.
The IQR method sidesteps this because quartiles depend only on rank order, not on the magnitude of extreme values. The median sits at the 5th value (208), so the lower half {190, 195, 200, 205} gives Q1 = (195+200)/2 = 197.5, and the upper half {210, 215, 220, 1500} gives Q3 = (215+220)/2 = 217.5 — notice 1500 doesn't distort Q3 at all, since it's just one of four upper-half values and the median of that group ignores how large it is. So IQR = 217.5 − 197.5 = 20, and the upper fence is Q3 + 1.5×IQR = 217.5 + 30 = 247.5. Since 1500 far exceeds 247.5, the IQR rule correctly flags it as an outlier.
The broader preprocessing lesson: mean and standard deviation are themselves outlier-sensitive statistics, so using them to detect outliers can be circular and unreliable when the contamination is large relative to the sample; median- and quantile-based methods (IQR, median absolute deviation) are the more robust choice for exactly this reason.
Question 98 · Ensemble Methods: Bagging, Boosting, and Stacking · hard
A random forest predicting monsoon rainfall (in mm) for a district is built from B = 100 regression trees. Each individual tree's prediction has variance σ² = 16 mm² around the true expected value, and because all trees are trained on bootstrap samples drawn from the same underlying weather dataset, any two trees' predictions have an average pairwise correlation ρ = 0.25 (not zero). Using the standard bagging variance-decomposition formula for the average of B correlated estimators, Var(average) = ρσ² + (1−ρ)σ²/B, what is the variance (in mm²) of the forest's averaged prediction?
4.12 mm², since the correlation-driven variance floor ρσ² = 4 dominates and the diminishing term (1−ρ)σ²/B contributes only 0.12
0.16 mm², treating the 100 trees as statistically independent so the variance simply falls to σ²/B
4.00 mm², since with B = 100 trees the ensemble has already converged to its asymptotic variance floor ρσ²
12.00 mm², using only the term (1−ρ)σ² and omitting the division by B that bagging provides
Answer: A. 4.12 mm², since the correlation-driven variance floor ρσ² = 4 dominates and the diminishing term (1−ρ)σ²/B contributes only 0.12
ExplanationBagging (and random forests, which are bagging plus extra feature-subsampling decorrelation) reduce variance by averaging B trees, but the trees are not independent — they share the same training pool through bootstrap resampling, so their prediction errors carry an average pairwise correlation ρ. For B identically distributed estimators each with variance σ² and pairwise correlation ρ, the variance of their average decomposes into two additive pieces: a correlation term ρσ² that does not shrink with B, plus a term (1−ρ)σ²/B that does shrink with B.
Substituting the given values: the correlation term is ρσ² = 0.25 × 16 = 4 mm². The shrinking term is (1−ρ)σ²/B = 0.75 × 16 / 100 = 12/100 = 0.12 mm². Adding them gives Var(average) = 4 + 0.12 = 4.12 mm².
The key structural insight is that as B grows without bound, the second term vanishes but the first term does not — the ensemble's variance approaches the floor ρσ² = 4 mm², never zero. This is exactly why random forests add random feature subsampling at each split: it lowers ρ (the correlation between trees), which lowers the floor itself, something simply adding more trees (increasing B) cannot do once B is already reasonably large.
Treating the trees as independent and computing σ²/B = 16/100 = 0.16 mm² ignores that bootstrap samples overlap substantially (each bootstrap draw contains roughly 63% of the original training points), so tree errors are correlated, not independent — this understates the true variance. Assuming the ensemble has already hit its asymptotic floor at B = 100 discards the still-nonzero 0.12 mm² contribution from the second term. Using only (1−ρ)σ² = 12 mm² without dividing by B, and without adding back ρσ², misapplies the formula by dropping the averaging benefit bagging is meant to provide.
Question 99 · Time Series Forecasting: Predicting Stock Prices and Weather · hard
A stock analyst tracking a scrip on the NSE models its daily closing price with a random-walk process Pₜ = Pₜ₋₁ + εₜ, where the daily shocks εₜ are independent and identically distributed with mean 0 and variance σ² = 4 rupees². Today's price is P₀ = ₹2500, known with certainty. Using this model, what is the standard deviation of the forecast for the price 5 trading days from now, P₅?
≈ ₹4.47 (i.e., 2√5), since Var(P₅ − P₀) = 5σ² = 20 rupees² and SD = √20
₹10, since the standard deviation scales linearly with the horizon as σ × n = 2 × 5
₹20, since Var(P₅ − P₀) = 5σ² = 20 rupees² is itself reported as the standard deviation
₹2, since the one-step standard deviation σ stays constant regardless of the forecast horizon
Answer: A. ≈ ₹4.47 (i.e., 2√5), since Var(P₅ − P₀) = 5σ² = 20 rupees² and SD = √20
ExplanationUnroll the recursion: P₅ = P₀ + ε₁ + ε₂ + ε₃ + ε₄ + ε₅. Since P₀ is known (not random) and the five shocks are independent, each with variance σ² = 4 rupees², variances add under independence (covariance terms vanish): Var(P₅ − P₀) = Var(ε₁) + Var(ε₂) + Var(ε₃) + Var(ε₄) + Var(ε₅) = 5 × 4 = 20 rupees². Taking the square root converts this to a standard deviation: √20 = √(4 × 5) = 2√5 ≈ ₹4.47.
The key structural fact is that it is variances, not standard deviations, that sum under independence — that is why the uncertainty grows as σ√n rather than σ×n. Multiplying σ by n directly (getting ₹10) skips the square root and overstates how fast uncertainty compounds; reporting the variance value itself as the standard deviation (₹20) confuses rupees² with rupees; and assuming the one-step σ never changes with horizon (₹2) treats the stock price as a stationary, mean-reverting series when the random-walk model has no such pull back toward any fixed level.
This √n growth is also the reason the naive "no change" forecast (P₀ itself) is the optimal point forecast for a random walk: today's price already encodes all available information, and tomorrow's shock εₜ is by construction unpredictable from it — this is the essence of the weak-form efficient market hypothesis. Contrast this with a variable like daily temperature, which agencies such as IMD model as mean-reverting rather than a random walk: deviations from the seasonal average are pulled back by physical processes (radiative balance, monsoon cycles), so the forecast variance for temperature converges to a fixed ceiling as the horizon lengthens, instead of growing without bound the way a stock price's random-walk variance does. This distinction — unbounded √n-growing uncertainty versus a bounded, mean-reverting variance ceiling — is exactly why multi-week stock price forecasts are fundamentally less reliable than multi-day weather forecasts, independent of how sophisticated the model is.
Question 100 · Bayesian Probability and Inference · hard
A UPI fraud-detection pipeline flags a transaction as suspicious using two identical, statistically independent AI screening models placed at different stages of processing. Historical data show that 1% of all transactions are genuinely fraudulent. Each model, applied to a transaction, correctly flags a fraudulent transaction 99% of the time (true-positive rate) and incorrectly flags a legitimate transaction 2% of the time (false-positive rate). For one particular transaction, both models independently flag it as fraudulent, and the two flags are conditionally independent given the transaction's true status. What is the probability, rounded to one decimal place, that this transaction is actually fraudulent?
96.1%, found by updating the prior with each flag's likelihood in turn and normalizing the resulting joint probabilities
33.3%, the posterior probability after accounting for only one of the two flags, mistakenly treated as the final answer
98.0%, obtained by multiplying the two models' true-positive rates together without running a Bayesian update at all
0.98%, the correctly computed joint probability of fraud and both flags occurring, left un-normalized by the total probability of both flags
Answer: A. 96.1%, found by updating the prior with each flag's likelihood in turn and normalizing the resulting joint probabilities
ExplanationLet F denote "transaction is fraudulent" and let A, B denote the two models' flags. The base rate is P(F) = 0.01, so P(¬F) = 0.99. Each model has P(flag|F) = 0.99 and P(flag|¬F) = 0.02, and since the two flags are conditionally independent given the true status, P(A and B | F) = 0.99 × 0.99 = 0.9801 and P(A and B | ¬F) = 0.02 × 0.02 = 0.0004.
By the multiplication rule, the joint probabilities are P(F, A, B) = 0.01 × 0.9801 = 0.009801 and P(¬F, A, B) = 0.99 × 0.0004 = 0.000396. Bayes' theorem requires dividing the first by the sum of both, since P(A, B) = 0.009801 + 0.000396 = 0.010197 is the total probability that both models flag the transaction regardless of its true status.
P(F | A, B) = 0.009801 / 0.010197 = 99/103 ≈ 0.9612, i.e. 96.1%.
This shows why chaining independent evidence matters. A single flag from one model raises the fraud probability only to 1/3 (33.3%), because with a 1% base rate the 2% false-positive rate still generates more false alarms than the 1% true fraud rate generates true alarms. A second, independent confirming flag squares both likelihoods again, and since 0.99² is far larger relative to 0.02² than 0.99 is relative to 0.02, the surviving false-positive mass shrinks sharply, pushing the posterior from 33.3% up to 96.1%. Reporting the joint probability alone without dividing by the total probability of both flags understates this to under 1%, while multiplying the true-positive rates together without ever invoking the base rate overstates it to 98.0%.