Suppose L is a language on an alphabet Σ for which there are only a finite number of types for
S(w) = {x: wx ∈ L}.
We wish to show L is a regular language; we shall construct a finite state machine (a DFA) which recognises L. Let T be the (finite!) set {S(w) : w ∈ Σ*} (T is the set of types of S(w)). T shall be the set of our automaton's states.
When in some state S(w), upon reading some letter a∈Σ of the alphabet, the automaton will switch to state S(wa). We must show this is well defined: if S=S(w)=S(u) for 2 words w, u, we must show S(wa)=S(ua). So suppose x is in S(w), and begins with a: x=ay. Then we know wx=way is in L, and thus y is in S(wa); all y's in S(wa) are of this form. But for such an x, x is in S(u)=S(w), so ux=uay is in L, and thus y is also in S(ua). Now switch u and w in the argument above, and conclude that S(ua)=S(wa). The set of accepting states of our automaton shall be F = {S(w): w is in L}, and the initial state shall be S() = S(ε) (ε is the empty word). It is straightforward (and left as an exercise for the reader) to verify that this does indeed define a DFA, which accepts L).
Also note that we have shown that L is accepted by an automaton with |T| states.
Now suppose L is a regular language; we wish to show S(w) takes on finitely many types. Consider some DFA accepting L. For each of our automaton's k state s, define W(s) = {w : after reading w, the automaton is in state s}. Then if w,u are in W(s), we know S(w)=S(u) (if wx is in L, then we may read u, reaching state s, then read x and reach an accepting state; thus ux is also in L). So S(w) takes on at most k types -- a finite number.
Also note that we have shown |T| ≤ k, so |T| is indeed the minimal number of states in a DFA accepting L.