Problem: Let $P_1$, $P_2$, \dots, $P_{2n}$ be $2n$ distinct points on the
unit circle $x^2+y^2=1$, other than $(1,0)$.
Each point is colored either red or blue,
with exactly $n$ red points and $n$ blue points.
Let $R_1$, $R_2$, \dots, $R_n$ be any ordering of the red points.
Let $B_1$ be the nearest blue point to $R_1$ traveling
counterclockwise around the circle starting from $R_1$.
Then let $B_2$ be the nearest of the remaining blue points to $R_2$
traveling counterclockwise around the circle from $R_2$, and so on,
until we have labeled all of the blue points $B_1$, \dots, $B_n$.
Show that the number of counterclockwise arcs of the form $R_i \to B_i$
that contain the point $(1,0)$ is independent of the way we chose the
ordering $R_1$, \dots, $R_n$ of the red points.

\end{enumerate}

Solution: We present two solutions, one based on
swapping and one based on an invariant.

\paragraph{First ``local'' solution by swapping two points.}
Let $1 \le i < n$ be any index and consider the two red points
$R_i$ and $R_{i+1}$.
There are two blue points $B_i$ and $B_{i+1}$ associated with them.

\begin{claim*}
  If we swap the locations of points $R_i$ and $R_{i+1}$ then
  the new arcs $R_i \to B_i$ and $R_{i+1} \to B_{i+1}$
  will cover the same points.
\end{claim*}
\begin{proof}
  Delete all the points $R_1$, \dots, $R_{i-1}$
  and $B_1$, \dots, $B_{i-1}$;
  instead focus on the positions of $R_i$ and $R_{i+1}$.

  The two blue points can then be located in three possible ways:
  either $0$, $1$, or $2$ of them lie on the arc $R_i \to R_{i+1}$.
  For each of the cases below, we illustrate on the left
  the locations of $B_i$ and $B_{i+1}$
  and the corresponding arcs in green;
  then on the right we show the modified picture
  where $R_i$ and $R_{i+1}$ have swapped.
  (Note that by hypothesis there are no other blue points in the green arcs).
  \begin{center}
  \begin{asy}
    unitsize(1cm);
    pair O = (0,0);
    picture init(bool flip) {
      picture pic;
      draw(pic, unitcircle);
      if (flip) {
        dot(pic, "$R_{i}$", dir(0), dir(0), red);
        dot(pic, "$R_{i+1}$", dir(180), dir(180), red);
      }
      else {
        dot(pic, "$R_{i+1}$", dir(0), dir(0), red);
        dot(pic, "$R_{i}$", dir(180), dir(180), red);
      }
      return pic;
    }

    picture L1 = init(true);
    picture L2 = init(true);
    picture L3 = init(true);
    picture R1 = init(false);
    picture R2 = init(false);
    picture R3 = init(false);

    real r = 0.8;
    real s = 0.9;

    // Case 1
    dot(L1, "$B_i$", dir(60), dir(60), blue);
    dot(L1, "$B_{i+1}$", dir(120), dir(120), blue);
    dot(R1, "$B_i$", dir(60), dir(60), blue);
    dot(R1, "$B_{i+1}$", dir(120), dir(120), blue);
    draw(L1, arc(O, r,   0,  60), deepgreen, EndArrow(TeXHead));
    draw(L1, arc(O, s, 180, 480), deepgreen, EndArrow(TeXHead));
    draw(R1, arc(O, r, 180, 420), deepgreen, EndArrow(TeXHead));
    draw(R1, arc(O, s,   0, 120), deepgreen, EndArrow(TeXHead));
    dot(L1, dir(140), blue);
    dot(L1, dir(150), blue);
    dot(R1, dir(140), blue);
    dot(R1, dir(150), blue);

    // Case 2
    dot(L2, "$B_i$", dir(90), dir(90), blue);
    dot(L2, "$B_{i+1}$", dir(270), dir(270), blue);
    dot(R2, "$B_i$", dir(270), dir(270), blue);
    dot(R2, "$B_{i+1}$", dir(90), dir(90), blue);
    draw(L2, arc(O, s,   0,  90), deepgreen, EndArrow(TeXHead));
    draw(L2, arc(O, s, 180, 270), deepgreen, EndArrow(TeXHead));
    draw(R2, arc(O, s, 180, 270), deepgreen, EndArrow(TeXHead));
    draw(R2, arc(O, s,   0,  90), deepgreen, EndArrow(TeXHead));
    dot(L2, dir(128), blue);
    dot(L2, dir(155), blue);
    dot(R2, dir(128), blue);
    dot(R2, dir(155), blue);
    dot(L2, dir(297), blue);
    dot(L2, dir(335), blue);
    dot(R2, dir(297), blue);
    dot(R2, dir(335), blue);

    // Case 3
    dot(L3, "$B_i$", dir(240), dir(240), blue);
    dot(L3, "$B_{i+1}$", dir(300), dir(300), blue);
    dot(R3, "$B_i$", dir(240), dir(240), blue);
    dot(R3, "$B_{i+1}$", dir(300), dir(300), blue);
    draw(L3, arc(O, r,   0, 240), deepgreen, EndArrow(TeXHead));
    draw(L3, arc(O, s, 180, 300), deepgreen, EndArrow(TeXHead));
    draw(R3, arc(O, r, 180, 240), deepgreen, EndArrow(TeXHead));
    draw(R3, arc(O, s,   0, 300), deepgreen, EndArrow(TeXHead));
    dot(L3, dir(328), blue);
    dot(L3, dir(342), blue);
    dot(R3, dir(328), blue);
    dot(R3, dir(342), blue);


    real t = 3.5;
    add(shift(0,0)*L1);
    add(shift(t,0)*R1);
    add(shift(0,-t)*L2);
    add(shift(t,-t)*R2);
    add(shift(0,-2*t)*L3);
    add(shift(t,-2*t)*R3);

    label("Case 1", (-2.5,0));
    label("Case 2", (-2.5,-t));
    label("Case 3", (-2.5,-2*t));
  \end{asy}
  \end{center}
  Observe that in all cases, the number of arcs covering
  any given point on the circumference is not changed.
  Consequently, this proves the claim.
