Exercise Center

Evaluate the expression $10 - 2 \times 3^2$ by hand, applying operator precedence.

Evaluate $-3^2$. (This is the classic precedence trap — the exponent binds tighter than the leading minus.)

Compute $\dfrac{2}{3} - \dfrac{1}{6}$ and give the result as a decimal.

What is the smallest of the sets $\mathbb{N}, \mathbb{Z}, \mathbb{Q}, \mathbb{R}$ that contains the number $-\dfrac{7}{2}$?

In NumPy, what is the dtype of np.array([1, 2, 3])? Answer with the exact dtype name (e.g. int64 or float64).

What does the floor-division expression 17 // 5 evaluate to in Python/NumPy?

In a training loop, which of the following quantities should be stored as a float rather than an integer?

Explain, in one or two sentences, why initializing a weight array with dtype=int and then applying a fractional gradient update leaves the weights unchanged.

What is the dtype of the array produced by np.zeros(3) (with no dtype argument)?

In the expression $\displaystyle\sum_{i=1}^{n} w_i x_i$, the index $i$ and the symbols $w_i, x_i$ come from different number worlds. Which set does the index $i$ range over, and which set do the values $w_i, x_i$ belong to?

A metric function reports $0$ accuracy when it should report $0.75$. The buggy line is acc = correct // total with correct = 3, total = 4. Write a corrected accuracy(correct, total) that returns a float, verify it gives 0.75 for these inputs, and print ok.

By hand, evaluate $E = 2 + 3 \times 4^2 - \dfrac{10}{2}$. Then confirm the value in NumPy, print the dtype you observe for the result, and print ok.

Reals in $\mathbb{R}$ are exact, but float64 is not. Write NumPy code showing that 0.1 + 0.2 == 0.3 is False, then show that np.isclose(0.1 + 0.2, 0.3) is True, and print ok. In a comment, explain in one line why exact equality fails.

Modern deep learning increasingly trains in float16 / bfloat16 (16-bit) rather than float64. Give one concrete benefit of the lower-precision float, one concrete risk it introduces, and explain why an integer dtype is nonetheless still the right choice for token IDs and class labels. Tie each point back to the $\mathbb{Z}$-labels-versus-$\mathbb{R}$-measures distinction.

Solve $3x + 5 = 20$ for $x$.

Solve $5x - 3 = 2x + 9$ for $x$.

Solve $2x - 6 > 0$ and give the threshold value of $x$ (the boundary of the solution interval).

Solve $-2x > 6$ and give the boundary value of $x$. (Remember what happens to the relation when you divide by a negative.)

The line is $y = mx + b$. Solve for the intercept $b$ in terms of $y$, $m$, and $x$.

For the general linear equation $ax + b = 0$ with $a \neq 0$, what is the unique solution $x$?

Which single operation, applied to both sides of an inequality, reverses its direction (e.g. turns $<$ into $>$)?

In machine learning, a learning rate must satisfy $\eta > 0$ and a predicted probability must satisfy $0 \le p \le 1$. In one or two sentences, explain why these are written as inequalities rather than equations, and what would go wrong if a value violated its constraint.

In NumPy, p is a 1-D array of shape $(6,)$. What does the expression p >= 0.5 evaluate to?

A batch has $n$ examples. Each epoch processes the whole batch once, and you want to run enough epochs that the model sees at least $10{,}000$ examples total. Write an inequality for the number of epochs $E$ in terms of $n$, then solve it for $E$.

You solved $7x - 4 = 3x + 12$ by hand and got $x = 4$. Write NumPy code that substitutes $x = 4$ into both sides, asserts they agree with np.isclose, and prints ok.

The standardization (z-score) formula is $z = \dfrac{x - \mu}{\sigma}$ with $\sigma > 0$. Derive the formula that recovers the original value $x$ from a given $z$, showing each balanced move.

Generate 8 values with a fixed seed via rng = np.random.default_rng(0) and raw = rng.standard_normal(8) (these can fall outside $[0,1]$). Build a boolean mask of which entries already satisfy $0 \le \text{raw} \le 1$, then use np.clip to force all entries into $[0,1]$. Assert every clipped value satisfies the constraint and print ok.

A tiny training budget imposes two simultaneous constraints on the number of training steps $s$: memory allows $s \le 1000$, and you need enough steps to converge, $s \ge 200$. (1) Describe the set of valid $s$ as an interval. (2) Now suppose someone also requires $s \ge 1200$. Explain what happens to the feasible region and what that means practically. (3) Relate this to why an optimization problem can be infeasible.

