Set of set of pairings to cover all combinations but are disjoint for each subset I am not familiar with nomenclature of these specific problems, so maybe I am banging my head with something very obvious but I have been unable to find a constructive procedure or a general counterexample.
And let me apologize for an horrendous title. Could not come up with anything better. Suggestions are welcome.
I have $S = \lbrace 1, 2, \ldots n\rbrace$. I want to build the following:
$ T_1 \ldots T_k$
where
$T_i = \lbrace (a^{i}_{1}, b^{i}_{1}), \ldots, (a^{i}_{m}, b^{i}_{m})\rbrace$
$ a^{i}_{t} \neq b^{i}_{s} \quad \forall t, s$
$ a^{i}_{t} \neq a^{i}_{s} \quad \forall t \neq s$
$ b^{i}_{t} \neq b^{i}_{s} \quad \forall t \neq s$
satisfying the following:
$ \bigcup\limits_{i=1}^{k} T_i = \lbrace (a, b) \in S \times S \mid a < b \rbrace$
Optimally, $ m = \frac{n}{2}$ and also $T_i \cap T_j = \emptyset \quad \forall i \neq j$
Thoes that set of $T_i$ always exist? I was expecting to find an easy constructive way to find it, but I have been struggling. If what I call optimal is impossible in certain cases, which is the best (minimal number of $T_i$)?
Written in a less LaTeX-y fashion: I want to find a way to cover all combinations of elements of S in a way that for each "step" I have a set of pairs that are disjoint, and when the last step is done, all the combinations have been picked once. My motivation comes from an algorithmic parallellism point of view, but I think that the mathematic foundation is properly set up.

Edit: Some examples
An almost degenerate $n = 3$:
$T_1 = \lbrace(1,2)\rbrace$
$T_2 = \lbrace(2,3)\rbrace$
$T_3 = \lbrace(1,3)\rbrace$
An example of "optimal" for $n = 4$:
$T_1 = \lbrace(1, 2), (3, 4)\rbrace$
$T_2 = \lbrace(1, 4), (2, 3)\rbrace$
$T_3 = \lbrace(1, 3), (2, 4)\rbrace$
 A: After some failed attempts I came up with a constructive algorithm for $n = 2^k$ that seems to work.
Procedure:
Split $S$ into two halves, $A$ and $B$. Generate all the $T_i$ that, for each pair, contain an element of A and an element of B. There are $\frac{n}{2}$ different $T_i$:
$T_1 = \lbrace (a_1, b_1), (a_2, b_2) \ldots \rbrace$
$T_2 = \lbrace (a_1, b_2), (a_2, b_3) \ldots \rbrace$
$T_k = \lbrace (a_1, b_k), (a_2, b_{k+1}) \ldots \rbrace$
etc. Note that the $b$ subindex have "rollover", so they are evaluated modulus cardinality of $B$.
Each of those $T_i$ is a valid $T$ of $S$.
After that, split $A$ into $A_1$, $A_2$ and $B$ into $B_1$ and $B_2$. Following the same procedure, build the $T^A_i$ elements and $T^B_i$ ones.
It's immediate to note that, for any $i$, $T^A_i \cup T^B_i$ is a valid $T$ of $S$.
Those steps are repeated until it's not possible to halve anymore.
Unless I have an error somewhere in my explanation, my empiric tests show that it is correct and if one checks cardinality of the $T$ one can see that it is satisfies the "optimal" criteria (minimum number of $T$).
If anyone is interested in the algorithm of this procedure, I made a gist in Python in order to test and validate it.
