Negative Space Graphs Task

You will be given a positive integer and you must output a "self-complementary graph" with that many nodes.  If you don't know what a self-complementary graph is the wikipedia article wont help you much so below are two explanations, a technical and a non-technical one.

Non-Technical

A graph is a set of nodes that are connected by lines.  Each pair of points can be connected by one line or none.  The "complement" of a graph is the result of taking a graph and connecting all the nodes that are not connected and disconnecting all the nodes that are.

A self-complementary graph is a graph whose complement can be rearranged into the shape of the original.  Below is an example of a self-complementary graph and a demonstration of how.

Here is a graph with 5 nodes:



We will highlight the all the places where connections could go with red dotted lines:



Now we will find the complement of the graph by swapping the red and black edges:



This does not look like the original graph but if we move the nodes around like so (each step swaps two nodes):



We get the original graph!  The graph and its complement are the same graph

Technical

A self-complementary graph is a graph that is isomorphic to its complement.

Specifications

You will receive an positive integer via whatever method suits you best.  And you will output a graph in whatever method you deem appropriate,  this includes but is not limited to Adjacency Matrix Form, Adjacency List Form, and of course pictures!  The outputted graph must be its own complement and have as many nodes as the integer input.  If no such graph exists you must output a falsy value.

This is code-golf and you should aim to minimize your byte count.

Test Cases

Below are pictures of possible outputs for several n

4



5



9
Haskell, 72 bytes

f n=[(a,b)|b&lt;-[1..n],a&lt;-[1..b-1],mod n 4&lt;2,mod(a+b+sum[b|odd n,a&lt;2])4&lt;2]

Try it online!
A belated improvement inspired by ideas from kops. Takes vertex 1 to the the special vertex in the \$n=1 \bmod 4\$ case, rather than vertex n.

Haskell, 77 bytes

f n=[(a,b)|b&lt;-[1..n],a&lt;-[1..b-1],mod n 4&lt;2,mod(a+(last$b:[a|odd n,n==b]))4&lt;2]

Try it online!
This uses an easy-to-compute explicit criterion to decide whether an edge (a,b) belongs in the graph. Instantiates this algorithm, with the permutation cycling among the values modulo 4
4*m -&gt; 4*m+1 -&gt; 4*m+2 -&gt; 4*m+3 -&gt; 4*m

We include edges whose two endpoint vertices add to 0 or 1 modulo 4. Note that cycling vertices as per this permutation adds 2 modulo 4 to the vertex sum on each each, and so swaps edges and non-edges. This gives a permutation of vertices that complements the edges.
If the graph has an extra node beyond a multiple of 4, it is put in a cycle alone. We include edges with it when then other vertex is even. Permuting the vertices flips the parity, and so the graph remains self-complementary.
If the number of vertices isn't 0 or 1 modulo 4, no self-complementary graph is possible because there's an odd number of edges in the complete graph
Overall, here are the conditions:

If the input n isn't 0 or 1 modulo 4, output an empty list
Otherwise if n is even, include all edges (a,b) with a&lt;b and a+b equal to 0 or 1 modulo 4.
Otherwise if n is odd, do the same, but instead include edges of the form (a,n) when a is even.

The code combines the second and third cases by replacing the condition mod(a+b)4&lt;2 with mod(a+a)4&lt;2 when both odd n and b==n.