A graph and its seven closures Background
A little while ago, someone posted an interesting puzzle on Math.SE:

What is the smallest digraph (directed graph) G where the following eight graphs are all distinct:

G, the original graph
Reflexive closure of G
Symmetric closure of G
Transitive closure of G
Reflexive symmetric closure of G
Symmetric transitive closure of G
Reflexive transitive closure of G
Reflexive symmetric transitive closure of G


A quick refresher on the terminology:

A reflexive graph satisfies: for every vertex X of G, the edge (X,X) is present in G.
A symmetric graph satisfies: for every pair of vertices X and Y of G, if the edge (X,Y) is present in G, the edge (Y,X) is also present.
A transitive graph satisfies: for every triple of vertices X, Y, and Z of G, if the edges (X,Y) and (Y,Z) are present in G, the edge (X,Z) is also present.
A reflexive/symmetric/transitive closure of G is the smallest superset of G that satisfies the given property. Note that, for example, symmetric transitive closure is not equal to symmetric closure of transitive closure in general.

For example, the following (from the original Math.SE post) shows an example graph that satisfies the original question:

Challenge
Given a digraph G, determine if it satisfies the above puzzle (G and its seven closures are all distinct).
The input digraph G can be represented in any reasonable way: adjacency matrix, adjacency list, flat lists of vertices and edges, etc. Since the answer is always false when isolated vertices are not allowed, the representation must include some representation of the list of vertices.
For output, you can choose to

output truthy/falsy using your language's convention (swapping is allowed), or
use two distinct, fixed values to represent true (affirmative) or false (negative) respectively.

The shortest code in bytes wins.
Test cases
Truthy
# the example in the image
vertices: [1, 2, 3, 4, 5, 6]
edges: [[1, 2], [2, 3], [3, 4], [4, 2], [4, 5]]
adjacency matrix:
[[0, 1, 0, 0, 0, 0],
 [0, 0, 1, 0, 0, 0],
 [0, 0, 0, 1, 0, 0],
 [0, 1, 0, 0, 1, 0],
 [0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0]]

# the smallest answer in Math.SE
vertices: [1, 2, 3, 4]
edges: [[1, 2], [2, 3]]
adjacency matrix:
[[0, 1, 0, 0],
 [0, 0, 1, 0],
 [0, 0, 0, 0],
 [0, 0, 0, 0]]

Falsy
# the incorrect answer in Math.SE
vertices: [1, 2, 3]
edges: [[1, 2], [2, 3]]
adjacency matrix:
[[0, 1, 0],
 [0, 0, 1],
 [0, 0, 0]]

# a modification of 4-vertex correct answer, ST=RST
vertices: [1, 2, 3, 4]
edges: [[1, 2], [2, 3], [4, 4]]
adjacency matrix:
[[0, 1, 0, 0],
 [0, 0, 1, 0],
 [0, 0, 0, 0],
 [0, 0, 0, 1]]
J, 71 58 bytes
Takes in the adjacency matrix.
*/@~:@(,([+./@,#)&quot;#/~^:_&quot;2)@(,s@r,(s=:+.|:),:r=:[+.=@i.@#)

Try it online!
How it works
First the original, s, r and r-&gt;s variants are computed, then all their transitive closures. Albeit the operations are not commutative, I believe calculating the transitive closure last will work here (r-&gt;t is equal to r-&gt;t-&gt;r as r just adds the diagonal, which was already set. s-&gt;t is equal to s-&gt;t-&gt;s as every transition was already symmetric. s-&gt;r is equal to r-&gt;s as every reflexion is symmetric.) Though this might be wrong, and if it is, I'm happy to slap some ^:_ on there. :-)

r=:+.=@i.@#: original matrix OR the diagonal =@i.@#.
s=:+.|:: original matrix OR its transposition |:.
,s@r,s,:r: original matrix and all its variants in a list.
([+./@,#)&quot;#/~^:_&quot;2: until the result does not change ^:_:  for every node: take the neighboring rows #, append them to the current row [ , and OR them together +./.
*/@~:: ~: returns whether each element of the list is unique, then AND */ those booleans.