Evaluate $\log_{2} 8$. (Read it as: '$2$ to what power gives $8$?')

Use $b^{m} b^{n} = b^{m+n}$ to evaluate $2^{3} \cdot 2^{4}$ as a single integer.

Write $\sqrt[3]{x^{2}}$ as a single power $x^{p}$. Enter the exponent $p$ as a decimal.

Evaluate $\log_{10} 1000$.

Evaluate $\ln\!\left(e^{5}\right)$.

Evaluate $2^{-3}$ as a decimal.

The statement $2^{5} = 32$ is written in exponential form. Which is its correct logarithmic form?

Which of the following is not a valid logarithm identity?

Using change of base $\log_{b} x = \dfrac{\ln x}{\ln b}$ with $\ln 10 \approx 2.302585$ and $\ln 2 \approx 0.693147$, evaluate $\log_{2} 10$. Give three decimals.

Training maximizes the log-likelihood $\sum_i \ln p_i$ rather than the raw likelihood $\prod_i p_i$. Give two distinct reasons this substitution is safe (same optimum) and better.

A model reports a total log-likelihood of $-23000$ over a dataset. Which statement is the best interpretation?

Write log_likelihood(p) that returns $\sum_i \ln p_i$ for a 1-D array of probabilities. Show that for $5000$ tiny probabilities the naive product np.prod(p) underflows to 0.0 while your log-space sum stays finite, then print ok.

Derive the quotient rule $\log_{b}\!\left(\tfrac{x}{y}\right) = \log_{b} x - \log_{b} y$ starting from an exponent law, for $x, y > 0$.

Implement logsumexp(z) computing $\ln\sum_k e^{z_k}$ with the max-subtraction trick, and show it agrees with the naive formula on safe inputs but does not overflow on large logits like z = [1000, 1001, 1002]. Print ok.

The log-sum-exp identity $\ln\sum_k e^{z_k} = m + \ln\sum_k e^{z_k - m}$ holds for any constant $m$. Prove the identity algebraically, then explain why the specific choice $m = \max_k z_k$ is the numerically safe one — addressing both overflow and underflow.

For a classifier that outputs probability $p_i$ on the correct class of example $i$, the average cross-entropy loss is $\mathcal{L} = -\tfrac{1}{N}\sum_i \ln p_i$. Explain why minimizing $\mathcal{L}$ is the same as maximizing the likelihood $\prod_i p_i$, and interpret the per-example loss $-\ln p_i$ as an amount of 'surprise' — including what happens as $p_i \to 0$ and as $p_i \to 1$.

Expand and compute $\sum_{i=1}^{4} (2i - 1)$.

How many terms does $\sum_{i=3}^{9} f(i)$ have?

For $A = \begin{pmatrix} 2 & 1 \\ 0 & 3 \end{pmatrix}$, compute $\sum_{i=1}^{2}\sum_{j=1}^{2} A_{ij}$.

Compute $\prod_{i=1}^{4} i$.

A classifier outputs probabilities $p = (0.2, 0.5, 0.3)$ over classes indexed $0, 1, 2$. What is $\arg\max_k p_k$ (use 0-based indexing)?

In the standard ML convention, what does $x^{(3)}$ denote?

A training set is written $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^{50}$. What is $|\mathcal{D}|$?

What does $\sum_{i \,:\, y_i = 1} x_i$ compute?

Training is written $\theta^\star = \arg\min_{\theta} L(\theta)$. What is $\theta^\star$?

You read $x^{(2)}_j$ in a paper. Which statement is correct?

In $p_k = \dfrac{e^{z_k}}{\sum_{j=1}^{K} e^{z_j}}$, which is true about the indices $k$ and $j$?

An algorithm runs in $\tfrac{1}{2}n^2 + 5n + 40$ operations. Its running time is:

Translate $L = \frac{1}{n}\sum_{i=1}^{n}(\hat{y}_i - y_i)^2$ into a function mse(yhat, y) using NumPy. Verify it on $\hat{y} = (2, 0, 3)$, $y = (1, 0, 5)$ (which should give $5/3$), then print ok.

