Contents

# Operators and functions for type PFACE

&<
```&<(f1::PFACE, f2::PFACE)::boolean
&>(f2::PFACE, f1::PFACE)::boolean
f1 &< f2
f2 &> f1
```

Test whether f1 is a proper face of f2. Both faces must have identical domains.

&<<
```&<<(f1::PFACE, f2::PFACE)::boolean
&>>(f2::PFACE, f1::PFACE)::boolean
f1 &<< f2
f2 &>> f1
```

Test whether f1 is a facet of f2. Both faces must have identical domains.

&<=
```&<=(f1::PFACE, f2::PFACE)::boolean
&>=(f2::PFACE, f1::PFACE)::boolean
f1 &<= f2
f2 &>= f1
```

Test whether f1 is a face of f2. Both faces must have identical domains.

&<>
```&<>(f1::PFACE, f2::PFACE)::boolean
f1 &<> f2
```

Test whether f1 and f2 represent different faces. This is true if their domains are not identical.

&=
```&=(f1::PFACE, f2::PFACE)::boolean
f1 &= f2
```

Test whether f1 and f2 represent the same face. This is false if they domains are not identical.

&x
```&x(f1::PFACE, f2::PFACE, ...)::PFACE
f1 &x f2
```

The Cartesian product of the given faces, considered as a face of the Cartesian product of their domains. See POLYHEDRON[&x].

ambientdim
```ambientdim(f::PFACE)::nonnegint
```

The dimension of the ambient space of f.

codim
```codim(f::PFACE)::nonnegint
```

The codimension of f in its ambient space. See also POLYHEDRON[codim], dim and corank.

convert/CFACE
```convert(f::PFACE, CFACE)::CFACE
```

This functions converts f to the corresponding face of the homogenization convert(domain(f), CONE) of its domain. See also POLYHEDRON[convert/CONE].

convert/POLYHEDRON
```convert(f::PFACE, POLYHEDRON)::POLYHEDRON
```

This functions converts f to the POLYHEDRON representing the same point set.

corank
```corank(f::PFACE)::nonnegint
```

The corank of f in the face lattice of its domain. This is the distance between f and the maximal element of the face lattice. See also rank.

dim
```dim(f::PFACE)::integer
```

The dimension of f. Note that the dimension of a facet of f may be different from dim(f)-1 if the facet is empty. See also POLYHEDRON[dim] and rank.

Examples
 f := maximal(cube(2));
f := PFACE(4,0)
 dim(f); map(dim, pred(f));
2
[1, 1, 1, 1]
If the minimal non-empty faces have positive dimension, then the dimension of the empty face (their common facet) differs by more than 1:
 P := cube(1) &x fullpolyhedron(1); f := support(P, [1, 0]);
P := POLYHEDRON(2,2,1,[2, 0],[1])
f := PFACE(1,1)
 dim(f); map(dim, pred(f));
1
[-1]
domain
```domain(f::PFACE)::POLYHEDRON
```

The polyhedron of which f is a face. Mathematically speaking, f may be a face of many polyhedra, but with the Convex package it is always constructed as the face of a fixed polyhedron. See POLYHEDRON[isface] for a way to change the domain.

Examples
 P := cube(2); f := support(P, [1, 0]);
P := POLYTOPE(2,2,4,4)
f := PFACE(2,1)
 domain(f) &= P;
true
dual
```dual(f::PFACE)::PFACE
```

If P is bounded and contains the origin in is interior (i.e., if P is of type POLYTOPE__0), then there is an order-reversing bijection between the faces of P and of its dual. This function returns the face of dual(P) which is dual to f in this sense. Note that (even as point sets) this is not the same as the dual of f, considered as polyhedron.

In the general case, one can still assign a "dual" face to f (by taking the dual in the category of cones and then intersecting the result with the halfspace at infinity), but this may no longer be a bijection.

Examples
 P := cube(2); f := support(P, [1, 1]);
P := POLYTOPE(2,2,4,4)
f := PFACE(1,2)
 f2 := dual(f); vertices(f2); domain(f2) &= dual(domain(f));
f2 := PFACE(2,1)
[[0, -1], [-1, 0]]
true
 P2 := dual(convert(f, POLYHEDRON)); vertices(P2); rays(P2), lines(P2);
