The Magic Encyclopedia ™

The KnightJump Construction method
(by Aale de Winkel)

The Knightjump construction method consists of the position for the first number and a sequence of n vectors. This article investigates the method, and the differences between the startpoint and endpointview. Although the below defines the "endpointview" the "startpointview" is more commonly used and I'll revert to this point for future uploads (unless otherwise specified)
Study of Planck's 1905 paper "The Theory of Path Nasiks" gave me a better understanding of the method then I had previously. Below a reflection of these studies in modern terminology as a "Path HyperCube" is a hypercube constructed by KnightJump and modified by Dynamic Numbering to improve quality. Planck uses a combination of a matrix and the rectangle to specify a hypercube, the obvious transformation into my "KnightJump-Vectors" resp. n-agonal permutation transforms his "names" into "KJ-names" in an isomorphic manner.

KnightJump Construction
KJm(n_Point0,n_Vector0 .. n_Vectorn-1)
The first number is positioned at some point in the hypercube, the 1st vector defines
the position of the next number by addition to the position of the previous. When the
thus arrived position is occupied further vectors are needed to reach a free position
startpoint view each vector is from the startpoint
The vector toward the number mk is determined relative to the start-position
This way only the position of 0 and the numbers mk are needed to figure out
the knightjump construction parameters.
n_Pointk = n_Point0 + l=0n-1((k\ml)%m) n_Vectorl
endpoint view
ABONDONED
each vector is from the endpoint
In this more traditional view vector toward the number mk is determined
relative to the number mk-1
to figure out the knightjump construction parameters in this pint of view one thus need
to find the positions of the numbers mk and mk-1
n_Pointk = n_Point0 + l=2k div m n_Vectorl + (k mod m) n_Vector1 (?)
Planck's: "The Theory of Path Nasiks"
{nNm_[perm(0..m-1)]} KJm(n_Point0,n_Vector0 .. n_Vectorn-1) =
KJm(n_Point0,n_Vector0 .. n_Vectorn-1)=[perm(0..m-1)]
The formula above summarizes the construction Frost / Planck used around 1900.
The "theory" formulates conditions about the "start point view" KnightJump-vectors
as well as the permutation used in the dynamic numbering phase of the construction method.
Planck intermixes the DN with the KJ phase, seperating the two phases clarifies things
though and makes things more available for counting arguments
(reserved for future upload / seperate articles).
KnightJump-vectors Det(n_Vector0,...,n_Vectorn-1) relatively prime to m
In order for the hypercube to be completely covered with numbers the determinant of
the matrix formed by writing the n-Vectors below one another needs to be relatively
prime to the order, also this determinant (not being 0) ensures the vectors being
liniairily independent.
Permutation Period dk,p = GCD(m,Det(n_Vector0,...,Pfk(p),...,n_Vectorn-1))
Replacing a KnightJump-vector with one of the directional Pathfinders the determinant
yield a number if all these numbers are relatively prime to m the dk,n are all 1
and the hypercube is {perfect} in a natural way, if the numbers are not relatively prime the
numbers above gives the dimension of a hyperbeam whose n-agonal forms the permutation
of the dynamic numbering phase which corrects the off-sums
Note: the magic-ness of this hyperbeam depends on the amount of dk,p not
relatively prime to m

Note the above summarizes "The Theory of Path Nasiks", the qualitative statements might be quantized in some future upload of this or related articles. Also less then {perfect} hypercubes might be obtainable by reducing the amount of dk,p to be satisfied.
Further note the equivalence between {nNm_[perm]} X and X=[perm] utilized below
Dynamic numbering with n-agonal permuted normal squares is as far as Planck etc. went, this seems to be equivalent to digit changing the "digits" of the numbers. Dynamic numbering allows for more possibilities left for future investigation to figure how they exactly fit in this century old theorem. Now computers are available the numbers dk,p might give different options in the direction Pf(p).

