*3. There are algorithms which run in polynomial time in the Turing machine model, but not in the arithmetic model. The Euclidean algorithm for computing the greatest common divisor of two integers is one example.*
 
The issue in the above question lies in the definition of the *running time* that we are trying to bound. If we expand, we have to say: "...runs (or doesn't run) in the number of steps that is polynomial in the length of encoded input". The catch is that the "steps" and "length of encoded input" are defined differently for the two models.

 * For a Turing Machine, the encoded input is taken as some concatenation of the binary representations of the input integers with separators. Its length is then $l_{TM} = 2\log a + 1$ where $a$ is the larger of the two integers. A step is a action of the TM head.

 * For an arithmetic model, the length of encoded input is defined as the number of numbers occurring in the input. For the Euclid's GCD this length is constant $l_{AM}=2$. A step is an arithmetic operation.

For $a,b, a>b$, input integers, the algorithm takes $O(\log b)$ iterations, with a division at each iteration.

* The division in a TM takes $O(\log^2 a)$ steps. Hence, the total number of TM steps is $O(\log^2 a\log b)=O(l_{TM}^3)$ (conservatively speaking). That is, the polynomial $P_{TM}(l_{TM})=l_{TM}^3$ in the length of encoded input bounds the TM running time.

* Under arithmetic model the number of steps is equal to the number of divisions $O(\log b)$. Since the value of any polynomial $P(l_{AM})$ is constant, for any choice of $P(l_{AM})$ we can always find a problem instance that takes more divisions than $P(l_{AM})$. That is, we cannot bound the running time with a polynomial in the length of encoded input.

*If an algorithm runs in polynomial time in the Turing machine, will it run in polynomial time in the arithmetic model?*

Repeated-squaring with a unary-encoded exponent as input is one example which runs in polynomial time under arithmetic model, but in exponential time under TM, since multiplication is no longer $O(1)$. E.g. given as input $n$ *encoded as unary*, to compute $2^{2^n}$, we need $\log 2^n = n$ multiplications, but each multiplication will eventually be multiplying $2^n$-bit numbers, which takes $O(2^{2n})$ TM-steps. Note that if the input exponent were binary-encoded, then the $n$ multiplications would be an exponential in the size of input.

Putting the two examples together, polynomial TM running time does not imply polynomial arithmetic running time, nor vice-a-versa.

Drawn from a reading of Wikipedia's primary source:

[1] Grötschel, Martin; László Lovász, Alexander Schrijver (1988). "Complexity, Oracles, and Numerical Computation". Geometric Algorithms and Combinatorial Optimization. Springer. ISBN 0-387-13624-X.