**Possible Proof for Wing Edges**
I think I have an idea of how to prove this, at least for a single orbit of wings in the nxnxn.

Almost everyone who knows how to solve a 4x4x4 cube knows Stefan's PLL Parity algorithm,

r2 F2 U2 r2 U2 F2 r2. Some know that this is just a conjugate of the move r2, as it can be expressed as

[r2 F2 U2: r2].

Now, I can comfortably make the claim (without any possibility of doubt) that ANY 2 2-cycle of wing edges case in the "cage" of big cubes can also be made with a conjugate of the move r2. Like Stefan's alg, they of course will not be supercube safe, but I will later show that this will not be an issue (if you are concerned about having a supercube safe commutator).

For those who have never seen the two 2 2-cycle of wings algorithms I made in the past, see

Algs_Sorted.pdf,

2 2-cycles.pdf, and the F3L documents in

this post just to get an idea of what I mean by 2 2-cycle conjugates, in general.

In addition, we can create every 2 2-cycle of wing cases in the "cage" of big cubes by just conjugating the move r2.

Note that we can generate any even permutation with products of 2 2-cycles because every 2 2-cycle can be expressed as a product of two overlapping 3-cycles.

So suppose we have a conjugate A for one 2 2-cycle of wings A X A', where X = r2. In addition, we have a different conjugate B, for another 2 2-cycle of wings: B X B'. (Note that in both algorithms, X is present because I previously claimed that every 2 2-cycle case can be expressed as a conjugate of the same move, r2).

Now, a few posts ago in this thread, I showed that the move r2 can be expressed as the commutator

[D2 r' D2 F2 l' U2 l U2 r' U2 r U2 F2 r D2 r D2, r] for the nxnxn.

So both A X A' and B X B' are commutators since the equality [O:[P,Q]] = [[O

],[O:Q]] holds.

If we multiply these two commutators, we have

A X A' B X B'

Since r2 = (r2)'

= A X A' B X' B'

Now, the commutator B' A X A' B X' can be conjugated to obtain the above:

B

B' A X A' B X'

B'

= A X A' B X' B'

, which shows that the product (A X A') (B X B') merges to the commutator [B: [B' A, X] ].

Now, if we were to multiply three 2 2-cycles together,

**where each 2 2-cycle is composed of only one conjugation of the move r2**, then we would have a problem because we would have an odd number of Xs (X = r2 = commutator). Since a commutator must have an even number of every move it contains, then these three 2 2-cycles could not possibly be merged to a single commutator.

However, note that we can freely create each and every 2 2-cycle of wings with two 2 2-cycle of wings. Here are two examples of this:

([l2 U' B2 U' x U' R' U: l2] ) (y' [R B: [l2 U' F2 U': l2]] y)
(y2 [r2 U F2 U: r2] y2) ([y x U2 l2 U F' L U R2 F': r2])
Therefore, we can always have an even number of Xs in our product.

Now let's confirm that we can merge three 2 2-cycle of wings (which are commutators) as one commutator.

Let one 2 2-cycle of wings algorithm be C X C' and another be D X D', and let's suppose that combining them yields a 2 2-cycle of wings.

Before we found that A X A' B X B' merged to the commutator [B: [B' A, X] ] and therefore A X A' B X B' is a commutator. Similarly, C X C' D X D' is also a commutator.

The equality [O:[P,Q]] = [[O

],[O:Q]] tells us that a conjugated commutator is a commutator (which shows why A X A' and B X B' are commutators), which also means that a shifted commutator is a commutator (which will justify what follows).

Let's combine these four 2 2-cycle algorithms (which is combining three 2 2-cycles, by definition of (C X C')(D X D') ).

(A X A' B X B') (C X C' D X D')

Since X = X',

(A X A' B X' B') (C X C' D X' D')

Since [O:[P,Q]] = [[O

],[O:Q]], we rotate the moves in parenthesis and still have a product of two commutators.

Moving A to the end and D' to the beginning,

(X A' B X' B' A) (D' C X C' D X')

Since [O:[P,Q]] = [[O

],[O:Q]], we can also rotate pieces at the end positions of the parenthesis to the beginning or end of the entire product to still have a product of two commutators.

Rotating X to X', they cancel to leave us with:

(A' B X' B' A) (D' C X C' D)

Moving C' D from the end to the beginning of the entire product,

C' D A' B X' B' A D' C X

= [C' D A' B, X'], which is a single commutator, which means that (A' B X' B' A) (D' C X C' D) is also a single commutator.

To handle merging four 2 2-cycles in which their effect is literally four 2 2-cycles (no consecutive pair of 2 2-cycles merges to a single 2 2-cycle), we still can use the above argument.

Now this can be extrapolated to any number number of 2 2-cycles of wings.

Since every even permutation of wings can be reached with a product of 2 2-cycle wing algorithms, every 2 2-cycle of wings can be expressed as a commutator, and these commutators can be merged into one commutator,

then every even permutation of wings can be expressed as a single commutator.

Lastly, as I mentioned at the beginning about the issue that a single 2 2-cycle conjugate is not supercube safe, note that we can construct all of these algorithms to affect the same centers. Since there must be an even number of Xs in order for all 2 2-cycle algorithms to merge as a single commutator, then doing a 2 2-cycle of four 1x(n-2) center blocks an even number of times yields the identity (the centers on supercubes would be untouched once the entire commutator is fully executed). But this is not at all required, as we can have consecutive 2 2-cycle algorithms involve different 1x(n-2) center blocks.

EDIT:

Maybe I should make it clear how we can extrapolate it to any number of 2 2-cycles of wings.

A X A B X B can be interpreted as either one 2 2-cycle (if the 2 2-cycles of A X A and B X B overlap two pieces) or two 2 2-cycles. So, to represent any number greater than or equal to one 2 2-cycle, we have

(A X A' B X B')(C X C' D X D')(E X E' F X F')....(Y X Y' Z X Z')...

I believe if we just look at the following example, we can see enough evidence. (Note that X = X').

(A X A' B X B')(C X C' D X D')(E X E' F X F')

We just rotate the outer most parenthesis so that X will be on the ends:

(X A' B X B' A)(C X C' D X D')(F' E X E' F X)

Then we cancel the Xs

(A' B X B' A)(C X C' D X D')(F' E X E' F)

We can continue rotating the outer most

(X B' A A' B)(C X C' D X D')(E' F F' E X) = (X)(C X C' D X D')(X)

Until we can get rid of the outer-most parenthesized groups completely

(C X C' D X D')

So that we will eventually end up with the single product of (C X C' D X D'), which merges to a single commutator.

Similar to this entire argument with conjugates, every ODD permutation of wing edges on even cubes at least, can be represented as a product of conjugates of the moves r and r', based on the method I showed in my 4-cycle conjugates in

this post.