Implement softmax(z) returning $p_k = e^{z_k}/\sum_j e^{z_j}$, confirm the output sums to $1$, and report the predicted class via np.argmax. Use $z = (2, 0, 1)$ and print ok.

The layer score is $z_i = \sum_{j=1}^{d} W_{ij} x_j$. Implement it two ways — an explicit double loop and W @ x — for a random $W$ of shape $(4, 3)$ and $x$ of length $3$ (fixed seed). Assert they agree and print match. In a comment, state the Big-O cost.

Prove the linearity fact $\sum_{i=1}^{n} c\,a_i = c \sum_{i=1}^{n} a_i$ for any scalar constant $c$, and explain why this justifies writing MSE with the $\frac{1}{n}$ outside the sum.

A paper reports that a dense layer costs $O(n \cdot d)$ (for $n$ tokens of dimension $d$) while self-attention costs $O(n^2 \cdot d)$. For a fixed $d$, if you double the sequence length $n$, by what factor does each cost grow? Then explain, using only Big-O reasoning, why attention becomes the bottleneck for long sequences even though both are 'polynomial'.

Using only the notation from this chapter, decode the (binary) cross-entropy loss $L = -\frac{1}{n}\sum_{i=1}^{n}\bigl[y_i \log \hat{y}_i + (1 - y_i)\log(1 - \hat{y}_i)\bigr]$. Identify each symbol and its type, expand the summand for a single example with label $y_i = 1$, and state in one sentence what the loss rewards.

Let $f(x) = 3x - 4$. Compute $f(5)$.

Let $f(x) = x + 3$ and $g(x) = 2x$. Compute $(g \circ f)(4)$.

For $f(x) = x + 3$ and $g(x) = 2x$, compute $(f \circ g)(4)$. (Compare with A2, where $(g \circ f)(4) = 14$.)

The function $f(x) = 2x + 1$ has inverse $f^{-1}(y) = \dfrac{y - 1}{2}$. Compute $f^{-1}(9)$.

For $f(x) = \dfrac{1}{x - 2}$ over the real numbers, which single value of $x$ must be excluded from the domain?

For $g(x) = x^2$ with domain all real numbers, what is the smallest value in the range?

A relation is graphed in the plane. Which single test decides whether it defines $y$ as a function of $x$?

Explain in one or two sentences the difference between the codomain and the range of a function $f: X \to Y$, using $f(x) = x^2$ with $X = Y = \mathbb{R}$ as an example.

Each function below has domain all of $\mathbb{R}$. Which one is invertible (one-to-one)?

A model is written $\hat{y} = f(x; \theta)$ and its loss $L(\theta)$. In one or two sentences, say which quantity is held fixed and which varies (a) at prediction time and (b) at training time, and why $L$ is written as a function of $\theta$ alone.

Let $f(x) = 3x - 1$ and $g(x) = x^2 + 2$. Derive closed-form expressions for $(g \circ f)(x)$ and $(f \circ g)(x)$, and confirm they are different functions.

The function $f(x) = \dfrac{x - 4}{3}$ is one-to-one on $\mathbb{R}$. Derive its inverse $f^{-1}(y)$ and verify $f^{-1}(f(x)) = x$.

Implement $f(x) = x + 1$ and $g(x) = x^2$ as Python functions. Using np.linspace(-3, 3, 7), evaluate $g \circ f$ and $f \circ g$ on the grid, confirm with np.allclose that they are not equal everywhere, and print ok.

A network layer is a function $f_\ell$, and an $L$-layer network is the composition $f_L \circ \cdots \circ f_1$. (a) Explain why stacking only linear layers $f_\ell(x) = W_\ell x$ gains no expressive power over a single linear layer. (b) Explain what a nonlinear activation inserted between layers changes. (c) Connect the composition structure to why the chain rule is central to training.

Compute $\sigma(0)$ for the sigmoid $\sigma(x) = \dfrac{1}{1 + e^{-x}}$.

Compute $\mathrm{ReLU}(-3) = \max(0, -3)$.

Compute $\mathrm{ReLU}(5) = \max(0, 5)$.

What is the range of $\tanh(x)$?

Using the course's Leaky ReLU with leak $\alpha = 0.1$, so $\mathrm{LReLU}(x) = x$ for $x \ge 0$ and $\alpha x$ for $x < 0$, compute $\mathrm{LReLU}(-4)$.

The sigmoid derivative is $\sigma'(x) = \sigma(x)(1 - \sigma(x))$. What is its maximum value?

