Something like this has come up recently.
We could just use types like std::int32_t instead in these examples.
Then the examples clearly work, and clearly depend on those types being present.
Is anyone's stance known to be against that?

Something like this has come up recently. We could just use types like std::int32_t instead in these examples. Then the examples clearly work, and clearly depend on those types being present. Is anyone's stance known to be against that?

I'm not opposed to int32_t, but I will point out that there's no guarantee that sizeof(int32_t) > 1.

So this kind of example only needs an "assumes CHAR_BIT is 8" clause, right?

So this kind of example only needs an "assumes CHAR_BIT is 8" clause, right?

Or equivalently, static_assert(sizeof(std::int32_t) == 4) which simultaneously requires int32_t to exist and CHAR_BIT to be 8.

Well, examples would require #include <cstdint>.
Maybe the first of these examples
should describe the parameters to the instance of the abstract machine they work on
and have the other similar examples refer to that.

So adding

+#include <cstdint>
+static_assert(sizeof(std::int32_t) == 4);

and changing the integer type keywords to the appropriate std:: type,
vs.

+// Assume the abstract machine described in \ref{that.first.example}.

for the rest of the examples.

Note [basic.align] p1:

An alignment is an implementation-defined integer value representing the number of bytes between successive addresses at which a given object can be allocated.

alignas(int) A a; can only guarantee the address (named A) of a satisfy the alignment of int, however, in the fix, we intend to use A + n * sizeof(int) to prove the result addresses satisfy the alignment, note that this is true only if sizeof(int) equal to alignof(int) because [basic.align] p1 only mention the alignment value, anyway, sizeof(int) and alignof(int) are both implementation-defined values that are not necessary the same.

anyway, sizeof(int) and alignof(int) are both implementation-defined values that are not necessary the same.

This is OK. Assuming that sizeof(int) is 4, alignof(int) must be 1, 2, or 4, and each of these values is OK for the example.

Assuming that sizeof(int) is 4, alignof(int) must be 1, 2, or 4

However, there is no wording in the current standard that says the value of alignof(int) must be less or equal to sizeof(int), if alignof(int) is 8 and sizeof(int) is 4, it will be an issue.

However, there is no wording in the current standard that says the value of alignof(int) must be less or equal to sizeof(int), if alignof(int) is 8 and sizeof(int) is 4, it will be an issue.

This is not possible, because in such an implementation, if you have int a[20];, every second int in that array will be misaligned, which can't be.