A new face iterator for polyhedra and more general finite locally branched lattices

TL;DR

This paper introduces a memory-efficient depth-first algorithm for iterating over elements of finite locally branched lattices, applicable to polyhedral structures and generalizations, with practical speed improvements and applications to Wilf's conjecture.

Contribution

The paper presents a novel, fast, memory-efficient algorithm for traversing finite locally branched lattices, extending its application to complex geometric and algebraic structures.

Findings

Algorithm is significantly faster than previous methods.

Successfully applied to verify Wilf's conjecture for all numerical semigroups of multiplicity 19.

Effective in analyzing face lattices of polyhedra and related structures.

Abstract

We discuss a new memory-efficient depth-first algorithm and its implementation that iterates over all elements of a finite locally branched lattice. This algorithm can be applied to face lattices of polyhedra and to various generalizations such as finite polyhedral complexes and subdivisions of manifolds, extended tight spans and closed sets of matroids. Its practical implementation is very fast compared to state-of-the-art implementations of previously considered algorithms. Based on recent work of Bruns, Garc\'ia-S\'anchez, O'Neill and Wilburne, we apply this algorithm to prove Wilf's conjecture for all numerical semigroups of multiplicity 19 by iterating through the faces of the Kunz cone and identifying the possible bad faces and then checking that these do not yield counterexamples to Wilf's conjecture.

Equations

$$\mathrm{Atoms}(\mathcal{P})=\{p\in \mathcal{P}\mid \hat{0}\prec p\}$$

$$\mathrm{Atoms}(p\wedge q)\subseteq \mathrm{Atoms}(p)\cap \mathrm{Atoms}(q).\text{qed}$$

$$\alpha =\sum _{a\in \text{coatoms}\cup \text{ignored\_sets}}|a\cup \text{ignored\_atoms}|.$$

$$c(S)\le e(S)n(S).$$

$$x_i+x_j\ge x_{i+j}1\le i\le j\le m-1,i+j<m,$$

$$x_i+x_j+1\ge x_{i+j}1\le i\le j\le m-1,i+j>m,$$

$$x_i+x_j\ge x_{i+j}1\le i\le j\le m-1,i+j\ne m.$$

$$m{x}_i+i\le m{x}_f+f\text{for every i=f}$$

$$mx_{f}+f-m+1>e(F)\cdot\big{(}mx_{f}+f-m-(x_{1}+\dots,+x_{m-1})+1\big{)}.$$

Full text

J.K. receives funding by the Deutsche Forschungsgemeinschaft DFG under Germany´s Excellence Strategy – The Berlin Mathematics Research Center MATH+ (EXC-2046/1, project ID: 390685689). C.S. is supported by the DFG Heisenberg grant STU 563/4-1 “Noncrossing phenomena in Algebra and Geometry”.

1. Introduction

We call a finite lattice $(\mathcal{P},\leq)$ locally branched if all intervals of length two contain at least four elements. We show that such lattices are atomic and coatomic and refer to Section 2 for details.

This paper describes a depth-first algorithm to iterate through the elements in a finite locally branched lattice given its coatoms, see Section 3. It moreover describes variants of this algorithm allowing the iteration over slightly more general posets. Most importantly, examples of such locally branched lattices (or its mild generalizations) include face posets of

• •

polytopes and unbounded polyhedra,

• •

finite polytopal or polyhedral complexes,

• •

finite polyhedral subdivisions of manifolds,

• •

extended tight spans, and

• •

closed sets of matroids.

One may in addition compute all cover relations as discussed in Subsection 4.1. The provided theoretical runtime (without variants) is the same as of the algorithm discussed by V. Kaibel and M. E. Pfetsch in [7], see Section 4. In the sligthly generalized situations, the theoretical runtime might be better as for extended tight spans (without chords) with many facets (using the opposite lattice), or might be worse as for extended tight spans with many vertices.

In practice it appears that the chosen data structures and implementation details make the implementation111See https://trac.sagemath.org/ticket/26887, merged into SageMath version sage-8.9. very fast for the iteration and still fast for cover relations in the graded case compared to state-of-the-art implementations of previously considered algorithms, see Section 5.

In Section 6, we apply the presented algorithm to affirmatively settle Wilf’s conjecture for all numerical semigroups of multiplicity $19$ by iterating, up to a certain symmetry of order $18$, through all faces of the Kunz cone (which is a certain unbounded polyhedron), identifing the bad faces which possibly yield counterexamples to Wilf’s conjecture, and then checking that these do indeed not yield such counterexamples. This is based on recent work of W. Bruns, P. García-Sánchez, C. O’Neill and D. Wilburne [3] who developed this approach to the conjecture and were able to settle it up to multiplicity $18$.

In Appendix A, we finally collect detailed runtime comparisions between the implementation of the presented algorithm with the state-of-the-art implementations in polymake and in normaliz.

Acknowledgements

We thank Michael Joswig and Winfried Bruns for valuable discussions and for providing multiple relevant references. We further thank Jean-Philippe Labbé for pointing us to [3] and all participants of the trac ticket in SageMath11footnotemark: 1 for stimulating discussions.

2. Formal framework

Let $(\mathcal{P},\leq)$ be a finite poset and denote by $\prec$ its cover relations. We usually write $\mathcal{P}$ for $(\mathcal{P},\leq)$ and write $\mathcal{P}^{\operatorname{op}}$ for the opposite poset $(\mathcal{P}^{\operatorname{op}},\leq_{\operatorname{op}})$ with $b\leq_{\operatorname{op}}a$ if $a\leq b$. For $a,b\in\mathcal{P}$ with $a\leq b$ we denote the interval as $[a,b]=\{p\in\mathcal{P}\mid a\leq p\leq b\}$. If $\mathcal{P}$ has a lower bound $\hat{0}$, its atoms are the upper covers of the lower bound,

