Cumulative checkpoint: programming and discrete reasoning

A weighted history, not a sum

The states are $3$, $2(3)-2=4$, and $2(4)+5=13$. With inputs $v_1,\ldots,v_n$, let $t_0=0$ and $t_k=2t_{k-1}+v_k$. Earlier inputs are repeatedly doubled; for three inputs, $t_3=4v_1+2v_2+v_3$, which gives $12-4+5=13$. An ordinary prefix sum instead satisfies $s_k=s_{k-1}+v_k$. This derivation explains the observed state rather than merely quoting the printed output.

The outer containers differ; one inner mutation is shared

Final a is [[1,7],[2]]; final b is [[1,7],[2],[3]]. The shallow copy created a new outer list containing references to the same two inner lists. Appending to the first inner list affects the shared object seen through both names. Appending a third inner list to b changes only that outer list. A memory diagram with two outer containers pointing to shared inner containers makes both effects predictable.

A reference cannot extend the destroyed local object’s lifetime

The local vector is destroyed when the function returns, so a reference to it dangles. Using it is invalid even if the old memory appears intact. Returning by value transfers a valid result object under C++ value semantics, with move or copy-elision behavior as applicable; the caller owns the resulting lifetime. Returning a reference to caller-owned storage can be valid only while that storage remains alive and under a clear mutation/invalidation contract. The choice is about ownership and API semantics, not a blanket rule that references are always faster.

Negate quantifiers in order

The negation is: there exists a request such that every server fails to eventually reply to that request. In symbolic form, $\neg\forall r\exists s\,R(r,s)$ becomes $\exists r\forall s\,\neg R(r,s)$. The original permits the chosen server to depend on the request. For example, one server may answer odd-numbered requests and another even-numbered requests; every request has a responder, but neither server answers all requests. This is not the same as $\exists s\forall r\,R(r,s)$.

Use the induction hypothesis as a divisible factor

For $n=0$, $4^0-1=0$, divisible by $3$. Assume $4^n-1=3k$ for an integer $k$. Then $4^{n+1}-1=4(4^n-1)+3=12k+3=3(4k+1)$, also divisible by $3$. Therefore the claim holds for all nonnegative integers by induction. The proof does not assume the desired next case; it constructs its integer factor from the current case.

A cost recurrence and an implementation domain are different

For $n=2^m$, after $m$ halvings the argument reaches one. Unrolling gives $T(n)=T(1)+m=1+\log_2n$. A literal real-valued halving routine on input $3$ never reaches exactly one, while an integer routine must specify floor/ceiling and a base condition such as $n\le1$. The mathematical recurrence’s stated power-of-two domain made the base reachable. An implementation on a larger domain needs a new termination argument and possibly a different exact recurrence.