Polyflags

[mr_e_man]

Definitions:

An (abstract) n-polyflag is a non-empty set S, whose elements are called flags, with n unary operations on S, called adjacency operations. For a number 0 ≤ k < n and a flag x in S, the result of the k'th operation is a flag, denoted x⟨k⟩ and called k-adjacent to x. (The angle brackets are a reminder of the dyad/diamond structure in a polytope's Hasse diagram.) A polyflag has these properties:

• Involution: For any flag x and any rank k, we have x⟨k⟩⟨k⟩ = x.
• Commutativity: For any flag x and any non-adjacent ranks j and k (meaning |j - k| > 1), we have x⟨j⟩⟨k⟩ = x⟨k⟩⟨j⟩.
• Connectedness: For any flags x and y, there exists a (finite) sequence of ranks k₁, k₂, ... , k_m, such that x⟨k₁⟩⟨k₂⟩...⟨k_m⟩ = y.

We may define the (-1)-polyflag to be the same as the 0-polyflag. Of course the (-1)-polytope is not the same as the 0-polytope, but in this context they're indistinguishable. (It has just one flag, and no adjacency operations.) Perhaps they should be distinguished by the label itself, 0 or -1.

A polyflag is orientable when any loop has an even length. That is, if x⟨k₁⟩⟨k₂⟩...⟨k_m⟩ = x, then m must be an even number.
Otherwise the polyflag is non-orientable.

A j-face is all flags reachable from one flag by avoiding rank j moves. In other words, for a flag x, the j-face containing x is the set of all flags of the form x⟨k₁⟩⟨k₂⟩...⟨k_m⟩, where all ranks k₁, k₂, ... , k_m are not equal to j.

Two faces are incident when they share a flag.

A polyflag is separable when, for any flag x, the adjacent flag x⟨j⟩ is in a separate j-face. In other words, if all ranks k₁, k₂, ... , k_m are not equal to j, then x⟨k₁⟩⟨k₂⟩...⟨k_m⟩ ≠ x⟨j⟩.
Otherwise the polyflag is inseparable.