[TABLE]

and, for $p\in\mathcal{P}$, we write $\operatorname{Atoms}(p)=\{a\in\operatorname{Atoms}(\mathcal{P})\mid p\geq a\}$ for the atoms below $p$. Analogously, if $\mathcal{P}$ has an upper bound $\hat{1}$, its coatoms are the lower covers of the upper bound, $\operatorname{coAtoms}(\mathcal{P})=\{p\in\mathcal{P}\mid p\prec\hat{1}\}$. $\mathcal{P}$ is called graded if it admits a rank function $r\colon\mathcal{P}\to\mathbb{Z}$ with $p\prec q\Rightarrow r(p)+1=r(q)$.

Definition 2.1**.**

$\mathcal{P}$ is locally branched if for every saturated chain $a\prec b\prec c$ there exists an element $d\neq b$ with $a<d<c$. If this element is unique, then $\mathcal{P}$ is said to have the diamond property.

The diamond property is a well-known property of face lattices of polytopes, see [9, Theorem 2.7(iii)]. The property of being locally branched has also appeared in the literature in contexts different from the present under the name $2$-thick lattices, see for example [1] and the references therein.

An obvious example of a locally branched lattice is the boolean lattice $B_{n}$ given by all subsets of $\{1,\dots,n\}$ ordered by containment. We will later see that all locally branched lattices are meet semi-sublattices of $B_{n}$.

In the following, we assume $\mathcal{P}$ to be a finite lattice with meet operation $\wedge$, join operation $\vee$, lower bound $\hat{0}$ and upper bound $\hat{1}$. We say that

• •

$\mathcal{P}$ is atomic if all elements are joins of atoms,

• •

$\mathcal{P}$ is coatomic if all elements are meets of coatoms,

• •

$p\in\mathcal{P}$ is join-irreducible if $p$ has a unique lower cover $q\prec p$,

• •

$p\in\mathcal{P}$ is meet-irreducible if $p$ has a unique upper cover $p\prec q$.

Atoms are join-irreducible and coatoms are meet-irreducible. The following classification of atomic and coatomic lattices is well-known.

Lemma 2.2**.**

We have that

1. (i)

$\mathcal{P}$* is atomic if and only if the only join-irreducible elements are the atoms,* 2. (ii)

$\mathcal{P}$* is coatomic if and only if the only meet-irreducible elements are the coatoms.*

Proof.

First observe that for all $p,q\in\mathcal{P}$ we have $p\geq q\Rightarrow\operatorname{Atoms}(p)\supseteq\operatorname{Atoms}(q)$ and $p\geq\bigvee\operatorname{Atoms}(p)$. Moreover, $\mathcal{P}$ is atomic if and only if $p=\bigvee\operatorname{Atoms}(p)$ for all $p\in\mathcal{P}$.

Assume that $\mathcal{P}$ is atomic and let $q\in\mathcal{P}$ join-irreducible and $p\prec q$. Because we have $\operatorname{Atoms}(p)\neq\operatorname{Atoms}(q)$ it follows that $p=\hat{0}$. Next assume that $\mathcal{P}$ is not atomic and let $p\in\mathcal{P}$ minimal such that $p>\bigvee\operatorname{Atoms}(p)$. If $q<p$ then by minimality $q=\bigvee\operatorname{Atoms}(q)$. It follows that $q\leq\bigvee\operatorname{Atoms}(p)$ and $p$ is join-irreducible.

The second equivalence is the first applied to $\mathcal{P}^{\operatorname{op}}$. ∎

Examples 2.3**.**

The face lattice of a polytope has the diamond property, it is atomic and coatomic, and every interval is again the face lattice of a polytope. The face lattice of an (unbounded) polyhedron might neither be atomic nor coatomic as witnessed by the face lattice of the positive orthant in $\mathbb{R}^{2}$ with five faces.

The reason to introduce locally branched posets is the following relation to atomic and coatomic lattices, which has, to the best of our knowledge, not appeared in the literature.

Proposition 2.4**.**

The following statements are equivalent:

1. (i)

$\mathcal{P}$* is locally branched,* 2. (ii)

every interval of $\mathcal{P}$ is atomic, 3. (iii)

every interval of $\mathcal{P}$ is coatomic.

Proof.

$\mathcal{P}$ is locally branched if and only if $\mathcal{P}^{\operatorname{op}}$ is locally branched. Also, $\mathcal{P}$ is atomic if and only if $\mathcal{P}^{\operatorname{op}}$ is coatomic. Hence, it suffices to show (i) $\Leftrightarrow$ (ii). Suppose $\mathcal{P}$ is not locally branched. Then, there exist $p\prec x\prec q$ such that the interval $[p,q]$ contains exactly those three elements. Clearly, $[p,q]$ is not atomic. Now suppose $[p,q]\subseteq\mathcal{P}$ is not atomic and $x$ is join-irreducible with unique lower cover $y$ with $p<y\prec x$. There exists $z\in[p,q]$ with $z\prec y$ and the interval $[z,x]$ contains exactly those three elements. ∎

Example 2.5**.**

On the left an example of a non-graded locally branched lattice. On the right an example of an atomic, coatomic lattice, which is not locally branched as the interval between the two larger red elements contains only three elements.

Let $\mathcal{P}$ be a finite locally branched poset with atoms $\{1,\dots,n\}$. As we have seen that $\mathcal{P}$ is atomic and thus $p=\bigvee\operatorname{Atoms}(p)$ for all $p\in\mathcal{P}$. The following proposition underlines the importance of subset checks and of computing intersections to understanding finite locally branched lattices.

Proposition 2.6**.**