P2 := POLYHEDRON(2,2,1,[1, 1],[1])
[[0, -1]]
[[0, 1]], [[1, -1]]
hspacenos
```hspacenos(f::PFACE)::set(posint)
```

The set of indices of the facets incident to f. The ordering is that of hspaces(domain(f)), see POLYHEDRON[hspaces]. This is a low-level routine.

isbounded
```isbounded(f::PFACE)::boolean
```

Test whether f is bounded.

isempty
```isempty(f::PFACE)::boolean
```

Test whether f is the empty face.

maximum
```maximum(f1::PFACE, f2::PFACE, ...)::PFACE
```

The maximum of f1, f2 ... in the face lattice. All faces must have the same domain, which will also be the domain of the result. At least one face must be given.

minimum
```minimum(f1::PFACE, f2::PFACE, ...)::PFACE
```

The minimum of f1, f2 ... in the face lattice. All faces must have the same domain, which will also be the domain of the result. At least one face must be given.

pred
```pred(f::PFACE)::list(PFACE)
```

A list containing the predecessors of f in the face lattice of domain(f). These are the faces whose rank is one smaller than that of f, or, in other words, the facets of f. See also succ.

Examples
 P := cube(3); f := support(P, [0, 1, 1/5]); vertices(f);
P := POLYTOPE(3,3,8,6)
f := PFACE(4,1)
[[-1, 1, -1], [1, 1, -1], [-1, 1, 1], [1, 1, 1]]
 L := pred(f); map(vertices, L);
L := [PFACE(2,2), PFACE(2,2), PFACE(2,2), PFACE(2,2)]
[[[1, 1, -1], [1, 1, 1]], [[-1, 1, 1], [1, 1, 1]], [[-1, 1, -1], [-1, 1, 1]], [[-1, 1, -1], [1, 1, -1]]]
 f := minimal(P); rank(f); pred(f);
f := PFACE(0,6)
0
[]
rank
```rank(f::PFACE)::nonnegint
```

The rank of f in the face lattice of its domain. This is the distance between f and the empty face. This function behaves better with respect to facets than the dimension.

Examples
 P := fullpolyhedron(2); f1 := maximal(P); f2 := minimal(P);
P := POLYHEDRON(2,2,2,[1, 0],[0])
f1 := PFACE(1,0)
f2 := PFACE(0,1)
 dim(f1), dim(f2);
2, -1
 rank(f1), rank(f2);
1, 0
raynos
```raynos(f::PFACE)::set(posint)
```

The set of indices of the rays incident to f. The ordering is that of rays(domain(f)), see POLYHEDRON[rays]. This is a low-level routine.

rays
```rays(f::PFACE)::list(vec)
```

A list of the rays of f. See POLYHEDRON[rays]. Do not make any assumption about the order.

relint
```relint(f::PFACE1)::vec
```

A point in the relative interior of f.

succ
```succ(f::PFACE)::list(PFACE)
```

A list containing the successors of f in the face lattice of domain(f). These are the faces whose rank is one bigger than that of f, or, in other words, the faces of which f is a facet. See also pred.

Examples
 P := cube(2);
P := POLYTOPE(2,2,4,4)
 L := succ(minimal(P)); map(vertices, L);
L := [PFACE(1,2), PFACE(1,2), PFACE(1,2), PFACE(1,2)]
[[[-1, -1]], [[1, -1]], [[-1, 1]], [[1, 1]]]
 succ(maximal(P));
[]
surface
```surface(f::PFACE)::{nonnegative, pos_infinity}
```

The surface of f with respect to the induced Euclidean volume. This is 0 if and only if f is empty or has only the empty face as facet. See also POLYHEDRON[surface].

vertexnos
```vertexnos(f::PFACE)::set(posint)
```

The set of indices of the vertices incident to f. The ordering is that of vertices(domain(f)), see POLYHEDRON[vertices]. This is a low-level routine.

vertices
```vertices(f::PFACE)::list(vec)
```

A list of the vertices of f. See POLYHEDRON[vertices]. Do not make any assumption about the order.

volume
```volume(f::PFACE)::{nonnegative, pos_infinity}
```

The volume of f with respect to the induced Euclidean volume. Unlike POLYHEDRON[volume], this function never returns 0 for non-empty polyhedra.