Which of these hidden-layer activations is zero-centered (outputs symmetric about $0$)?

A plotted curve is $0$ for all negative inputs, then rises as a straight line of slope $1$ for positive inputs, with a sharp corner at the origin. Which function is it?

What is the range of softplus $\zeta(x) = \ln(1 + e^{x})$?

In a deep network of sigmoid layers, explain why pushing many neurons into their saturated regions (large $|x|$) makes the early layers train slowly. Reference the chain rule and the size of $\sigma'(x)$.

A binary classifier commonly uses ReLU in its hidden layers but a sigmoid on the final output neuron. Give the reason for each choice in one sentence.

Implement vectorized relu(x) and leaky_relu(x, alpha=0.1) for a 1-D NumPy array. Verify on x = np.array([-2.0, 0.0, 3.0]) that ReLU gives [0, 0, 3] and Leaky ReLU gives [-0.2, 0, 3], then print ok.

Implement softplus(x) that does not overflow for large inputs, and confirm softplus(1000.0) is finite (and $\approx 1000$) while the naive np.log(1 + np.exp(1000.0)) is inf. Also check numerically that the derivative of softplus equals the sigmoid. Print ok.

Show that $\sigma'(x) = \sigma(x)\,(1 - \sigma(x))$ for $\sigma(x) = (1 + e^{-x})^{-1}$.

Empirically show gradient vanishing: multiply together the sigmoid derivatives $\sigma'(z)$ across a stack of layers whose pre-activations are all saturated (e.g. $z = 6$). Compare the product for a 20-layer sigmoid stack against a 20-layer ReLU stack (per-layer derivative $1$ for $z > 0$). Print both products, assert the sigmoid product is far smaller, and print ok.

Before ~2011, deep networks used sigmoid/tanh and were notoriously hard to train past a few layers; switching to ReLU was a turning point. Explain the main mechanism by which ReLU improved trainability of deep nets, name at least one additional practical benefit, and state one drawback ReLU introduced (with a named remedy).

You are designing a network whose scalar output must be strictly positive (e.g. it predicts the variance $v$ of a Gaussian, or a rate parameter). Compare using $\mathrm{ReLU}$, $\exp$, and softplus $\zeta$ as the final activation. Which would you choose and why? Address the range, gradient behavior, and numerical stability of each.

What is the .shape of np.array([[1, 2, 3], [4, 5, 6]])? Enter it as a tuple, e.g. (2, 3).

An array has shape (2, 3, 4). What is its .ndim (its rank, the number of axes)?

On a 64-bit platform, what dtype does np.array([1, 2, 3]) get? Enter the dtype name, e.g. int64.

What is the output shape of np.arange(3).reshape(3, 1) + np.arange(4).reshape(1, 4)? Enter it as a tuple, e.g. (3, 4).

For A with shape (2, 3), what is the shape of A.sum(axis=0)? Enter it as a tuple, e.g. (3,).

What is np.array([1, 2, 3]) // 2? Enter the three resulting values as a, b, c.

Let A = np.arange(12).reshape(3, 4). What single value is A[1, 2]?

What is the output shape of an operation between an array of shape (4, 1) and an array of shape (3,)? Enter it as a tuple, e.g. (4, 3).

Which of the following pairs of shapes cannot be broadcast together?

You have A of shape (5, 3) and a vector v of shape (3,). What does A - v do, and what shape is the result?

a = np.array([1, 2, 3]) (int64) and b = np.array([1.0, 2.0, 3.0]) (float64). What is the dtype of a + b?

What is the value of (np.array([127], dtype=np.int8) + np.int8(1))[0]?

Given a batch X of shape (N, D), implement standardize(X) that returns (X - mu) / sigma, where mu and sigma are the per-feature (per-column) mean and standard deviation. Use axis and broadcasting — no Python loops. Verify the output has per-feature mean $\approx 0$ and std $\approx 1$, then print ok.

Given a non-negative array A of shape (N, D), implement row_normalize(A) so that each row sums to 1. Use keepdims=True so the row sums broadcast back onto A. Assert each row sums to 1, then print ok.

Write broadcast_shape(s1, s2) that returns the broadcast output shape (as a tuple) of two shapes, or raises ValueError if they are incompatible — implementing the rule by hand (do not call np.broadcast_shapes). Test that broadcast_shape((2, 1, 3), (4, 3)) == (2, 4, 3) and that (3, 4) with (3,) raises, then print ok.