In a finite locally branched lattice it holds that

1. (i)

$p\leq q\Leftrightarrow\operatorname{Atoms}(p)\subseteq\operatorname{Atoms}(q).$** 2. (ii)

$p\wedge q=\bigvee\left(\operatorname{Atoms}(p)\cap\operatorname{Atoms}(q)\right).$**

Proof.

1. (i)

If $p\leq q$ then clearly $\operatorname{Atoms}(p)\subseteq\operatorname{Atoms}(q)$. On the other hand, if $\operatorname{Atoms}(p)\subseteq\operatorname{Atoms}(q)$, then $p=\bigvee\operatorname{Atoms}(p)\leq\bigvee\operatorname{Atoms}(q)=q$, as $\bigvee\operatorname{Atoms}(q)$ is in particular an upper bound for $\operatorname{Atoms}(p)$. 2. (ii)

By (i) it holds that $\bigvee\left(\operatorname{Atoms}(p)\cap\operatorname{Atoms}(q)\right)$ is a lower bound of $p$ and $q$. Also, $\operatorname{Atoms}(p\wedge q)\subseteq\operatorname{Atoms}(p),\operatorname{Atoms}(q)$ and we obtain

[TABLE]

This proposition provides the following meet semi-lattice embedding of any finite locally branched lattice into a boolean lattice.

Corollary 2.7**.**

Let $\mathcal{P}$ be a finite locally branched lattice with $\operatorname{Atoms}(\mathcal{P})=\{1,\dots,n\}$. The map $p\mapsto\operatorname{Atoms}(p)$ is a meet semi-sublattice embedding of $\mathcal{P}$ into the boolean lattice $B_{n}$.

Example 2.8**.**

The above embedding does not need to be a join semi-sublattice embedding as witnessed by the face lattice of a square in $\mathbb{R}^{2}$.

Remark 2.9**.**

Proposition 2.6 shows that checking whether the relation $p\leq q$ holds in $\mathcal{P}$ is algorithmically a subset check $\operatorname{Atoms}(p)\subseteq\operatorname{Atoms}(q)$, while computing the meet is given by computing the intersection $\operatorname{Atoms}(p)\cap\operatorname{Atoms}(q)$.

Justified by Corollary 2.7, we restrict our attention in this paper to meet semi-sublattices of the boolean lattice.

2.1. Variants of this framework and examples

Before presenting in Section 3 the algorithm to iterate over the elements of a finite locally branched lattice together with variants to avoid any element above certain atoms and to avoid any element below certain coatoms (or other elements of $B_{n}$), we give the the following main use cases for such an iterator.

Example 2.10** (Polytope).**

The face lattice of a polytope $P$ has the diamond property and is thus locally branched.

Example 2.11** (Polyhedron).**

The face lattice of a polyhedron $P$ is isomorphic to the one obtained from quotiening out the affine space $P$ contains. Thus, we can assume that $P$ does not contain an affine line. It is well known (see e.g. [9, Exercise 2.19]) that we may add an extra facet $\overline{F}$ to obtain a polytope $\overline{P}$. The faces of $P$ are exactly the faces of $\overline{P}$ not contained in $\overline{F}$ (together with the empty face). Thus, the iterator visits all non-empty faces of $P$ by visiting all faces of $\overline{P}$ not contained in $\overline{F}$.

Example 2.12** (Polytopal subdivision of manifold).**

The face poset of a finite polytopal subdivision of a closed manifold (compact manifold without boundary). Adding an artificial upper bound $\hat{1}$, this is a finite locally branched lattice.

Example 2.13** (Extended tight spans).**

We consider extended tight spans as defined in [6, Section 3] as follows: Let $P\subset\mathbb{R}^{d}$ be a finite point configuration, and let $\Sigma$ be a polytopal complex with vertices $P$, which covers the convex hull of $P$. We call the maximal cells of $\Sigma$ facets. We can embedd $\Sigma$ into a closed $d$-manifold $M$: In any case, we can add a vertex at infinity and for each face $F$ on the boundary of $\Sigma$ a face $F\cup\{\infty\}$. In many cases, just adding one facet containing all vertices on the boundary will work as well.

Given a collection $\Gamma$ of boundary faces of $\Sigma$. We can iterate over all elements of $\Sigma$, which have empty intersection with $\Gamma$: Iterate over all faces of $M$, which do not contain a vertex of $\Gamma$ and are not contained in a facet in $M\setminus\Sigma$.

Example 2.14** (Closed sets of a matroid).**

The MacLane–Steinitz exchange property (see e.g. [8, Lemma 1.4.2]) ensures that the closed sets of a matroid form a locally branched finite lattice.

Example 2.15** (Locally branched lattices with non-trivial intersection).**

Let $\mathcal{P}_{1},\dots,\mathcal{P}_{k}$ be finite locally branched meet semi-sublattices of $B_{n}$. Then the iterator may iterate through all elements of their union by first iterating through $\mathcal{P}_{1}$, then through all elements in $\mathcal{P}_{2}$ not contained in $\mathcal{P}_{1}$ and so on.

Example 2.16** (Polyhedral complexes).**

Using the iteration as in the previous example allows to iterate through polytopal or polyhedral complexes, or through complexes of tight spans.

3. The algorithm

