[seqfan] Re: A "hard" quaternion-based sequence

Creighton Kenneth Dement creighton.k.dement at mail.uni-oldenburg.de
Fri Jul 31 01:53:54 CEST 2009

```> If one takes the Lipschitz integers, then Creighton's problem becomes (in
> general): find the number a(n) of sequences of length n:
> (x[1],x[2],..,x[n]) such that x[i] is in the quaternion group Q =
> {1,-1,i,-i,j,-j,k,-k} and the product x[1]x[2]...x[n] = 1. In this case
> a little thought shows that a(n) = 8^(n-1)---the first n-1 elements
> can be arbitrary and the n-th term is the inverse of the product
> of the first n-1.
>
> I seem to recall that given a finite group G there is a name for sequences
> of elements of the group whose product is 1, but I cannot recall what it
> is. In any case it seems that for a group of order k the sequence would be
> simply a(n) = k^(n-1).

Edwin, I agree that your assessment is a generalisation
for stage 1 (instead of triples, take quaduples, etc.). However,
I do not (yet) believe it is a generalization for the entire
problem.

Here is a reformulation of the problem without refering to "stages":

To calculate A(n) (offset 1), count the number of ways to place
quaternions {1,-1,i,-i,j,-j,k,-k} on the spaces of an nx3 grid such that

1. the product of the 3 quaternions in each grid row is equal to 1 (taken
from left to right)

and

2. a*b*c = 1 where a, b, c are the products of the n quaternions in the
first, second and third columns respectively (taken from top to bottom).

Note we can also take diagonals of the grid into account, but I wish to
calculate the most basic -nontrivial- variation of the problem first.

As stated, my brute force program returns A(2) = 2176 = 17*2^7

Returning to the example from before, one possible 2x3 grid configuration
is
Row 1: [i, i, -1]
Row 2: [-i, j, k]

Multiplying the columns together gives
a = i * (-i) = 1
b = i * j = k
c = -1 * k = -k
and a*b*c = 1

Shifting row 2 above one to the left, however, is not a valid grid
configuration:

Row 1: [i, i, -1]
Row 2: [j, k, -i]

a = i * j = k
b = i * k = -j
c = -1 * (-i) = i
and a*b*c = -1

Shifting row 2 again one to the left returns:

Row 1: [i, i, -1]
Row 2: [k, -i, j]

a = i * k = -j
b = i * (-i) = 1
c = -1 * j = -j
and a*b*c = -1

which is also not a valid configuration.

But there are some valid configurations for the 2x3 grid
where we can shift any row any way we like and still produce another
acceptable configuration, say

Row 1: [j, k, -i]
Row 2: [-1, 1, -1]

It wouldn't suprise me if this all turned out to be trivial to compute-
especially if based on an idea on not brute force. However, I am not yet
convinced that it is.

Sincerely,
Creighton

```