Given A = np.arange(12).reshape(3, 4), use a boolean mask to extract all entries greater than 5 into a 1-D array, and separately use fancy indexing to build a new array from rows [2, 0] in that order. Assert the mask result equals [6, 7, 8, 9, 10, 11] and the fancy result has shape (2, 4), then print ok.

An engineer wants element-wise squared errors between predictions pred and targets true, both length-1000 vectors, and writes err = pred[:, None] - true[None, :], then mse = (err ** 2).mean(). The code runs but the reported MSE is wrong and memory usage spikes. Explain what shape err actually has, why it runs without error, what the correct one-liner is, and what single assertion would have caught the bug immediately.

Deep-learning frameworks default model weights and activations to float32, while NumPy defaults to float64. Give two concrete reasons float32 is preferred for large-scale training, one concrete risk it introduces, and one place in a pipeline where you would deliberately switch back to float64.

Let $\mathbf{a} = (2, -1, 3)$ and $\mathbf{b} = (4, 5, -2)$. Compute $\mathbf{a} \cdot \mathbf{b}$.

Compute $\mathbf{a} + \mathbf{b}$ for $\mathbf{a} = (1, 2)$ and $\mathbf{b} = (3, -5)$. Enter the result as x, y.

Compute $-2\,\mathbf{v}$ for $\mathbf{v} = (3, -1, 0)$. Enter as x, y, z.

Compute the Euclidean length $\lVert \mathbf{a} \rVert = \sqrt{\mathbf{a}\cdot\mathbf{a}}$ for $\mathbf{a} = (3, 4)$.

With $\mathbf{v}_1 = (1, 0)$ and $\mathbf{v}_2 = (0, 1)$, compute $3\mathbf{v}_1 + (-2)\mathbf{v}_2$. Enter as x, y.

Two vectors are orthogonal when their dot product is which value?

Two nonzero vectors have a negative dot product. Which is true about the angle $\theta$ between them?

In a neuron $z = \mathbf{w}^\top\mathbf{x} + b$, explain in one or two sentences what a large positive weight $w_i$ means about feature $x_i$'s influence on $z$, and what a weight near zero means.

If $\mathbf{a}, \mathbf{b} \in \mathbb{R}^{768}$ (say, two word embeddings), what is the shape of $\mathbf{a}\cdot\mathbf{b}$?

Show that the dot product is commutative: $\mathbf{a}\cdot\mathbf{b} = \mathbf{b}\cdot\mathbf{a}$ for all $\mathbf{a},\mathbf{b}\in\mathbb{R}^n$.

Implement cosine_similarity(a, b) for two 1-D NumPy arrays, returning $\dfrac{\mathbf{a}\cdot\mathbf{b}}{\lVert a\rVert\,\lVert b\rVert}$. Verify it returns approximately 1.0 for two parallel vectors, then print ok.

Write dot_loop(a, b) (an explicit Python loop) and dot_vec(a, b) (using @). Generate a, b of length 100000 with a fixed seed, confirm the results agree with np.isclose, and print match. In a comment, state which is faster and why.

The projection of $\mathbf{a}$ onto $\mathbf{b}$ is the vector $\mathbf{p} = t\,\mathbf{b}$ such that the error $\mathbf{a} - \mathbf{p}$ is orthogonal to $\mathbf{b}$. Derive $t$.

Retrieval systems and embedding papers usually rank by cosine similarity rather than the raw dot product. Give a concrete example of vectors where the raw dot product is misleading but cosine is not, explain what property cosine adds, then name one situation where the raw dot product is the right choice.

Compute the L2 (Euclidean) norm $\lVert\mathbf{x}\rVert_2$ of $\mathbf{x} = (3, 4)$.

Compute the L1 (Manhattan) norm $\lVert\mathbf{x}\rVert_1$ of $\mathbf{x} = (3, -4)$.

Compute the L∞ (max) norm $\lVert\mathbf{x}\rVert_\infty$ of $\mathbf{x} = (-2, 5, -7, 1)$.

Compute the Euclidean distance $d(\mathbf{a}, \mathbf{b})$ between $\mathbf{a} = (1, 2)$ and $\mathbf{b} = (4, 6)$.

Compute the cosine similarity of $\mathbf{a} = (1, 0)$ and $\mathbf{b} = (0, 3)$.