Let $\mathcal{P}$ be a finite locally branched lattice given as a meet semi-sublattice of the boolean lattice $B_{n}$. This is, $\operatorname{Atoms}{\mathcal{P}}=\{1,\dots,n\}$ and $p=\operatorname{Atoms}(p)\in\mathcal{P}$. The following algorithm is a recursively defined depth-first iterator through the elements of $\mathcal{P}$. Given $c\in\mathcal{P}$ and its lower covers $x_{1},\dots,x_{k}$, the iterator yields $c$ and then computes, one after the other, the lower covers of $x_{1},\dots,x_{k}$, taking into account those to be ignored, and then recursively proceeds. Being an iterator means that the algorithm starts with only assigning the input to the respective variables and then waits in its current state. Whenever an output is requested, it starts from its current state and runs to the point ITERATOR OUTPUT, outputs the given output, and again waits. Iterators are regularly used in modern programming languages222See https://en.wikipedia.org/wiki/Iterator..

For polyhedra, a slightly more sophisticated version of this algorithm is implemented in SageMath11footnotemark: 1. Before proving the correctness of the algorithm, we provide several detailed examples. If not mentioned otherwise, we do not ignore any atoms and always set ignored_atoms = $\{\}$ in the examples. We also assume the lists to be ordered lexicographically for iteration. One may assume that the algorithm additionally visits the upper bound given by the union of the coatoms, whenever this is suitable.

Example 3.1** (Square).**

We apply the algorithm to visit faces of a square.

• •

INPUT: coatoms = $[\{1,2\},\{1,4\},\{2,3\},\{3,4\}]$, ignored_sets = $[]$

• •

a = $\{1,2\}$, ITERATOR OUTPUT: $\{1,2\}$

• •

new_coatoms = $[\{1\},\{2\}]$

• •

Apply FaceIterator to sublattice $[\hat{0},\{1,2\}]$

• –

INPUT: coatoms = $[\{1\},\{2\}]$, ignored_sets = $[]$

• –

a = $\{1\}$, ITERATOR OUTPUT: $\{1\}$

• –

new_coatoms = $[\emptyset]$

• –

Apply FaceIterator to sublattice $[\hat{0},\{1\}]$

INPUT: coatoms = $[\emptyset]$, ignored_sets = $[]$

• *

a = $\emptyset$, ITERATOR OUTPUT: $\emptyset$

• *

(new_coatoms is empty)

• *

Apply FaceIterator to sublattice $[\hat{0},\hat{0}]$ without output

• *

Add $\emptyset$ to ignored_sets (to the copy in this call of FaceIterator)

• *

Reapply FaceIterator to sublattice $[\hat{0},\{1\}]$

• *

INPUT: coatoms = $[]$, ignored_sets = $[\emptyset]$

• –

ignored_sets = $[\{1\}]$

• –

Reapply FaceIterator to sublattice $[\hat{0},\{1,2\}]$

• –

INPUT: coatoms = $[\{2\}]$, ignored_sets = $[\{1\}]$

• –

a = $\{2\}$, ITERATOR OUTPUT: $\{2\}$

• –

Apply FaceIterator to sublattice $[\hat{0},\{2\}]$

INPUT: coatoms = $[]$, ignored_sets = $[\{1\}]$

• –

ignored_sets = $[\{1\},\{2\}]$

• –

Reapply FaceIterator to sublattice $[\hat{0},\{1,2\}]$

• –

INPUT: coatoms = $[]$, ignored_sets = $[\{1\},\{2\}]$

• •

ignored_sets = $[\{1,2\}]$

• •

Reapply FaceIterator to entire lattice

• •

INPUT: coatoms = $[\{1,4\},\{2,3\},\{3,4\}]$, ignored_sets = $[\{1,2\}]$

• •

a = $\{1,4\}$, ITERATOR OUTPUT: $\{1,4\}$

• •

Apply FaceIterator to sublattice $[\hat{0},\{1,4\}]$

• –

INPUT: coatoms = $[\{4\}]$, ignored_sets = $[\{1,2\}]$

• –

a = $\{4\}$, ITERATOR OUTPUT: $\{4\}$

• –

Apply FaceIterator to sublattice $[\hat{0},\{4\}]$ without output

• •

ignored_sets = $[\{1,2\},\{1,4\}]$

• •

… further outputs: $\{2,3\}$, $\{3\}$, $\{3,4\}$

Example 3.2** (Minimal triangulation of $\mathbb{RP}^{2}$).**

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

• •

INPUT: coatoms = $[\{1,2,4\},\dots,\{4,5,6\}]$, ignored_sets = $[]$

• •

a = $\{1,2,4\}$, ITERATOR OUTPUT: $\{1,2,4\}$, $\{1,2\}$, $\{1\}$, $\emptyset$, $\{2\}$, $\{1,4\}$, $\{4\}$, $\{2,4\}$

• •

a = $\{1,2,6\}$, ITERATOR OUTPUT: $\{1,2,6\}$, $\{1,6\}$, $\{6\}$, $\{2,6\}$

• •

a = $\{1,3,4\}$, ITERATOR OUTPUT: $\{1,3,4\}$, $\{1,3\}$, $\{3\}$, $\{3,4\}$

• •

a = $\{1,3,5\}$, ITERATOR OUTPUT: $\{1,3,5\}$, $\{1,5\}$, $\{5\}$, $\{3,5\}$

• •

a = $\{1,5,6\}$, ITERATOR OUTPUT: $\{1,5,6\}$, $\{5,6\}$

• •

a = $\{2,3,5\}$, ITERATOR OUTPUT: $\{2,3,5\}$, $\{2,3\}$, $\{2,5\}$

• •

a = $\{2,3,6\}$, ITERATOR OUTPUT: $\{2,3,6\}$, $\{3,6\}$

• •

a = $\{2,4,5\}$, ITERATOR OUTPUT: $\{2,4,5\}$, $\{4,5\}$

• •

a = $\{3,4,6\}$, ITERATOR OUTPUT: $\{3,4,6\}$, $\{4,6\}$

• •

a = $\{4,5,6\}$, ITERATOR OUTPUT: $\{4,5,6\}$

Example 3.3** (Tight span).**

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

