Is there an algorithm to merge $d$ chains into $\left\lceil\frac{d}{k}\right\rceil$ chains?

Question

I've come up with a problem as follow:

Given an integer $k > 1$, a queue $Q$ as a permutation of integers $1$ to $N$. You can apply an operation to the queue as follows:

• split the queue into no more than $k$ subqueues by repeatedly moving the front element of the main queue to the back of one of the $k$ subqueues until the main queue is empty.
• merge the $k$ subqueues into one by repeatedly moving the front element of one of the $k$ subqueues to the back of the main queue until all subqueues are empty.

The problem is how many number of operations are required to sort the queue into decreasing sequence.

For example: the case where $k = 2$ and $Q$ is 5 2 1 4 3, we can split the queue into

1. 5 4 3
2. 2 1

and merge into 5 4 3 2 1 in one operation.

Another example: the case where $k = 2$ and $Q$ is 5 1 2 4 3, we can split the queue into

1. 5 4 3
2. 1 2

and merge into 1 5 4 3 2 then split into

1. 1
2. 5 4 3 2

then merge into 5 4 3 2 1, using the operation two times. (There are other ways, but still they end up using at least two times.)

I think the operation is related to maintenance of the minimum number of increasing subsequences required to cover the queue. For better picture, I'd represent the queue as a poset of $\mathbb{N}_N$ with $a \preceq b$ if and only if $a \leq b$ and $Q(a) \geq Q(b)$. The minimum number of increasing subsequences required to cover the queue would be exactly the width of the poset. And by Dilworth's Theorem, it would be equal to the length of longest increasing subsequence of the queue as an array.

For simplicity, let's denote the minimum number of increasing subsequences required to cover the queue $Q$ as $\chi(Q)$. Obviously, this is the same as the width of poset $\mathbb{N}_N, \preceq$. Also, for simplicity, let's call this the width of the queue. As stated by Dilworth's Theorem, $\chi(Q) = |LIS(Q)|$, where $|LIS(Q)|$ denotes the length of longest increasing subsequence of $Q$ as an array.

I've come up with a conjecture that in each operation, if done efficiently, would reduce the width by about a factor of $\frac{1}{k}$. That is, there exists an algorithm satisfying the conditions of an operation such that $\chi(Q) \mapsto \left\lceil\frac{\chi(Q)}{k}\right\rceil$.

It is not hard to see that if the conjecture is true, then the answer to the problem will be $\lceil \log_k{\chi(Q)} \rceil$.

My first intuition was that if we decompose the queue poset into $\chi(Q)$ chains, we should be able to group each $k$ chains together into $\left\lceil\frac{\chi(Q)}{k}\right\rceil$ groups of no more than $k$ chains, and each group could be merged to one in a single operation. I thought this is obviously proved, but it turns out to be unproved. There are cases where randomly grouping chains leads to collision, that is, the groups cannot be merged properly.

My next intuitions were about drawing Hasse diagrams as DAG and observe the properties of it. I thought that if each step of picking chains to form the decomposition, we try to pick the longest chain possible, then it should satisfy the conjecture. But this also turns out to be false. There are cases where groups cannot be merged properly.

Therefore, I'm looking for some proof (or disproof with counterexamples) about the stated conjecture.