Compute the cosine similarity of $\mathbf{a} = (2, 1)$ and $\mathbf{b} = (6, 3)$.

For any vector $\mathbf{x}$, which chain of inequalities among its L1, L2, and L∞ norms always holds?

You want a regression model that sets many weights to exactly zero for feature selection. Do you add an L1 or an L2 penalty to the loss, and what is the resulting method called?

A colleague computes the 'distance' between $\mathbf{a} = (3, 0)$ and $\mathbf{b} = (0, 3)$ as $\lVert\mathbf{a}\rVert_2 - \lVert\mathbf{b}\rVert_2$ and gets $0$, concluding the points coincide. In one or two sentences, explain the error and give the correct Euclidean distance.

A document embedding $\mathbf{d}$ and the same document repeated twice, embedded as roughly $2\mathbf{d}$, should be judged equally relevant to a query $\mathbf{q}$. Explain in one or two sentences why cosine similarity gives the same score for $\mathbf{d}$ and $2\mathbf{d}$ but the raw dot product does not.

Ridge regression penalizes $\lVert\mathbf{w}\rVert_2^2$, not $\lVert\mathbf{w}\rVert_2$. Give the main reason the squared norm is preferred as the penalty term.

Implement lp_norm(x, p) for a 1-D NumPy array, returning $\left(\sum_i |x_i|^p\right)^{1/p}$, and handle p = np.inf as the max norm. Verify against np.linalg.norm(x, ord=p) for $p = 1, 2, \infty$ on $\mathbf{x} = (3, -4)$, then print ok.

Implement cosine(a, b) returning $\dfrac{\mathbf{a}\cdot\mathbf{b}}{\lVert a\rVert_2\,\lVert b\rVert_2}$, but return 0.0 if either vector is the zero vector (so it never emits nan). Clamp the result to $[-1, 1]$. Verify it gives 1.0 for parallel vectors, 0.0 for orthogonal ones, and 0.0 for a zero input, then print ok.

Starting from the geometric form of the dot product, $\mathbf{a}\cdot\mathbf{b} = \lVert\mathbf{a}\rVert_2\,\lVert\mathbf{b}\rVert_2\cos\theta$, derive the cosine similarity formula and explain why the result must lie in $[-1, 1]$ and why it is scale-invariant.

Ridge (L2) and Lasso (L1) both shrink weights, yet only Lasso drives many of them to exactly zero. Using the geometry of the L1 and L2 unit balls in 2-D, explain why the L1 constraint favors solutions on the axes (sparse) while the L2 constraint does not. Then name one concrete situation where you would deliberately prefer L2 over L1.

$\mathbf{A}$ has shape $(2, 3)$ and $\mathbf{B}$ has shape $(3, 4)$. What is the shape of $\mathbf{A}\mathbf{B}$? Enter as (rows, cols).

Let $\mathbf{A} = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix}$ and $\mathbf{x} = (1, 1)$. Compute $\mathbf{A}\mathbf{x}$. Enter as y1, y2.

For $\mathbf{A} = \begin{bmatrix} 2 & 4 & 6 \\ 8 & 10 & 12 \\ 14 & 16 & 18 \end{bmatrix}$, what is A[1][2] using 0-based indexing (as in NumPy: row first, column second)?

$\mathbf{A}$ has shape $(5, 2)$. What is the shape of $\mathbf{A}^\top$? Enter as (rows, cols).

Compute $\mathbf{A} + \mathbf{B}$ for $\mathbf{A} = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix}$ and $\mathbf{B} = \begin{bmatrix} 10 & 20 \\ 30 & 40 \end{bmatrix}$. Enter the entries row by row: a11, a12, a21, a22.

Compute $\operatorname{tr}(\mathbf{A})$ for $\mathbf{A} = \begin{bmatrix} 3 & 1 & 0 \\ 2 & 5 & 7 \\ 1 & 0 & 4 \end{bmatrix}$.

With $\mathbf{A}$ of shape $(3, 5)$, $\mathbf{B}$ of shape $(5, 2)$, and $\mathbf{C}$ of shape $(2, 7)$, what is the shape of $\mathbf{A}\mathbf{B}\mathbf{C}$? Enter as (rows, cols).

Let $\mathbf{A}$ have shape $(2, 3)$ and $\mathbf{B}$ have shape $(3, 2)$. Which statement is correct?