• •

INPUT: coatoms = $[\{1,2,3,4\},\{1,2,5,6\},\{1,3,6\},\{2,4,5\}]$,

ignored_sets = $[\{3,4,5,6\}]$, ignored_atoms = $\{3,4,5,6\}$

• •

a = $\{1,2,3,4\}$, no output of $\{1,2,3,4\}$

• •

new_coatoms = $\{\{1,2\},\{1,3\},\{2,4\}\}$

• –

INPUT: coatoms = $[\{1,2\},\{1,3\},\{2,4\}]$,

ignored_sets = $[\{3,4,5,6\}]$, ignored_atoms = $\{3,4,5,6\}$

• –

a = $\{1,2\}$, ITERATOR OUTPUT: $\{1,2\}$, $\{1\}$, $\{2\}$

• –

ignored_sets = $[\{3,4,5,6\},\{1,2,3,4,5,6\}]$, coatoms = $\{\}$

• •

ignored_sets = $[\{3,4,5,6\},\{1,2,3,4,5,6\}]$, coatoms = $\{\}$

Example 3.4** (Polyhedral complex).**

O$$W$$E$$N$$S

Incorrect application by applying to all polyhedra in the complex:

• •

INPUT: coatoms = $[\{W,N,0\},\{N,E,0\},\{S,E,0\}]$, ignored_sets = $[]$

• •

a = $\{W,N,0\}$, ITERATOR OUTPUT: $\{W,N,0\}$

• •

new_coatoms = $[\{N,0\}]$, ITERATOR OUTPUT: $\{N,0\}$

• •

ignored_sets = $[\{W,N,0\}]$

• •

a = $\{N,E,0\}$, ITERATOR OUTPUT: $\{N,E,0\}$

• •

new_coatoms = $[\{E,0\}]$, ITERATOR OUTPUT: $\{E,0\}$

• •

ignored_sets = $[\{W,N,0\},\{N,E,0\}]$

• •

a = $\{S,E,0\}$, ITERATOR OUTPUT: $\{S,E,0\}$

• •

new_coatoms = $[]$

Correct application by applying successively to all faces of all polyhedra:

• •

ITERATOR OUTPUT: $\{W,N,0\}$ (output of $\hat{1}$ before applying FaceIterator)

• •

Apply algorithm for $\{W,N,0\}$:

• –

INPUT: coatoms = $[\{W,0\},\{N,0\}]$, ignored_sets = $[\{W,N\}]$

• –

ITERATOR OUTPUT: $\{W,0\}$, $\{0\}$, $\{N,0\}$

• •

ITERATOR OUTPUT: $\{N,E,0\}$

• •

Apply algorithm for $\{N,E,0\}$:

• –

INPUT: coatoms = $[\{E,0\}]$, ignored_sets = $[\{W,N,0\},\{N,E\}]$

• –

ITERATOR OUTPUT: $\{E,0\}$

• •

ITERATOR OUTPUT: $\{S,E,0\}$

• •

Apply algorithm for $\{S,E,0\}$:

• –

INPUT: coatoms = $[\{S,0\}]$, ignored_sets = $[\{W,N,0\},\{N,E,0\},\{S,E\}]$

• –

ITERATOR OUTPUT: $\{S,0\}$

3.1. Correctness of the algorithm

As assumed, let $\mathcal{P}$ be a locally branched meet semi-sublattice of the boolean lattice $B_{n}$. In the following properties and their proofs, we indeed see that if $\mathcal{P}$ is any meet semi-sublattice of $B_{n}$, the algorithm visits exactly once each element $p\in\mathcal{P}$ not contained in any of ignored_sets and not containing any of ignored_atoms if the interval $[p,\hat{1}]$ is locally branched.

Proposition 3.5**.**

The algorithm FaceIterator is well-defined in the following sense: Let $a\in$ coatoms. Then

1. (i)

The call of FaceIterator in line 18 applies the algorithm to the sublattice $[\hat{0},a]$. 2. (ii)

The call of FaceIterator in line 24 applies the algorithm to $\mathcal{P}$ with $a\ \cup$ ignored_atoms appended to ignored_sets and all coatoms contained in $a\ \cup$ ignored_atoms removed.

Proof.

The proof of (ii) is obvious. To prove (i), we have to show that the construction of new_coatoms in lines 15–17 is correct. First, observe that all elements in new_coatoms are strictly below the element $a$. Next, let $x\prec a\prec\hat{1}$ in $\mathcal{P}$. Since $\mathcal{P}$ is locally branched there is an element $b\neq a$ with $x<b\prec\hat{1}$, implying $x=a\cap b$. If $x$ is not contained in any element in ignored_sets, then the same holds for $b$ and thus, $b\in$ coatoms and $x\in$ new_coatoms. This implies that new_coatoms are exactly the lower covers of $a$ not contained in an element of ignored_sets, as desired. ∎

Theorem 3.6**.**

The algorithm FaceIterator iterates exactly once over all element in $\mathcal{P}$ which are not contained in any subset of ignored_sets, and do not contain any element in ignored_atoms.

Proof.

We argue by induction on the cardinality of coatoms. First note that the cardinalities of new_coatoms and next_coatoms in the two subsequent calls of FaceIterator in lines 18 and 24 are both strictly smaller than the cardinality of coatoms. If coatoms $=\emptyset$, then all elements of $\mathcal{P}\setminus\hat{1}$ are contained in elements of ignored_sets, and the algorithm does correctly not output any element. Suppose that coatoms $\neq\emptyset$ and let $a$ be its first element assigned in line 10. Let $p\in\mathcal{P}$. If $p$ is contained in an element of ignored_sets or contains an element in ignored_atoms then it is not outputed by the algorithm. Otherwise,

