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
KJ_m(n_Point₀,n_Vector₀ .. n_Vector_n-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 m^k is determined relative to the start-position
This way only the position of 0 and the numbers m^k are needed to figure out
the knightjump construction parameters.

n_Point_k = n_Point₀ + _l=0∑^n-1((k\m^l)%m) n_Vector_l

endpoint view
ABONDONED each vector is from the endpoint
In this more traditional view vector toward the number m^k is determined
relative to the number m^k-1
to figure out the knightjump construction parameters in this pint of view one thus need
to find the positions of the numbers m^k and m^k-1

n_Point_k = n_Point₀ + _l=2∑^{k div m} n_Vector_l + (k mod m) n_Vector₁ (?)

Planck's: "The Theory of Path Nasiks"
{ⁿN_{m_[perm(0..m-1)]}} KJ_m(n_Point₀,n_Vector₀ .. n_Vector_n-1) =
KJ_m(n_Point₀,n_Vector₀ .. n_Vector_n-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_Vector₀,...,n_Vector_n-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 d_k,p = GCD(m,Det(n_Vector₀,...,Pf_k(p),...,n_Vector_n-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 d_k,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 d_k,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 d_k,p to be satisfied.
Further note the equivalence between {ⁿN_{m_[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 d_k,p might give different options in the direction Pf(p).

Examples
(note radix 9 numbers!)
KJ₉([0,0],<1,2>,<1,-2>) KJ₉([0,0],<1,2>,<1,3>)

D = Det(<1,2><1,-2>) = -4
D_0,5 = Det(<0,1><1,-2>) = -1
D_0,6 = Det(<1,-1><1,-2>) = -1
D_0,7 = Det(<1,0><1,-2>) = -2
D_0,8 = Det(<1,1><1,-2>) = -3
D_1,5 = Det(<1,2><0,1>) = 1 D_1,6 = Det(<1,2><1,-1>) = -3
D_1,7 = Det(<1,2><1,0>) = -2
D_1,8 = Det(<1,2><1,1>) = -1
D = Det(<1,2><1,3>) = 1
D_0,5 = Det(<0,1><1,3>) = 1
D_0,6 = Det(<1,-1><1,3>) = 2
D_0,7 = Det(<1,0><1,3>) = 3
D_0,8 = Det(<1,1><1,3>) = 2
D_1,5 = Det(<1,2><0,1>) = 1 D_1,6 = Det(<1,2><1,-1>) = -3
D_1,7 = Det(<1,2><1,0>) = 2
D_1,8 = Det(<1,2><1,1>) = -1

D tells us that the square is completely covered
D_0,8 indicates failing low components main diagonal
D_1,6 indicates failing high components sub diagonal D tells us that the square is completely covered
D_0,7 indicates failing low components row
D_1,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

d_0,8 = GCD(9,D_0,7) = 3
d_1,6 = GCD(9,D_1,5) = 3
needed {row-magic} 3 by 3 rectangle d_0,7 = GCD(9,D_0,6) = 3
d_1,6 = GCD(9,D_1,5) = 3
needed {row-magic} 3 by 3 rectangle

0 4 8
1 5 6
2 3 7

KJ₉([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 KJ₉([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_Vector_l ]
as the matrix formed by juxtaposing the knightjumpvectors and
{ ((k\m^l)%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_Point_k = n_Point₀ + _l=0∑^n-1((k\m^l)%m) n_Vector_l

with forementioned notation can be rewritten as a vector equation:

{ n_Point_k - n_Point₀ } = [ n_Vector_l ] { ((k\m^l)%m) } <==>
[ n_Vector_l ]^-1{ n_Point_k - n_Point₀ } = { ((k\m^l)%m) }

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

Det([ n_Vector_l ]) != 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_Vector_l ]),m) = 1

KnightJump Construction
KJ_m(n_Point₀,n_Vector₀ .. n_Vector_n-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 m^k is determined relative to the start-position This way only the position of 0 and the numbers m^k are needed to figure out the knightjump construction parameters.
	n_Point_k = n_Point₀ + _l=0∑^n-1((k\m^l)%m) n_Vector_l
endpoint view ABONDONED	each vector is from the endpoint
	In this more traditional view vector toward the number m^k is determined relative to the number m^k-1 to figure out the knightjump construction parameters in this pint of view one thus need to find the positions of the numbers m^k and m^k-1
	n_Point_k = n_Point₀ + _l=2∑^{k div m} n_Vector_l + (k mod m) n_Vector₁ (?)
Planck's: "The Theory of Path Nasiks"
{ⁿN_{m_[perm(0..m-1)]}} KJ_m(n_Point₀,n_Vector₀ .. n_Vector_n-1) = KJ_m(n_Point₀,n_Vector₀ .. n_Vector_n-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_Vector₀,...,n_Vector_n-1) relatively prime to m
KnightJump-vectors	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	d_k,p = GCD(m,Det(n_Vector₀,...,Pf_k(p),...,n_Vector_n-1))
Permutation Period	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 d_k,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 d_k,p not relatively prime to m

Examples (note radix 9 numbers!)
KJ₉([0,0],<1,2>,<1,-2>)	KJ₉([0,0],<1,2>,<1,3>)
D = Det(<1,2><1,-2>) = -4 D_0,5 = Det(<0,1><1,-2>) = -1 D_0,6 = Det(<1,-1><1,-2>) = -1 D_0,7 = Det(<1,0><1,-2>) = -2 D_0,8 = Det(<1,1><1,-2>) = -3 D_1,5 = Det(<1,2><0,1>) = 1 D_1,6 = Det(<1,2><1,-1>) = -3 D_1,7 = Det(<1,2><1,0>) = -2 D_1,8 = Det(<1,2><1,1>) = -1	D = Det(<1,2><1,3>) = 1 D_0,5 = Det(<0,1><1,3>) = 1 D_0,6 = Det(<1,-1><1,3>) = 2 D_0,7 = Det(<1,0><1,3>) = 3 D_0,8 = Det(<1,1><1,3>) = 2 D_1,5 = Det(<1,2><0,1>) = 1 D_1,6 = Det(<1,2><1,-1>) = -3 D_1,7 = Det(<1,2><1,0>) = 2 D_1,8 = Det(<1,2><1,1>) = -1
D tells us that the square is completely covered D_0,8 indicates failing low components main diagonal D_1,6 indicates failing high components sub diagonal	D tells us that the square is completely covered D_0,7 indicates failing low components row D_1,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
d_0,8 = GCD(9,D_0,7) = 3 d_1,6 = GCD(9,D_1,5) = 3 needed {row-magic} 3 by 3 rectangle	d_0,7 = GCD(9,D_0,6) = 3 d_1,6 = GCD(9,D_1,5) = 3 needed {row-magic} 3 by 3 rectangle
0 4 8 1 5 6 2 3 7
KJ₉([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	KJ₉([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