I'm a big fan of number theory. A big thing in number theory is modular arithmetic; the definition being $aequiv bmod m$ if and only if $mmid a-b$. A fun thing to do is raising to powers: especially when the modulus is a prime number. In particular, it has been proven that if $a$ and $m$ are relatively prime (share no common factors besides $1$) then there exists a number $e$ such that $a^eequiv 1mod m$.

I will explain what the exercise is by an example. Let's take a modulus $m=7$. The output of the program or function would be

3 2 6 4 5 1
2 4 1 2 4 1
6 1 6 1 6 1
4 2 1 4 2 1
5 4 6 2 3 1
1 1 1 1 1 1

Each row is a list of the powers of the first number in that row: the first row is $3, 3^2, 3^3, cdots, 3^6$, which is equivalent to $3,2,6,4,5,1$ modulo $7$. We only put numbers between $0$ and $m$ in the square, so these numbers are the only possibility. The second row of the square above is the powers of $2$, etcetera, up to the last row, which are just powers of $1$. Also, the square is symmetric; that is, the $i$th column is the same as the $i$th row. We only have the powers of the numbers $1$ through $6$, as those are the only numbers relatively prime to $7$ that lie between $0$ (inclusive) and $7$ (exclusive).

So, create a function or program that given a prime p outputs a magical modulo square, that is, a square with side lengths p-1, such that each row is a list of the consecutive powers of the first element in the row, and the same for the columns. All numbers between 0 and p must occur, and the square can only contain numbers in that range.

This is code-golf, so the shortest code wins.

Wolfram Language (Mathematica), 46 bytes

Mod[r=Range[#-1];#^r&/@(PrimitiveRoot@#^r),#]&

Try it online!

Charcoal, 36 bytes

≔Ｅ…¹θ﹪Ｘι…¹θＩθηＥ⊟Φη⁼¹№ι¹⪫Ｅ§η⊖ι◧ＩλＬ⊖θ 

Try it online! Link is to verbose version of code. Note: Trailing space. Explanation:

≔Ｅ…¹θ﹪Ｘι…¹θＩθη

Create a p-1 by p-1 array of powers of 1..p-1 to indices 1..p-1 (modulo p).

Ｅ⊟Φη⁼¹№ι¹

Map over one of the rows which has exactly one 1.

⪫Ｅ§η⊖ι◧ＩλＬ⊖θ 

Rearrange the rows into the order given by the selected row and format the output.

Wolfram Language (Mathematica), 67 bytes

(s=Thread@Mod[x^#&/@(x=Range[#-1]),#])[[#&@@Select[s,Sort@#==x&]]]&

Try it online!

JavaScript (ES7), 91 bytes

This version attempts to compute the powers before applying the modulo and will fail for $pge11$ because of loss of precision.

f=(p,k)=>(g=k=>b=[...Array(i=p-1)].map(_=>k**++i%p))(k).every(x=>g[x]^=1)?b.map(g):f(p,-~k)

Try it online!

JavaScript (ES6), 92 bytes

This version uses modular exponentiation to support higher input values.

f=(p,k)=>(g=k=>b=[...Array(p-1)].map(_=>n=n*k%p,n=1))(k).every(x=>g[x]^=1)?b.map(g):f(p,-~k)

Try it online!

Perl 6, 65 57 bytes

.first(*.Set+2>$_)]o.&@=(($++X**1..^$_)X%$_)xx$_

Try it online!

There's probably some way to just output the square itself, but this does the same process outlined in the question, sorting the lists by their positions in the first list that is just a permutation of 1 to input-1. Returns as a list of lists.

BTW, there's a lot of jockeying around, trying to get around some of Perl 6's annoying limitations involving sequences vs arrays, and anonymous variables.

Explanation:

 $++ xx$_ # Map 0 to i-1 to
 ( X**1..^$_) # n, n^2, n^3... n^(i-1)
 ( X%$_) # All modulo i
 o.& # Pass to the next function
 .[ ] # Index into that list of lists
 |.first( ) # The list of the first list that
 *.Set+2>$_ # Has all the elements in the range 1 to i-1

Jelly, 13 bytes

^{Feels like the repeated code should be golf-able, but I have not managed it...}

*€Ṗ%⁸QƑƇḢ*€Ṗ%

Try it online! (footer pretty-formats as a grid)

How?

*€Ṗ%⁸QƑƇḢ*€Ṗ% - Link: integer, p
 € - for each n in [1..p]
* - exponentiate with:
 Ṗ - pop = [1..p-1]
 - ...i.e [[1^1,1^2,...,1^(p-1)],[2^1,2^2,...,2^(p-1)],...,[....,p^(p-1)]]
 % - modulo:
 ⁸ - chain's left argument, p
 Ƈ - keep those which:
 Ƒ - are invariant under:
 Q - de-duplicate
 Ḣ - head
 € - for each v in that list:
 * - exponentiate with:
 Ṗ - pop = [1..p-1]
 % - modulo (p)

_{Less repeated code, also 13:}

*€%³
çṖQƑƇḢçṖ