• •

if $p=a$, then the algorithm outputs $p$ correctly in line 13,

• •

if $p<a$, then $p$ is outputed in the call of FaceIterator in line 18 by induction,

• •

if $p\not\leq a$, then $p\not\leq a\ \cup$ ignored_atoms and $p$ is outputed in the call of FaceIterator in line 24 by induction. ∎

3.2. Variants of the algorithm

We finish this section with a dualization property followed by explicitly stating the result when applying the algorithm for the variants discussed in Subsection 2.1.

Corollary 3.7**.**

If ignored_sets is a list of coatoms, then the algorithm can also be applied to $\mathcal{P}^{\operatorname{op}}$ with the roles of atoms and coatoms interchanged.

We later see in Theorem 4.1 that considering $\mathcal{P}^{\operatorname{op}}$ instead of $\mathcal{P}$ might be faster as the runtime depends on the number of coatoms. For example, in Example 3.2 one could apply the algorithm to $\mathcal{P}^{{\operatorname{op}}}$ to improve runtime as there are $10$ facets but only $6$ vertices.

Corollary 3.8**.**

Let $P$ be a polytope. Provided the vertex-facet incidences of $\mathcal{P}$, the above algorithm visits exactly once all faces of $P$.

Corollary 3.9**.**

Let $P$ be an unbounded polyhedron and let $\overline{P}$ be a projectively equivalent polytope with marked face. Provided the vertex-facet incidences of $\overline{P}$, the above algorithm visits exactly once all non-empty faces of $P$.

Actually, a non-empty intersection of two faces of $P$ is not contained in the marked facet at infinity. Hence, one could even use the algorithm without providing the marked facet at infinity. This might or might not visit the empty face.

Corollary 3.10**.**

Let $P$ be a finite polytopal subidivision of a closed manifold. Provided the vertex-facet incidences the above algorithm visits exactly once all faces of $P$.

Corollary 3.11**.**

Let $\Sigma$ be an extended tight span in $\mathbb{R}^{d}$ as described in Example 2.13. Let $V$ be a subset of vertices of $\Sigma$. Provided the facets and the boundary faces in their vertex description, the above algorithm visits exactly once all faces of $\Sigma$ not containing any vertex of $V$.

Corollary 3.12**.**

Let $P$ be a polyhedral complex. Provided each maximal cell as vertex-facet incidences with possibly marked face at infinity. The algorithm can be applied to visit exactly once each element in $P$.

4. Data structures, memory usage, and theoretical runtime

The operations used in the algorithm are intersetions, subset checks and unions. It will turn out that the crucial operation for the runtime is the subset check.

For the theoretical runtime we consider representation as (sparse) sorted-lists-of-atoms. However, in the implementation we use (dense) atom-incidence-bit-vectors. This is theoretically slighly slower, but the crucial operations can all be done using bitwise operations.

Observe that a sorted-lists-of-atoms needs as much memory as there are incidences. Consider two sets $A$ and $B$ (of integers) of lengths $a$ and $b$, respectively, and a (possibly unsorted) list $C$ of $m$ sets of total length $\alpha$. Using standard implementations, we assume in the runtime analysis that

• •

finding (and possibly deleting) a given element $x$ inside $C$ has runtime $\mathcal{O}(\alpha)$,

• •

deleting all duplicates in $C$ has runtime $\mathcal{O}(\alpha\cdot m)$,

• •

intersection $A\cap B$ and union $A\cup B$ have runtime $\mathcal{O}(\max(a,b))$,

• •

a subset check $A\subseteq B$ has runtime $\mathcal{O}(b)$ and

• •

to check whether $A$ is subset of any element in $C$ has runtime $\mathcal{O}(\alpha)$.

Let $r+1$ be the number of elements in a longest chain in $\mathcal{P}$, let $m=|\text{{\tt coatoms}}|$, $n=|\text{{\tt atoms}}|$, and let

[TABLE]

(In the case that ignored_sets and ignored_atoms are both empty, $\alpha$ is the total number of atom-coatom incidences.) Moreover, let $\varphi$ be the number of recursive calls of the algorithm. (In the case that ignored_atoms is empty, $\varphi$ is the cardinality of $\mathcal{P}$. Otherwise, it is bounded by this cardinality.)

Theorem 4.1**.**

The algorithm has memory consumption $\mathcal{O}(\alpha\cdot r)$ and runtime $\mathcal{O}(\alpha\cdot m\cdot\varphi)$.

Proof.

Note first that at each recursive call of FaceIterator the number of coatoms is bounded by $m$ and the total length of coatoms, ignored_sets and ignored_atoms is bounded each by $\alpha$. With above assumptions, FaceIterator has runtime $\mathcal{O}(\alpha\cdot m)$ not considering recursive calls.

A single call of FaceIterator has memory usage at most $c\cdot\alpha$ for a global constant $c$, not taking into account the recursive calls. The call in line 24 does not need extra memory as all old variables can be discarded. The longest chain of the lattice $[0,\text{{\tt a}}]$ is at most of length $r-1$. By induction the call of FaceIterator in line 18 has total memory consumption at most $(r-1)\cdot c\cdot\alpha$. The claimed bounds follow. ∎

4.1. Computing all cover relations

Applying the algorithm to a graded locally branched meet semi-sublattice of $B_{n}$ while keeping track of the recursion depth allows an a posteriori sorting of the output by the level sets of the grading. The recursion depth is the number of iterative calls using line 18. We obtain the same bound for generating all cover relations as V. Kaibel and M. E. Pfetsch [7]. For this we additionally assume that

• •

a list of $\varphi$ sets each of length at most $n$ can be sorted in time $\mathcal{O}(n\cdot\varphi\cdot\log\varphi)$ and