If you convert a polytope to a polyflag in the obvious way (define flags in terms of faces), and convert the polyflag to a polytope according to the above (define faces in terms of flags), then the result is isomorphic to the original polytope.
(Here's an old revision of Wikipedia's abstract polytope page. It has some useful information which was later removed; particularly the part about "strong flag-connectedness" is helpful in proving my claim here. Mapping a face to a flag to a set of flags doesn't depend on which flag is chosen.)

Every polytope is a polyflag. But not every polyflag is a polytope.

[mr_e_man]

The simplest one which is not a polytope is the hemi-dyad or hemi-ditelon. It has just one flag x = x⟨0⟩. (Think of this as a line segment running into a mirror.)

Another example is the monogon, or hemi-digon, which has 1 vertex and 1 edge but 2 flags, x ≠ x⟨0⟩ = x⟨1⟩.
(For some reason I think it's important to have n-gons for all natural numbers n. Maybe it's something Grunbaum said about connections to number theory; but I think that was in the context of star polygons, with rational n.)

You can cut a polygon into pieces using mirrors, and take one of the pieces to be a 2-polyflag. The end of a piece may be either an edge which connects a single vertex to itself, or a vertex which connects a single edge to itself.

Polyflags 1.png (14.48 KiB) Viewed 27849 times

For 3-polyflags, we have hemi-dihedra, and hemi-hosohedra. The 2n-gon dihedron has 2n vertices, 2n edges, 2 faces, and 8n flags. The corresponding hemi-dihedron has n vertices, n edges, 1 face, and 4n flags.

Here's a more well-behaved 3-polyflag. It is orientable, and can be considered a tiling of the sphere. It has no digons or divalent vertices. It is separable. (Any polytope is a separable polyflag, but all the other examples here are inseparable.) Nevertheless, it's not a valid polytope; the vertex in the middle, and the (green) outer hexagon, violate the dyadic property; there are more than 2 edges between them.

Polyflags 2.png (22.95 KiB) Viewed 27849 times

Polyflags 3.png (72.61 KiB) Viewed 27849 times

[mr_e_man]

Any non-orientable polyflag has an orientable double-cover, in which every flag is duplicated. Specifically, a flag in the double-cover has the form y = (x, b), where x is a flag in the original, and b is a bit (0 or 1). The adjacency operations are given by y⟨k⟩ = (x⟨k⟩, not b) = (x⟨k⟩, b+1), adding modulo 2 of course.

An orientable polyflag cannot be double-covered in this way, because the result would be disconnected.

It's not clear to me whether any non-orientable polytope has an orientable double-cover (which is also a polytope). I tried a few constructions, but they didn't seem to work in general.

[mr_e_man]

Also called "generalized maps". Too vague.

[mr_e_man]

Of course the dual of an n-polyflag just has the ranks reversed: ⟨k⟩ is replaced with ⟨n-1-k⟩.

A j-face is all flags reachable from one flag by avoiding rank j moves. In other words, for a flag x, the j-face containing x is the set of all flags of the form x⟨k₁⟩⟨k₂⟩...⟨k_m⟩, where all ranks k₁, k₂, ... , k_m are not equal to j.

(I think I'll rename this as a j-surtope. Without a prefix, "surtope" implies no particular rank, while "face" may or may not imply rank 2 or rank n-1.)

The monogon's vertex contains all (two) of the monogon's flags. The monogon's edge contains the same two flags. This would mean that the vertex equals the edge!

To avoid this, we must include the rank j as part of the data defining a j-surtope (like I suggested for the (-1)-polyflag), so it's more than just a set of flags.

Two faces surtopes are incident when they share a flag.

(In what follows, A,B,C are arbitrary surtopes with ranks i,j,k respectively.)

We define A≤B to mean that A and B are incident and i≤j.

This is in fact a partial order. Let us verify the axioms:

• A≤A.

This is obvious, as A contains at least one flag (thus sharing it with itself) and i≤i.

• If A≤B and B≤A, then A=B.

We have i≤j and j≤i, which implies i=j. We're given that A and B share some flag x. Now A is everything that can be reached from x by avoiding rank i moves, and B is everything that can be reached from x by avoiding rank j moves. But these are the same since i=j. Thus A=B.

• If A≤B and B≤C, then A≤C.

We have i≤j and j≤k, which implies i≤k. We're given that A and B share some flag x, and B and C share some flag y. Since B is a j-surtope containing x and y, there is some sequence j₁, j₂, j₃, ... never equalling j such that x⟨j₁⟩⟨j₂⟩⟨j₃⟩... = y. Notice that any rank less than j and any rank greater than j are separated by at least 2. Thus, by commutativity, the ranks greater than j can be moved to the left, leaving the ranks less than j on the right, and we can write

x⟨j₁⟩⟨j₂⟩⟨j₃⟩... = x⟨i₁⟩⟨i₂⟩⟨i₃⟩...⟨k₁⟩⟨k₂⟩⟨k₃⟩... = y,

where i₁, i₂, ... are all greater than j (hence greater than i), and k₁, k₂, ... are all less than j (hence less than k). Let

z = x⟨i₁⟩⟨i₂⟩... ,
z⟨k₁⟩⟨k₂⟩... = y.

This z is an element of A, because x is in A, and i₁, i₂, ... are not equal to i. And z is also an element of C, because y is in C, and k₁, k₂, ... are not equal to k, and

z = y...⟨k₃⟩⟨k₂⟩⟨k₁⟩.

Therefore A≤C, since they share the flag z.
(EDIT: In fact z is contained in all three of A,B,C. Generalizing, if we have a chain of surtopes A≤B≤...≤C≤D, then there is a flag contained in all of them. This can be proven by induction on the length of the chain, and the proof is essentially the same.)


So a polyflag determines a (ranked) poset. But there is a loss of information; we can't recover the polyflag from the poset. For example, the monogon is a 2-polyflag with 2 flags, and there's also a trivial 2-polyflag with 1 flag; both of these determine the same poset (1 vertex incident with 1 edge).

[mr_e_man]

Even for an orientable separable polyflag, the poset of surtopes gives less information.

This example is a 4-polyflag, made of two cubes. A cube has 48 flags, so this has 96 flags. The top face hedron of each cube is attached (by a translation, i.e. with no twists) to the bottom hedron of the other cube. The left hedron of one cube is attached to the left hedron of the other cube, with a 180° rotation around the vertical axis. Likewise, right to right, front to front, back to back.

Polyflags 4.png (18.55 KiB) Viewed 27827 times

This has 2 vertices (0-surtopes), 6 edges (1-surtopes), 6 hedra (2-surtopes), and 2 chora (3-surtopes). A vertex is made of 48 flags, just like a cube. An edge or a hedron is made of 16 flags. (This thing is probably self-dual, but I haven't checked.)

Let x be a flag at the top of the 'F' hedron, and let y = x⟨0⟩⟨1⟩⟨0⟩⟨1⟩ = x⟨2⟩⟨3⟩⟨2⟩⟨3⟩. Both x and y are contained in the same vertex, the same edge, the same hedron, and the same choron. But x and y are not equal. So a flag cannot be represented in terms of the poset.

Polyflags 5.png (31.18 KiB) Viewed 27827 times

That was a separable polyflag whose poset is not a polytope (it's not dyadic; between a vertex and a hedron are 3 or 4 edges).
Now here's the opposite: an inseparable polyflag whose poset is a polytope.

See the last example in the second post here. (It had six triangles and a hexagon.) Cut it in half with a vertical mirror, so that the two ⟨1⟩'s in the middle connect two flags to themselves, x⟨1⟩=x and y⟨1⟩=y. (This polyflag is obviously not separable.) Now the halved vertex and hexagon do satisfy dyadicity; there are 2 edges incident with them. The poset is simply a tetrahedron. Converting this back to a polyflag, those two flags become connected, x⟨1⟩=y. So, though a flag can be represented in terms of the poset, the adjacency relations are not respected.


And here's a separable polyflag whose poset is a polytope. Still there's a loss of information!

It's a square dihedron dichoron (thus 32 flags) with a twist. Again there are two different flags contained in the same vertex, the same edge, the same hedron, and the same choron. (In fact any flag is paired with another in this way.) The poset is a digon dihedron dichoron; that is, {2,2,2} (which has 16 flags).

Polyflags 6.png (41.19 KiB) Viewed 27812 times

[mr_e_man]

If you convert a polytope to a polyflag in the obvious way (define flags in terms of faces), and convert the polyflag to a polytope according to the above (define faces in terms of flags), then the result is isomorphic to the original polytope.

I might as well post the full proof here. I don't know who's reading this, or who cares, or how much they're able to prove on their own. But I think it's a significant result, especially since the previous post casts doubt on such nice relations between polytopes and polyflags.

(The least and greatest elements (ranks -1 and n) must be either specially added to the new polytope, or removed from the original polytope. This is no trouble.)
(Also, the cases n≤1 are easy, so I'll assume n≥2.)

Let P be an abstract n-polytope.
Let Q be the n-polyflag derived from P; so an element of Q is a subset of P, a chain of incident surtopes.
Let R be the poset derived from Q; so an element of R is a subset of Q, with this form: For a flag x in Q, and a rank j, denote by S_j(x) the set of all flags which can be reached from x without applying ⟨j⟩.
We need to construct a nice function f from P to R.

Given a j-surtope s in P, let x be any flag containing s. First we want to show that f(s) = S_j(x) is a well-defined function, i.e. it doesn't depend on the choice of x. So, if y is another flag containing s, must S_j(x) = S_j(y)?

Consider the two sub-polytopes [l, s] and [s, g] (where l and g are the least and greatest elements in P). The flag x breaks into two sub-flags, x_l ⊆ [l, s] and x_g ⊆ [s, g] (consisting of the surtopes in x with ranks less than j and greater than j, respectively). Likewise, from y we get y_l and y_g. By strong flag-connectedness, since x_l and y_l are two flags in the sub-polytope [l, s], there exists a sequence of ranks i₁, i₂, i₃, ... , all less than j, such that x_l⟨i₁⟩⟨i₂⟩... = y_l. Likewise, since x_g and y_g are two flags in the sub-polytope [s, g], there exists a sequence of ranks k₁, k₂, ... , all greater than j, such that x_g⟨k₁⟩⟨k₂⟩... = y_g. Combining these two sequences, we get x⟨i₁⟩⟨i₂⟩⟨i₃⟩...⟨k₁⟩⟨k₂⟩⟨k₃⟩... = y, where all ranks in the sequence are not equal to j. Therefore y is in S_j(x), and it follows that S_j(y) = S_j(x).

(There are special cases, j=0 or j=n-1. These are also no trouble. In the previous paragraph you can remove the i's or the k's, respectively.)

Next we want to show that f is an injective function, i.e. for any two different surtopes s≠t we have f(s)≠f(t). Suppose s has rank j (continuing the previous notation) and t has rank k. For j=k, this (f(s)≠f(t)) follows from the fact that any flag in f(s) has its rank j element being s, but any flag in f(t) has its rank j element being t. For j≠k, the set f(s) is not closed under the operation ⟨j⟩ (it changes the rank j element to something other than s), but f(t) is closed under ⟨j⟩. Thus f(s)≠f(t).

Next, f is a surjective function, i.e. for any set of flags of the form S_j(x), there exists at least one surtope s such that f(s) = S_j(x). This is obvious, as we can take s to be the rank j element of x. (Don't get confused by the re-use of variables, and the order of the quantifiers. Before, we started with a surtope and found some flag containing it. Here, we start with a flag and find some surtope contained in it.)

Next, f preserves rank. This is also obvious, as S_j(x) is defined to have rank j. (Less trivially, we can define it as the rank of the adjacency operation that the set is not closed under.)

Finally, f preserves incidence, i.e. two surtopes s and t are incident if and only if f(s) and f(t) share some flag. Indeed, s is incident with t if and only if there's a flag containing both s and t. And a flag contains s if and only if it's contained in f(s).

Hence, f is an isomorphism.

[mr_e_man]

Notice that the proof requires connectedness, not for all sub-polytopes, but only for sub-polytopes with the same least or greatest element as P. So a "polytope" that's connected, but not strongly, may still be fully equivalent to a polyflag.

For example, take an elongated pentagonal dipyramid, and connect its top vertex to its bottom vertex, turning it inside-out. (This is analogous to the green hexagon in the other example.) Then fill in the remaining torus-shaped space with other polyhedra, to make a 4-polyflag. (It's dyadic, unlike the other example.) The vertex figure at the central vertex is perhaps a pentagonal prism, or some other ordinary polyhedron, which is connected. But the "sub-polytope" between that vertex and the elongated dipyramid is two pentagons, disconnected.

[wendy]

It seems an extraordinary way of going about this. Incidence gives rise to the orthoscheme (flag), and also the hasse diagram. The incidence can be though of as an S->A arrow, where 'S' is in the surounding, and A the arounding S is at a lesser rank than a, so A appears in the verge [S-figure], S appears on the surface of A

This is sufficient to show klitzing matrix works, they being s\a, the surtope being to the left below the diagonal, and the aroundings to the right of the diagonal. Because each head and tail is counted for, it suffices that far.

The hasse diagram is an antitegum. Between any points incident on each other lies also an antitegum. It represents a polytope that is a surtope of the verge. Norman Johnson calls this a cluster.

It is unclear how you plan to do with boundless surtopes, such as the surface of a sphere. There is no direct downward incidence here.

[mr_e_man]

Incidence gives rise to the orthoscheme (flag)

That's true for polytopes, of course, by definition. It's not true for polyflags in general. That was the point of this post. The square dihedron twisted dichoron, and the digon dihedron dichoron, have exactly the same Hasse diagram, but different flag structures. There are 2 vertices, 2 edges, 2 hedra, and 2 chora (and maybe 1 nulloid and 1 teron).

We might be able to make it true, by allowing two surtopes to be incident more than once. I haven't looked into this.

It represents a polytope that is a surtope of the verge. Norman Johnson calls this a cluster.

Also called "subpolytope", "subtope", "subposet", or "section", depending on the author.

It is unclear how you plan to do with boundless surtopes, such as the surface of a sphere.

I do not.

[mr_e_man]

Relevant: https://doc.cgal.org/latest/Generalized_map/index.html

They take x⟨k⟩ = x to mean that the flag x doesn't have a k-adjacent flag.
I take x⟨k⟩ = x to mean that x is adjacent to itself. If it's not adjacent to anything, then x⟨k⟩ should be undefined.

I was thinking that the property x⟨k⟩ ≠ x (for all x and all k) should have a name, as a weaker kind of separability. They say that such a polyflag is without boundary, but I can't use that term because of the difference in interpretation in the previous paragraph.

So, I'll say a polyflag is flag-separable, when for any flag x and any rank k we have x⟨k⟩ ≠ x.
And a polyflag is surtope-separable, when for any flag x and any rank k we have x and x⟨k⟩ being in different k-surtopes.
"Separable" remains a synonym for "surtope-separable".

The idea behind the term "separable" is that you can pull apart two things that are adjacent. (The things could be individual flags, or sets of flags.) Of course you can't pull them apart if they're actually the same thing.

[mr_e_man]

Also relevant: Flag graph , Polytopality of Maniplexes

A maniplex is like a polyflag, but it's required to be a simple graph, so x⟨k⟩ ≠ x, and x⟨k⟩ ≠ x⟨j⟩ when k ≠ j. (The monogon is thus not a maniplex.)

[mr_e_man]

There are several approaches to realization. One question is whether flags should be oriented (in the "left vs. right" sense). For now I'll ignore orientation.

A real (or concrete) flag is a sequence of subspaces of all dimensions, where each subspace is contained in the next.

A realization of an abstract polyflag is a function that maps each element to a real flag, such that, for any two ranks j≠k, any two k-adjacent flags have the same j-dimensional subspace. (In other words, x⟨k⟩ may differ from x only in its k-dimensional subspace.)

I won't yet define non-degeneracy of a polyflag realization. I need to think about it more. Here are some possible conditions:

• Distinct abstract flags are mapped to distinct real flags (i.e. the function is injective).
• Two flags are k-adjacent if and only if their j-dimensional subspaces are equal for all j≠k.
• If two flags are k-adjacent, then their k-dimensional subspaces are different.
• If two flags are in different (abstract) k-surtopes, then their k-dimensional subspaces are different.
• Variations on these conditions involving orientation....

[mr_e_man]

(To simplify things, let's work in spheric space rather than Euclidean space. Modifications are possible.)

An oriented flag is a sequence of oriented subspaces of all dimensions, where each subspace is contained in the next.

In terms of Geometric Algebra, an oriented k-dimensional subspace is a unit (k+1)-blade, i.e. the geometric product of k+1 orthonormal vectors. Furthermore, if a subspace contains another, then the blade contains the other blade as a factor. So an oriented flag can be represented as a multivector, a sum of blades:

X = 1 + u₀ + u₀u₁ + u₀u₁u₂ + ... + (u₀u₁u₂...u_n-1) + (u₀u₁u₂...u_n-1u_n),

where the u's are orthonormal vectors. The flag's k-dimensional subspace is represented by ⟨X⟩_k+1 = u₀u₁...u_k. (Sorry about the notational conflict. In GA the angle brackets denote grade projection, whereas in polyflags the angle brackets denote adjacent flags.) The vectors determine the blades, and vice versa: u_k = ⟨X⟩_k^~ ⟨X⟩_k+1.

In a polytope, these would be insiding vectors.
(If this term is unfamiliar, see viewtopic.php?f=25&t=2437 .)

If Y is the flag k-adjacent to X, and is formed from vectors v, then the dyadic rule for insiding says v_kv_k+1 = - u_ku_k+1. The other vectors are the same: v_j = u_j for j<k or j>k+1. It follows that ⟨Y⟩_j+1 = ⟨X⟩_j+1 for j<k, and ⟨Y⟩_j+1 = -⟨X⟩_j+1 for j>k. That is, the lower-dimensional subspaces are unchanged, and the higher-dimensional subspaces are negated (the orientation is flipped) by the adjacency operation.

The angle (measure) of the k-dyad formed by X and Y can be determined from the four vectors. Specifically, if θ is the angle, then cosθ = u_k•v_k = - u_k+1•v_k+1, and sinθ = u_k+1•v_k = u_k•v_k+1.

Conversely (given X), the adjacent flag Y can be determined from the angle: v_k = u_kcosθ + u_k+1sinθ, and v_k+1 = u_ksinθ - u_k+1cosθ.

Thus, an oriented real polyflag is fully described by the following data: the abstract polyflag, and the realization of a single flag, and the dyad measures for all adjacencies between flags. (But the dyad measures are subject to some consistency conditions; they can't be chosen arbitrarily.) The realizations of all other flags can then be calculated.


Also, a transformation (rotation or reflection etc.) is uniquely determined by what it does to a single oriented flag (equivalent to an orthonormal basis).
In other words, a flag has no symmetry. Distinct transformations, applied to one flag, result in distinct flags.

So the number of flags in a symmetry equivalence class is exactly the size of the polyflag's symmetry group. In contrast, the number of equivalent surtopes is usually less than the size of the group.