Can you either expand on that one or link me to sources that do? I think I follow, but I'd like more info
(i1,s1) = step(i0,s0)
(i2,s2) = step(i1,s1)
...
(halt,sN) = step(i(N-1),s(N-1))
where i* is the instruction(s), s* is the state(s) and halt is the "program is done" instruction.
Think about it as a pure interpreter running an imperative program.
It is how imperative software is proven correct using pure languages like LEAN.
To get a Turing machine, you need to add one more constraint, which is that things only happen at one place at a time... but that "cursor" itself can (and must, if we want to do something nontrivial) walk across the working memory.
What no one is ever able to explain is: why is this a good thing?
The underlying machine does destructive assignment. The whole thing is a big mutable array. Why should we represent it in another way?
Optimizing deeply enough will eventually make any abstraction leaky though, so you'll never fully escape mechanical sympathy.
Because different representations have different properties which lets you perform different transformations. All compilers even for imperative languages use some variant of SSA in their intermediate languages, for example.
Viewing the CPU as a pure function from "state of the universe before a given clock cycle" to "state of the universe after said clock cycle" is not particularly helpful on its own, because you still need to care about all the state in the universe. What this change in perspective does however, is that it becomes a relatively small change to say "actually this part of the program doesn't care about the whole universe, and doesn't affect the whole resulting universe, only that tiny bit over there matters and only this tiny bit over here changes."
The win is that the compiler can help keep you honest about handling every possible state you depend on as input and that when you call a function, it doesn't unexpectedly change some state your function depends on behind your back. All the state you ever have to care about when writing a pure function is "what are my arguments, and what are the return values of functions I call?"