• •

a set with $a$ elements can be looked up in a sorted list of $\varphi$ sets in time $\mathcal{O}(a\cdot\log\varphi)$.

Proposition 4.2**.**

Let $\mathcal{P}$ be a graded meet sublattice of $\mathcal{B}_{n}$. Assume each level set of $\mathcal{P}$ to be given as sorted-lists-of-atoms, one can generate all cover relations in time $\mathcal{O}(\alpha\cdot\min(m,n)\cdot\varphi)$ with quantities as defined above using the above algorithm.

Observe that in the situation of this proposition, ignored_sets and ignored_atoms are both empty and in particular $\alpha$ is the total length of the coatoms.

Proof.

First, we sort all level-sets. Then, we intersect each element with each coatom, obtaining its lower covers and possibly other elements. We look up each intersection to determine the lower covers.

Sorting the level sets is done in time $\mathcal{O}(n\cdot\varphi\cdot\log\varphi)$. All such intersection are obtained in time $\mathcal{O}(\varphi\cdot m\cdot n)$. For a fixed element the total length of its intersections with all coatoms is bounded by $\alpha$. Hence, all lookups are done in time $\mathcal{O}(\varphi\cdot\alpha\cdot\log\varphi)$.

Finally, we note that $m,n\leq\alpha$ and that $\log\varphi\leq\min(m,n)$. ∎

In the ungraded case, one first sorts all elements in $\mathcal{P}$, and then intersects each element $p$ with all coatoms. The inclusion maximal elements among those strictly below $p$ are lower covers of $p$. They can be looked up in the list of sorted elements to obtain an index. Observe that all this is done time $\mathcal{O}(\alpha\cdot m\cdot\varphi)$.

5. Performance of the algorithm implemented in SageMath

We present running times for the several computations. These are performed on an Intel${}^{\text{\tiny{\textregistered}}}$ Core™ i7-7700 CPU @ 3.60GHz x86_64-processor with 4 cores and 30 GB of RAM. The computations are done either using

• •

polymake 3.3 [5], or

• •

normaliz 3.7.2 [2], or

• •

the presented algorithm in sage-8.9, or

• •

the presented algorithm in sage-8.9 with additional parallelization, intrinsics, and subsequent improvements333 The presented algorithm can be parallelized easily by altering the loop call in line 9 on page 9 in Section 3. The implementation using bitwise operations also allows to use instructions for intrinsics such as Advanced Vector Extensions. This results in a runtime improvement of at least a factor $2$. Also, the subset check has been improved since sage-8.9. All these improvements will be made available in SageMath, see https://trac.sagemath.org/ticket/28893 and https://trac.sagemath.org/ticket/27103.

The default algorithms in SageMath before version sage-8.9 performs much worse than either of these and is not considered here. Given the vertex-facet incidences, we computed

1. (1)

cover relations and $f$-vector in polymake, 2. (2)

$f$-vector in normaliz with parallelization, 3. (3)

$f$-vector with the presented implementation in SageMath, 4. (4)

all cover relations with the presented implementation in SageMath, 5. (5)

$f$-vector with the presented implementation in SageMath with parallelization, intrinsics and additional improvements.

We remark that

• •

the computation of the $f$-vector in (1) also calculates all cover relations,

• •

polymake also provides a different algorithm to compute the $f$-vector from the $h$-vector for simplicial/simple polytopes (providing this additional information sometimes improves the performance in polymake), and

• •

normaliz does not provide an algorithm to compute the cover relations.

For every algorithm we record the best-of-five computation on

• •

the simplex of dimension $n$,

• •

several instances of the cyclic polyhedron of dimension $10$ and $20$,

• •

the associahedron of dimension $n$,

• •

the permutahedron of dimension $n$ embedded in dimension $n+1$,

• •

a $20$-dimensional counterexample to the Hirsch-conjecture,

• •

the cross-polytope of dimension $n$,

• •

the Birkhoff-polytope of dimension $(n-1)^{2}$,

• •

joins of such polytopes with their duals,

• •

Lawrence polytopes of such polytopes,

and refer to Appendix A for the detailed runtimes.

6. Application of the algorithm to Wilf’s conjecture

W. Bruns, P. García-Sánchez, C. O’Neill and D. Wilburne provided an algorithm that verifies Wilf’s conjecture for a given fixed multiplicity [3]. We give a brief overview of their approach:

Definition 6.1**.**

A numerical semigroup is a set $S\subset\mathbb{Z}_{\geq{0}}$ containing [math] that is closed under addition and has finite complement.

• •

Its conductor $c(S)$ is the smallest integer $c$ such that $c+\mathbb{Z}_{\geq 0}\subseteq S$.

• •

Its sporadic elements are the elements $a\in S$ with $a<c(S)$ and let $n(S)$ be the number of sporadic elements.

• •

The embedding dimension $e(S)=|S\setminus(S+S)|$ is the number of elements that cannot be written as sum of two elements.

• •

The multiplicity $m(S)$ is the minimal nonzero element in $S$.

Conjecture 6.2** (Wilf).**

For any numerical semigroup $S$,

[TABLE]

For fixed mulitplicity $m$ one can analyse certain polyhedra to verify this conjecture.

Definition 6.3** ([3, Def. 3.3]).**

Fix an integer $m\geq 3$. The relaxed Kunz polyhedron is the set $P^{\prime}_{m}$ of rational points $(x_{1},\dots,x_{m-1})\in\mathbb{R}^{m-1}$ satisfying

[TABLE]

The Kunz cone is the set $C_{m}$ of points $(x_{1},\dots,x_{m-1})\in\mathbb{R}^{m-1}$ satisfying

[TABLE]

(All indices in this definition are taken modulo $m$.)

