That's something possible, depending upon the set of axioms chosen.
Any demonstration that would use cardinal as a way to show this is impossible, is sure to fail: a definition of an infinite set is precisely that there exists an injection from that set to one of its proper subsets.
See Example of set which contains itself for the case of sets: a specific axiom, the axiom of foundation, is added to forbid sets that contain themselves. This page also refers a Wikipedia page where is described the anti-foundation axiom, the opposite of the foundation axiom - this shows maths can be done with another principle, although of course with surprising consequences.
With tuples, it may depend upon how you define them: tuples in maths are not a primary concept such as sets. It could be defined as:
- An $n$-tuple of elements of $E$ is a function from $\mathbb{N}^n$ to $E$. The set of tuples on $E$ is then $T= \cup_{n=0}^\infty \{ \text{functions: } \mathbb{N}^n \to E\}$. With this definition, a tuple having itself as element would mean $E$ includes some part of $T$. We could try defining $f$ such that $f(E)=T$, and look for its fixed point. However what would be the domain and range of $f$? We would not choose the set of all sets, as it is prohibited in usual theories; there does not seem to be another simple choice.
- A tuple of elements of $E$ is a finite subset of $E$ with a total order on that subset. Then, to have a tuple which includes itself, we would need a finite subset of $E$ that contains $E$ as an element, i.e $E$ is an element of itself, which is prohibited in usual theories.
So it seems that: if sets that contain themselves are prohibited, tuples that contain themselves are also prohibited.
In computer science, having objects that refer to themselves, directly or indirectly, is common. Example of constructing in Python an immutable object that refers to itself: https://stackoverflow.com/questions/11873448/building-self-referencing-tuples
There is also a common way of recursively defining an infinite object, such as $\mathbb{N}$, in languages such as Haskell which use lazy evaluation. It is as simple as:
nats :: [Int]
nats = 0 : map (+1) nats
It says nats contains $0$, then a copy of itself with each element incremented by $1$.
This to show that programming languages can easily model math concepts as infinity or containing oneself, which we intuitively think as non applicable to real world objects.