Examples
(note radix 9 numbers!)
KJ9([0,0],<1,2>,<1,-2>) KJ9([0,0],<1,2>,<1,3>)
D = Det(<1,2><1,-2>) = -4
D0,5 = Det(<0,1><1,-2>) = -1
D0,6 = Det(<1,-1><1,-2>) = -1
D0,7 = Det(<1,0><1,-2>) = -2
D0,8 = Det(<1,1><1,-2>) = -3
D1,5 = Det(<1,2><0,1>) = 1 D1,6 = Det(<1,2><1,-1>) = -3
D1,7 = Det(<1,2><1,0>) = -2
D1,8 = Det(<1,2><1,1>) = -1
D = Det(<1,2><1,3>) = 1
D0,5 = Det(<0,1><1,3>) = 1
D0,6 = Det(<1,-1><1,3>) = 2
D0,7 = Det(<1,0><1,3>) = 3
D0,8 = Det(<1,1><1,3>) = 2
D1,5 = Det(<1,2><0,1>) = 1 D1,6 = Det(<1,2><1,-1>) = -3
D1,7 = Det(<1,2><1,0>) = 2
D1,8 = Det(<1,2><1,1>) = -1
D tells us that the square is completely covered
D0,8 indicates failing low components main diagonal
D1,6 indicates failing high components sub diagonal
D tells us that the square is completely covered
D0,7 indicates failing low components row
D1,7 indicates failing low components sub diagonal
00 55 11 66 22 77 33 88 44
27 73 38 84 40 05 51 16 62
45 01 56 12 67 23 78 34 80
63 28 74 30 85 41 06 52 17
81 46 02 57 13 68 24 70 35
18 64 20 75 31 86 42 07 53
36 82 47 03 58 15 60 25 71
54 10 65 21 76 32 87 43 08
72 37 83 48 04 50 15 61 26
00 73 56 30 13 86 60 43 26
18 82 65 48 22 05 78 52 35
27 01 74 57 31 14 87 61 44
36 10 83 66 40 23 06 70 53
45 28 02 75 58 32 15 88 62
54 37 11 84 67 41 24 07 71
63 46 20 03 76 50 33 16 80
72 55 38 12 85 68 42 25 08
81 64 47 21 04 77 51 34 17
d0,8 = GCD(9,D0,7) = 3
d1,6 = GCD(9,D1,5) = 3
needed {row-magic} 3 by 3 rectangle
d0,7 = GCD(9,D0,6) = 3
d1,6 = GCD(9,D1,5) = 3
needed {row-magic} 3 by 3 rectangle
0 4 8
1 5 6
2 3 7
KJ9([0,0],<1,2>,<1,-2>)=[0 5 7 4 6 2 8 1 3]

00 22 55 88 77 11 44 33 66
71 14 43 34 60 02 35 58 87
62 05 28 17 81 74 13 46 83
84 73 16 40 32 65 08 27 51
35 68 07 21 54 83 76 10 42
53 86 70 12 45 38 24 01 24
48 37 61 04 23 56 80 72 15
26 50 82 71 18 47 31 64 38
17 41 34 43 06 20 52 85 78
KJ9([0,0],<1,2>,<1,3>)=[0 5 7 4 6 2 8 1 3]

00 14 28 40 54 38 80 64 78
53 37 82 63 77 02 13 27 42
71 05 16 21 45 56 31 85 66
48 50 34 88 60 74 08 10 24
62 73 07 12 23 47 52 33 87
26 41 55 36 81 65 76 01 15
84 68 70 04 18 20 44 58 30
17 22 43 57 32 83 67 72 03
35 86 61 75 06 11 25 46 51

Other samples are in Plancks article as well as recently optained spreadsheets from <George Chen> replied by Dynamic Numbering spreadsheets by me showing the above formulated



Implementing the suggestins made by planckgave me more insigths formulated in the table below The mathematical minded might benifit from the given notes and fill in the noted gaps.
(Note: these notes aren't finished yet, progress of implementation might show me more details)

mathematical recap
a slight deviation from the usual notation denotes:
[ n_Vectorl ]
as the matrix formed by juxtaposing the knightjumpvectors and
{ ((k\ml)%m) }
as the vector formed by the radix m digit's of the number k
the position of k is thus seen the "digit-vector" multiplied by
the "vector-matrix" formed by the knightjump-vectors as shown below.
n_Pointk = n_Point0 + l=0n-1((k\ml)%m) n_Vectorl

with forementioned notation can be rewritten as a vector equation:

{ n_Pointk - n_Point0 } = [ n_Vectorl ] { ((k\ml)%m) } <==>
[ n_Vectorl ]-1{ n_Pointk - n_Point0 } = { ((k\ml)%m) }

which shows that the "vector-matrix" needs to be a regular matrix, in order to have an inverse, ie:

Det([ n_Vectorl ]) != 0

By some (unknown to me) theorem this number needs to be relatively prime to the order m
to reach all the poasible positions, which gives the condition Planck noted:

GCD(Det([ n_Vectorl ]),m) = 1