Definition 6.4**.**

Let $F$ be a face of $P^{\prime}_{m}$ or $C_{m}$. Denote by $e(F)-1$ and $t(F)$ the number of variables not appearing on the right and left hand sides resp. of any defining equations of $F$.

The Kunz cone is a translation of the relaxed Kunz polyhedron. $e(F)$ and $t(F)$ are invariants of this translation.

Every numerical semigroup $S$ of multiplicty $m$ corresponds to a (all-)positive lattice point in $P^{\prime}_{m}$. If the point corresponding to $S$ lies in the interior of some face $F\subseteq P^{\prime}_{m}$, then $e(F)=e(S)$ and $t(F)=t(S)$, see [3, Thm. 3.10 & Cor. 3.11]. The following proposition summarizes the approach by which we can check for bad faces:

Proposition 6.5** ([3]).**

There exists a numerical semigroup $S$ with multiplicity $m$ that violates Wilf’s conjecture if and only if there exists a face $F$ of $P^{\prime}_{m}$ with positive integer point $(x_{1},\dots,x_{m-1})\in F^{\circ}$ and $f\in[1,m-1]$ such that

[TABLE]

and

[TABLE]

A face $F$ of $P^{\prime}_{m}$ is Wilf if no interior point corresponds to a violation of Wilf’s conjecture. A face $F$ of $C_{m}$ is Wilf, if the corresponding face in $P^{\prime}_{m}$ is Wilf.

Proposition 6.6** ([3] p.9).**

Let $F$ be a face of $P^{\prime}_{m}$ or $C_{m}$.

• •

If $e(F)>t(F)$, then $F$ is Wilf.

• •

If $2e(F)\geq m$, then $F$ is Wilf.

Checking Wilf’s conjecture for fixed multiplicity $m$ can be done as follows:

1. (1)

For each face $F$ in $C_{m}$ check if Proposition 6.6 holds. 2. (2)

If Proposition 6.6 does not hold, check with Proposition 6.5 if the translated face in $P^{\prime}_{m}$ contains a point corresponding to a counterexample of the Wilf’s conjecture.

We say that a face $F$ of $C_{m}$ is bad if Proposition 6.6 does not hold. The group of units $(\mathbb{Z}/m\mathbb{Z})^{\times}$ acts on $\mathbb{R}^{m-1}$ by multiplying indices. The advantage of the Kunz cone over the (relaxed) Kunz polyhedron is that it is symmetric with respect to this action. Even more, $e(F)$ and $t(F)$ are invariant under this action. Thus in order to determine the bad faces, it suffices to determine for one representative of its orbit, if it is bad. We say that an orbit is bad, if all its faces are bad.

While [3] uses a modified algorithm of normaliz to determine all bad orbits, we replace this by the presented algorithm. To use the symmetry of $C_{m}$, after visiting a facet $F$, we mark all facets in the orbit of $F$ as visited.

We visit of each orbit at least one face. By sorting the facets by orbits and some lexicographic ordering of the facet-indices, we can even guarantee that we will visit the first element of each orbit.

Now, we are in a situation to apply the presented algorithm to Wilf’s conjecture. The concrete implementation is available in SageMath444See https://git.sagemath.org/sage.git/tree/?h=u/gh-kliem/KunzConeWriteBadFaces..In the following table we compare the runtimes of computing the bad orbits:

[TABLE]

These are performed on an Intel${}^{\text{\tiny{\textregistered}}}$ Xeon™ CPU E7-4830 @ 2.20GHz with a total of 1 TB of RAM and 40 cores. We used 40 threads and about 200 GB of RAM. The timings in [3] used only 32 threads and a slightly slower machine.

While testing all bad faces takes a significant amount of time, recent work by S. Eliahou has simplified this task.

Theorem 6.7** ([4, Thm. 1.1]).**

Let $S$ be a numerical semigroup with multiplicity $m$. If $3e(S)\geq m$ then $S$ satisfies Wilf’s conjecture.

Checking the remaining orbits can be done quickly (we used an Intel${}^{\text{\tiny{\textregistered}}}$ Core™ i7-7700 CPU @ 3.60GHz x86_64-processor with 4 cores). For each of the orbits with $3e<m$, we have checked whether the corresponding region is empty analogously to the computation in [3]:

[TABLE]

This computation yields the following proposition.

Proposition 6.8**.**

Wilf’s conjecture holds for $m=19$.

Appendix A Detailed runtimes

We give, for each of the five computations, an example of how it is executed for the $2$-simplex.

(1) Compute cover relations and $f$-vector in polymake from vertex-facet-incidences:

(2) Compute $f$-vector with normaliz

(3) Compute cover relations in SageMath:

(4) & (5) Compute $f$-vector in SageMath

For displaying the runtimes, we use the following notations:

• •

$\Delta_{d}$ for the $d$-dimensional simplex,

• •

$\mathcal{C}_{d,n}$ for the $d$-dimensional cyclic polytope with $n$ vertices,

• •

$\mathcal{A}_{d}$ for the $d$-dimensional associahedron,

• •

$\mathcal{P}_{d}$ for the $d$-dimensional permutahedron,

• •

$\mathcal{H}$ for the $20$-dimensional counterexample to the Hirsch conjecture,

• •

$\square_{d}$ for the $d$-cube,

• •

$\mathcal{B}_{n}$ for the $(n-1)^{2}$-dimensional Birkhoff polytope,

• •

$P^{\operatorname{op}}$ for the polar dual of a polytope $P$,

• •

$L(P)$ for the Lawrence polytope of $P$.

The runtimes of the five best-of-five computations on the various examples are as given in the following table. “MOF” indicates that the process was killed due to memory overflow, and a dash indicates a runtime of less than a second.

[TABLE]