\end{proof}

Finally, it is enough to recall that any permutation
of the red points can be achieved by swapping consecutive points
(put another way: $(i \; i+1)$ generates the permutation group $S_n$).
This solves the problem.

\begin{remark*}
  This proof does \emph{not} work if one tries to swap
  $R_i$ and $R_j$ if $|i-j| \neq 1$.
  For example if we swapped $R_i$ and $R_{i+2}$
  then there are some issues caused by the
  possible presence of the blue point $B_{i+1}$
  in the green arc $R_{i+2} \to B_{i+2}$.
\end{remark*}

\paragraph{Second longer solution using an invariant.}
Visually, if we draw all the segments $R_i \to B_i$
then we obtain a set of $n$ chords.
Say a chord is \emph{inverted} if satisfies the problem condition, and \emph{stable} otherwise.
The problem contends that the number of stable/inverted chords
depends only on the layout of the points and not on the choice of chords.

\begin{center}
\begin{asy}
size(6cm);
pair A(int i) { return dir(22.5+45*i); }

draw(unitcircle, gray);
dot("$(1,0)$", dir(0), dir(0));

dotfactor *= 2;
draw(A(7)--A(0), EndArrow, Margins);
draw(A(1)--A(2), EndArrow, Margins);
draw(A(3)--A(5), EndArrow, Margins);
draw(A(4)--A(6), EndArrow, Margins);

dot("$-1$", A(0), A(0), blue);
dot("$0$", A(1), A(1), red);
dot("$-1$", A(2), A(2), blue);
dot("$0$", A(3), A(3), red);
dot("$+1$", A(4), A(4), red);
dot("$0$", A(5), A(5), blue);
dot("$-1$", A(6), A(6), blue);
dot("$0$", A(7), A(7), red);
\end{asy}
\end{center}

In fact we'll describe the number of inverted chords explicitly.
Starting from $(1,0)$ we keep a running tally of $R-B$;
in other words we start the counter at $0$ and decrement by $1$ at each
blue point and increment by $1$ at each red point.
Let $x \le 0$ be the lowest number ever recorded. Then:
\begin{claim*}
  The number of inverted chords is $-x$
  (and hence independent of the choice of chords).
\end{claim*}

This is by induction on $n$.
I think the easiest thing is to delete chord $R_1 B_1$;
note that the arc cut out by this chord contains no blue points.
So if the chord was stable certainly no change to $x$.
On the other hand, if the chord is inverted,
then in particular the last point before $(1,0)$ was red, and so $x < 0$.
In this situation one sees that deleting the chord changes $x$ to $x+1$, as desired.