KnightJump Construction  

KJ_{m}(n_Point_{0},n_Vector_{0} .. n_Vector_{n1})  
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 startposition 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_{0} + _{l=0}∑^{n1}((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_{0} + _{l=2}∑^{k div m} n_Vector_{l} + (k mod m) n_Vector_{1} (?)  
Planck's: "The Theory of Path Nasiks"  
{^{n}N_{m_[perm(0..m1)]}} KJ_{m}(n_Point_{0},n_Vector_{0} .. n_Vector_{n1}) = KJ_{m}(n_Point_{0},n_Vector_{0} .. n_Vector_{n1})_{=[perm(0..m1)]} 

The formula above summarizes the construction Frost / Planck used around 1900. The "theory" formulates conditions about the "start point view" KnightJumpvectors 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). 

KnightJumpvectors  Det(n_Vector_{0},...,n_Vector_{n1}) relatively prime to m  
In order for the hypercube to be completely covered with numbers the determinant of the matrix formed by writing the nVectors 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_{0},...,Pf_{k}(p),...,n_Vector_{n1}))  
Replacing a KnightJumpvector 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 nagonal forms the permutation of the dynamic numbering phase which corrects the offsums Note: the magicness of this hyperbeam depends on the amount of d_{k,p} not relatively prime to m 
Examples (note radix 9 numbers!) 


KJ_{9}([0,0],<1,2>,<1,2>)  KJ_{9}([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 {rowmagic} 3 by 3 rectangle 
d_{0,7} = GCD(9,D_{0,6}) = 3 d_{1,6} = GCD(9,D_{1,5}) = 3 needed {rowmagic} 3 by 3 rectangle 
0 4 8 1 5 6 2 3 7 

KJ_{9}([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_{9}([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 
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 "digitvector" multiplied by the "vectormatrix" formed by the knightjumpvectors as shown below. 

n_Point_{k} = n_Point_{0} +
_{l=0}∑^{n1}((k\m^{l})%m) n_Vector_{l}
with forementioned notation can be rewritten as a vector equation: { n_Point_{k}  n_Point_{0} } = [ n_Vector_{l} ] { ((k\m^{l})%m) } <==> [ n_Vector_{l} ]^{1}{ n_Point_{k}  n_Point_{0} } = { ((k\m^{l})%m) } which shows that the "vectormatrix" 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 