PolyhedralGeometryInOSCAR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a6df9a27",
   "metadata": {},
   "source": [
    "# Polyhedral Geometry\n",
    "\n",
    "* Author: Martin Bies, Luca Remke\n",
    "* Version: OSCAR version 1.1.0 or newer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48a4ce25-724b-4828-bbeb-1af79f0531f3",
   "metadata": {},
   "source": [
    "This tutorial provides an introduction to polyhedral geometry in *OSCAR*.\n",
    "\n",
    "The goal is to demonstrate basic constructions of and computations with convex polytopes, cones and polyhedral fans to newcomers to *OSCAR*. No prior knowledge of *OSCAR* is assumed.\n",
    "\n",
    "The material discussed in this tutorial is selective. For a full description of the available functionality, please consult https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/. Another very valuable resources is the article https://arxiv.org/abs/2308.07459, which provides an overview of polyhedral geometry in *OSCAR*.\n",
    " \n",
    "\n",
    "## Content\n",
    "1. [Polyhedra](#1.-Polyhedra)\n",
    "   - [Polyhedra from *H*-representation](#1.A-Polyhedra-from-*H*-representation)\n",
    "   - [Polyhedra from *V*-representation](#1.B-Polyhedra-from-*V*-representation)\n",
    "   - [Polyhedra from existing Polyhedra](#1.C-Polyhedra-from-existing-Polyhedra)\n",
    "   - [Properties and Attributes](#1.D-Properties-and-Attributes)\n",
    "   - [Standard Constructions](#1.E-Standard-Constructions)\n",
    "2. [Polyhedral Fans](#2.-Polyhedral-Fans)\n",
    "   - [Polyhedral Cones](#2.A-Polyhedral-Cones)\n",
    "   - [Polyhedral Fans](#2.B-Polyhedral-Fans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2c3cd666",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ___   ____   ____    _    ____\n",
      " / _ \\ / ___| / ___|  / \\  |  _ \\   |  Combining ANTIC, GAP, Polymake, Singular\n",
      "| | | |\\___ \\| |     / _ \\ | |_) |  |  Type \"?Oscar\" for more information\n",
      "| |_| | ___) | |___ / ___ \\|  _ <   |  Manual: https://docs.oscar-system.org\n",
      " \\___/ |____/ \\____/_/   \\_\\_| \\_\\  |  1.1.0 #release-1.1 d0b75de 2024-06-21\n"
     ]
    }
   ],
   "source": [
    "using Oscar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7c2ecc7",
   "metadata": {},
   "source": [
    "# 1. Polyhedra\n",
    "\n",
    "Let us begin by quoting the definition of polytopes and polyhedra from https://arxiv.org/pdf/2308.07459:\n",
    "\n",
    "> A polyhedron in $\\mathbb{R}^d$ is the intersection of finitely many affine closed half-spaces. Equivalently,\n",
    "polyhedra can be described by finitely many linear inequalities, whence they are precisely the\n",
    "feasible regions of linear programs. A polytope is a bounded polyhedron.\n",
    "\n",
    "As such, it is not surprising that we can define polyhedra as the intersection of finitely many affine closed half-spaces. This is called an *H-representation*. Alternatively, it is possible to define polyhedra as the convex hull of finitely many points. The latter is referred to as *V-representation*. Both constructors are supported by *OSCAR* and we shall demonstrate them momentarily.\n",
    "\n",
    "A third way of creating new polyhedra is to manipulate or \"combine\" existing polyhedra. For example, one can consider the so-called *Minkowski sum* of two (or finitely many) polyhedra. We will also demonstrate this.\n",
    "\n",
    "Before we come to demonstrate those constructors, let us mention that *OSCAR* can draw pictures of polyhedra. This can often be very helpful to picture a geometry. The command for this is `visualize(P)`, where `P` is the polyhedron in question. Similarly, it is possible to save polyhedra to files and load them afterwards:\n",
    "- `save(\"/path/to/your/desired/data/file\", P)`,\n",
    "- `load(\"/path/to/your/desired/data/file\")`.\n",
    "\n",
    "Note that he functionality of `visualize` as well as `save` and `load` extends also to cones and polyhedral fans, which we will discuss further down below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42661e13-4a00-462a-80d0-a64d4aab2853",
   "metadata": {},
   "source": [
    "## 1.A Polyhedra from *H*-representation\n",
    "\n",
    "In *H-representation*, a polyhedron is given by $P = \\{x \\in \\mathbb{R}^n \\; \\vert \\; Ax \\leq b\\}$ for a matrix $A$ and a vector $b$. The following code creates the 2-simplex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "42280e94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×2 Matrix{Int64}:\n",
       " -1   0\n",
       "  0  -1\n",
       "  1   1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [-1 0; 0 -1; 1 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6af72d90-d3d1-48c3-825e-3ef27969f221",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 0\n",
       " 0\n",
       " 1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = [0, 0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "379d75b7-52a3-48a3-856a-fda3e766022d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedron in ambient dimension 2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P1 = polyhedron(A, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13673cde-9fff-4a48-807b-01c0ff0e8df1",
   "metadata": {},
   "source": [
    "Here is a somewhat compact/alternative code sample, which creates the same polyhedron:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "51c1bbb0-d3d7-44ad-8e59-565063dc4e81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedron in ambient dimension 2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I = ([-1 0; 0 -1; 1 1], [0, 0, 1])\n",
    "P2 = polyhedron(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "552fa2a9-8eda-4f86-b6fe-d5f651b7595f",
   "metadata": {},
   "source": [
    "We can verify with *OSCAR* that those polyhedra are indeed identical:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "818f175b-5100-4cd5-bf36-b3f3e11de03a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P1 == P2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50f8b830-cabd-407c-b656-6bb3122b00ad",
   "metadata": {},
   "source": [
    "The *H* representation of a polyhedron can be recovered from the facets of *P1*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "953996f5-0f26-4c06-ba1c-5c375c36e636",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element SubObjectIterator{AffineHalfspace{QQFieldElem}} over the Halfspaces of R^2 described by:\n",
       "-x_1 <= 0\n",
       "-x_2 <= 0\n",
       "x_1 + x_2 <= 1\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "facets(P1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edc3135f-1075-4479-b305-76282c474f74",
   "metadata": {},
   "source": [
    "Certainly, *OSCAR* can compute a large number of propertes and attributes of polyhedra and polytopes. The interested reader may consult the *OSCAR* documentation: https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/. Here, we suffice it to demonstrate the computation of the volume of *P1*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1232f605-3efe-4aa6-980b-b071d280de5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1//2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume(P1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea91ef4e",
   "metadata": {},
   "source": [
    "## 1.B Polyhedra from *V*-representation\n",
    "\n",
    "We now turn to the *V*-representation of polyhedra. In this case, we have $P = \\mathrm{conv}(p_1, \\ldots , p_N)$ where $p_i \\in \\mathbb{R}^n$. The points $p_i$ are vertices of the polyhdron in question.\n",
    "\n",
    "While we will not elaborate much on the matter, let us mention that the *OSCAR* constructor also accepts rays and lineality spaces as optional input parameters. The interested reader may wish to consult the documentation (https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/).\n",
    "\n",
    "For an example, let us revisit the 2-simplex again. Its vertices $p_i$ are the origin $(0,0)$ as well as $(1,0)$ and $(0,1)$. Consequently, we construct the 2-simplex in *OSCAR* as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ab8602ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedron in ambient dimension 2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V = [0 0; 1 0; 0 1]\n",
    "P3 = convex_hull(V)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bceb9586-8bc3-437e-bdff-d40f3a565307",
   "metadata": {},
   "source": [
    "Let us verify that this gives us the same polyhedron as computed with the *H*-representations above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "54081af6-8c04-4db9-ac64-7c499576b7eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P2 == P3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "220be51d-cffa-4805-9e9b-c0b257cd760e",
   "metadata": {},
   "source": [
    "We can recover the information provided to the *V*-representation with the functions `vertices` (as well as `rays` and `lineality_space`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "985de68f-e99d-4b4f-a010-65da925192fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element SubObjectIterator{PointVector{QQFieldElem}}:\n",
       " [0, 0]\n",
       " [1, 0]\n",
       " [0, 1]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vertices(P3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c53fd69-e87d-4bb7-8746-9513e59bb142",
   "metadata": {},
   "source": [
    "Starting from a *V*-representation, the vertices are of course known upon construction. Not so about the facets, those need to be computed this time from the vertices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bcdaca4b-85d6-4ddd-8995-c998f265d1eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element SubObjectIterator{AffineHalfspace{QQFieldElem}} over the Halfspaces of R^2 described by:\n",
       "-x_1 <= 0\n",
       "-x_2 <= 0\n",
       "x_1 + x_2 <= 1\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "facets(P3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "727dd7bb",
   "metadata": {},
   "source": [
    "## 1.C Polyhedra from existing Polyhedra\n",
    "\n",
    "Polyhedra can be produced through various operations from other polyhedra. Here is a (most likely incomplete) list of available operations. More can be found in the documentation (https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/):\n",
    "\n",
    "| Method | Description |\n",
    "| :----------- | :----------- |\n",
    "| `+(P::Polyhedron, Q::Polyhedron)` | Minkowski sum $P+Q = \\{x+y \\; \\vert \\; x \\in P, y \\in Q\\}$ von `P` und `Q`. |\n",
    "| `*(k::Int, Q::Polyhedron)` | Scaled polyhedron  $kQ = \\{kx \\; \\vert \\; x \\in Q\\}$. |\n",
    "| `*(P::Polyhedron, Q::Polyhedron)` | Cartesian product of `P` and `Q`. |\n",
    "| `intersect(P::Polyhedron, Q::Polyhedron)` | Intersection $P \\cap Q$ of `P` and `Q`. |\n",
    "| `pyramid(P::Polyhedron, z::Number = 1)` | Pyramid over `P` with distance `z` between the vertex barycenter of `P` and the top of the pyramid. |\n",
    "| `convex_hull(P::Polyhedron, Q::Polyhedron)` | Convex hull of `P` and `Q`. |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b74b2826-6b3d-4bd6-b65e-dbd44c6ad64a",
   "metadata": {},
   "source": [
    "For a first example, let us compute the Minkowski sum of the 2-simplex $\\Delta_2$ with itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e4b28b64-7cc0-4209-b53e-134f8f8216fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polytope in ambient dimension 2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D2 = simplex(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1b2198b1-ce8c-4e8b-9c45-4be4d8a95e8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedron in ambient dimension 2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S1 = D2 + D2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1dace935-39be-4b7c-8740-9ec740ddaa1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element SubObjectIterator{PointVector{QQFieldElem}}:\n",
       " [0, 0]\n",
       " [2, 0]\n",
       " [0, 2]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vertices(S1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "622f0793-c26d-4704-9387-cd32ba8ce6e9",
   "metadata": {},
   "source": [
    "So the Minkowski sum $\\Delta_2 + \\Delta_2$ of the standard 2-simplexes has the vertices $(0,0)$, $(2,0)$ and $(0,2)$. Actually, this is exactly the same polyhedron that we obtain by scaling $\\Delta_2$ by $2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7739d608-112f-4f94-a898-486fe05ea1e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polytope in ambient dimension 2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S2 = 2 * simplex(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "06cf9210-86c8-4fa4-8cff-7d5804ca9f11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S1 == S2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6883fb1a-67b1-4daf-8c24-c561ba3b61b4",
   "metadata": {},
   "source": [
    "Finally, notice that $(\\tfrac{1}{3}, \\tfrac{1}{3})$ is the centroid of $\\Delta_2$. Therefore, the pyramid of $\\Delta_2$ has the vertex $(\\tfrac{1}{3}, \\tfrac{1}{3}, 1)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0d692644",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polytope in ambient dimension 3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S3 = pyramid(simplex(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "88ff2213-ae9d-4160-99fe-d5ebd413b072",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element SubObjectIterator{PointVector{QQFieldElem}}:\n",
       " [0, 0, 0]\n",
       " [1, 0, 0]\n",
       " [0, 1, 0]\n",
       " [1//3, 1//3, 1]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vertices(S3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "bf305313-318c-4a65-a939-9e7234585aa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1//6"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volume(S3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "576b3e52-4d64-44ad-9763-e83a3680c497",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element SubObjectIterator{AffineHalfspace{QQFieldElem}} over the Halfspaces of R^3 described by:\n",
       "-x_3 <= 0\n",
       "-3*x_1 + x_3 <= 0\n",
       "-3*x_2 + x_3 <= 0\n",
       "3*x_1 + 3*x_2 + x_3 <= 3\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "facets(S3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "961da188-70c8-4113-8fad-53497e9b9857",
   "metadata": {},
   "source": [
    "## 1.D Properties and Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c3b1189-b3aa-4232-bcc3-1a417bbdea6b",
   "metadata": {},
   "source": [
    "We have already seen, that for a given polyhedron we can compute its vertices and facets. But there are many more properties and attributes that are supported within *OSCAR*. Let us provide some examples. To this end, we again focus on the 2-simplex $\\Delta_2$.\n",
    "\n",
    "We begin with `ambient_dim`, that is the integer $n$ such that - by construction - the simplex is embedded into $\\mathbb{R}^n$. So for $Delta_2$, the ambient dimension is $2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c4029033-4d02-4cd5-ae6c-49e598a0cdce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ambient_dim(D2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c6ed889-be0a-4f36-836e-67f8e12afa0d",
   "metadata": {},
   "source": [
    "The simplex $\\Delta_2$ itself has dimension $2$ and lies in codimension $0$ of $\\mathbb{R}^2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "01b4ac6e-fb48-460d-8892-3db3c6c82a81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dim(D2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5b0d232f-3f45-4335-aa25-8aef73050707",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codim(D2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25c71e52-3b7e-448d-a860-451a0aea4456",
   "metadata": {},
   "source": [
    "This means that $\\Delta_2$ is full dimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9ade4c21-59d5-4c54-ac80-e4437a2089ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_fulldimensional(D2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c343f790-a039-48e6-9637-0bc8aa71d6b3",
   "metadata": {},
   "source": [
    "We can wonder if a polyhedron is bounded, i.e. is a polytope. Certainly, $\\Delta_2$ is bounded:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6791555f-a650-4572-946b-5bd2083cb10c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_bounded(D2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "363c5ada-419a-42e8-b935-8c510d78391b",
   "metadata": {},
   "source": [
    "For polytopes - by virtue of their boundedness - the number of lattice points contained in the polytope is finite. Therefore, we can execute the following function for $\\Delta_2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f9f9514e-1418-4615-9e6b-a2e177ad6c30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element SubObjectIterator{PointVector{ZZRingElem}}:\n",
       " [0, 0]\n",
       " [0, 1]\n",
       " [1, 0]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lattice_points(D2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33eaa059-a47f-46c5-980b-0031728d0237",
   "metadata": {},
   "source": [
    "Of course, we can also \"just\" count vertices or facets of polyhedra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3e96c9cd-9b53-44af-9437-b41a0f5992a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_vertices(D2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4c52357b-94e9-464f-8c13-fa124a268f0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_facets(D2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f18d253-bdce-472c-a771-77d173387ef6",
   "metadata": {},
   "source": [
    "There are many more properties and attributes for polyhedra supported by *OSCAR*. The following is a (likely incomplete) list. We again encourage interested readers to consult the documentation (https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/):\n",
    "\n",
    "| Method | Description |\n",
    "| :----------- | :----------- |\n",
    "| `facets(as::Type{T} = AffineHalfspace, P::Polyhedron)` | Facets of `P` in the format defined by `as` (`Halfspace` (Default), `Polyhedron` or `Pair`). |\n",
    "| `vertices(P::Polyhedron)` | Iterator over the vertices of a polyhedron `P` as points. |\n",
    "| `rays(P::Polyhedron)` | Minimal set of generators of the cone of unbounded directions of `P` (i.e. its rays) as points. |\n",
    "| `rays_modulo_lineality(as, P::Polyhedron)` | Rays of the recession cone of `P` up to lineality as a `NamedTuple` with two iterators. |\n",
    "| `minimal_faces(as, P::Polyhedron)` | Minimal faces of a polyhedron as a `NamedTuple` with two iterators. |\n",
    "| `affine_hull(P::Polytope)` | (Affine) hyperplanes generating the affine hull of `P`.  |\n",
    "| `ambient_dim(P::Polyhedron)` | Ambient dimension of `P`. |\n",
    "| `dim(P::Polyhedron)` | Dimension of `P`. |\n",
    "| `codim(P::Polyhedron)` | Codimension of `P`. |\n",
    "| `is_bounded(P::Polyhedron)` | Checks whether `P` is bounded. |\n",
    "| `is_feasible(P::Polyhedron)` | Checks whether `P` is non-empty. |\n",
    "| `is_fulldimensional(P::Polyhedron)` | Checks whether `P` is full-dimensional. |\n",
    "| `is_lattice_polytope(P::Polyhedron{QQFieldElem})` | Checks whether `P` is bounded and has integral vertices. |\n",
    "| `lineality_dim(P::Polyhedron)` | Dimension of the largest affine subspace contained in `P`. |\n",
    "| `lineality_space(P::Polyhedron)` | Matrix whose row span is the lineality space of `P`. |\n",
    "| `recession_cone(P::Polyhedron)` | Recession cone of `P`. |\n",
    "| `relative_interior_point(P::Polyhedron)` | A point in `P` not contained in any facet. |\n",
    "| `n_facets(P::Polyhedron)` | Number of facets of `P`. |\n",
    "| `n_vertices(P::Polyhedron)` | Number of vertices of `P`. |\n",
    "| `f_vector(P::Polyhedron)` | Vector $(f_1, ..., f_{\\dim(PF)-1})$, where $f_i$ is the number of faces of `P` of dimension $i$. |\n",
    "| `g_vector(P::Polyhedron)` | Toric $g$-vector of a (bounded) polytope, defined by $g_0=1$ and $g_k = h_k - h_{k-1}$ for $1 \\leq k \\leq \\lceil (d+1)/2 \\rceil$, where $h$ is the $h$-vector and $d = \\dim P$. |\n",
    "| `h_vector(P::Polyhedron)` | Toric $h$-vector of a (bounded) polytope; for simplicial polytopes this is a linear transformation of the $f$-vector. |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8899d3bf-2b03-4678-bad0-657b06340126",
   "metadata": {},
   "source": [
    "## 1.E Standard Constructions\n",
    "\n",
    "There are many famous standard constructions for polyhedra. A large number is supported by *OSCAR*. The supported constructions include the following. For a complete up-to-date list, please consult the documentation:\n",
    "\n",
    "| Function | Description |\n",
    "| :----------- | :----------- |\n",
    "| `archimedean_solid(s::String)` | Archimedean solid with the name given by String `s`, see [here](https://docs.oscar-system.org/stable/PolyhedralGeometry/Polyhedra/constructions/). |\n",
    "| `birkhoff(n::Integer, even::Bool = false)` | Birkhoff polytop of dimension `n`$^2$. |\n",
    "| `catalan_solid(s::String)` | Catalan solid with the name given by String `s`, see [here](https://docs.oscar-system.org/stable/PolyhedralGeometry/Polyhedra/constructions/). |\n",
    "| `cross_polytope([::Type{T} = QQFieldElem,] d::Int [,n::Rational])` | `d`-dimensional cross polytope around the origin with vertices located at $\\pm e_i$ for each unit vector $e_i$ of $\\mathbb{R}^d$, scaled by `n`. |\n",
    "| `cube([::Type{T} = QQFieldElem,] d::Int , [l::Rational = -1, u::Rational = 1])` | $[l,u]$-cube in dimension `d`. |\n",
    "| `cyclic_polytope(d::Int, n::Int)` | Cyclic polytope that is the convex hull of `n` points on the moment curve in dimension `d`. |\n",
    "| `del_pezzo_polytope(d::Int)` | `d`-dimensional del Pezzo polytop. |\n",
    "| `dodecahedron()` | Regular dodecahedron, one of the Platonic solids. |\n",
    "| `fano_simplex(d::Int)` | A lattice simplex such that the origin is the unique interior lattice point. |\n",
    "| `fractional_cut_polytope(G::Graph{Undirected})` | The fractional cut polytope of the graph `G`. |\n",
    "| `fractional_matching_polytope(G::Graph{Undirected})` | The fractional matching polytope of the graph `G`. |\n",
    "| `gelfand_tsetlin(lambda::AbstractVector)` | Gelfand Tsetlin polytope indexed by a weakly decreasing vector `lambda`. |\n",
    "| `icosahedron()` | Regular icosahedron, one of the Platonic solids. |\n",
    "| `johnson_solid(i::Int)` | `i`-th proper Johnson solid. |\n",
    "| `newton_polytope(poly::Polynomial)` | Newton polytope of the multivariate polynomial `poly`. |\n",
    "| `orbit_polytope(V::AbstractCollection[PointVector], G::PermGroup)` | Convex hull of the orbit of one or several points (given row-wise in `V`) under the action of `G`. |\n",
    "| `platonic_solid(s::String)` | Platonic solid with the name given by String `s`, see [here](https://docs.oscar-system.org/stable/PolyhedralGeometry/Polyhedra/constructions/). |\n",
    "| `rand_spherical_polytope([rng::AbstractRNG,] d::Int, n::Int;` <br> `distribution=:uniform, precision=nothing, seed=nothing)` | The convex hull of `n` points on the unit sphere in $\\mathbb{R}^d$. |\n",
    "| `regular_24_cell()` | Regular 24-cell, one out of three exceptional regular 4-polytopes. |\n",
    "| `regular_120_cell()` | Regular 120-cell, one out of three exceptional regular 4-polytopes. |\n",
    "| `regular_600_cell()` | Regular 600-cell, one out of three exceptional regular 4-polytopes. |\n",
    "| `simplex([::Type{T} = QQFieldElem,] d::Int [,n::Rational])` | Simplex which is the convex hull of the standard basis vectors along with the origin in $\\mathbb{R}^d$, scaled by `n`. |\n",
    "| `tetrahedron()` | Regular tetrahedron, one of the Platonic solids. |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c1f184e-a8e5-47e8-95bb-d1b507be7b55",
   "metadata": {},
   "source": [
    "# 2. Polyhedral Fans"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2834aa75",
   "metadata": {},
   "source": [
    "There are multiple ways to motivate polyhedral fans. With a view towards algebraic geometry, one notices that polyhedral fans are the (polyhedral) backbone of toric varieties. Toric varities in turn are an arguably vast class of algebraic varieties, for which it is algorithmically possible to determine a wide range of properties and attributes (e.g. the Chow ring). As such toric varieties are of ample importance to (constructive) algebraic geometry. While polyhedral fans certainly have more applications than just toric geometry, we hope that this is sufficient to emphasize their importance.\n",
    "\n",
    "A polyhedral fan is a collection of polyhedral cones. In staying with the picture of toric varieties, we may think of the polyhedral cones as affine charts, that are glued together in a consistent fashion. Consequently, a collection of polyhedral cones $F$ forms a polyhedral fan if the following two properties are satisfied:\n",
    "1. Each face of each cone in $F$ is, itself, an element of $F$.\n",
    "2. For any two cones $C_1$, $C_2$ in $F$, their intersection $C_1 \\cap C_2$ is also an element of $F$.\n",
    "\n",
    "Polyhedral cones in turn are special instances of polyhedra. We first demonstrate the creation and available functionality for polyhedral cones before we come back to constructing polyhedral fans."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1be0f66-a407-4d44-929c-5cb13aeac1df",
   "metadata": {},
   "source": [
    "## 2.A Polyhedral Cones"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5c8930-0d13-42e9-9350-fd51a606877d",
   "metadata": {},
   "source": [
    "We construct a polyhedral cone by specifying its ray generators and then computing the positive hull of these ray generators. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ccc68380",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedral cone in ambient dimension 2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = [2 -1; 0 1]\n",
    "C = positive_hull(R)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8624b2c-2283-4818-a8ed-d825e03c8ed4",
   "metadata": {},
   "source": [
    "Design choices of *OSCAR* lead to half-integer ray vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9f1e17ac-64b2-4b1d-bf92-e15d3f4b17b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element SubObjectIterator{RayVector{QQFieldElem}}:\n",
       " [1, -1//2]\n",
       " [0, 1]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rays(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a3ec7bb-c8c9-48da-8edc-57681ab959f3",
   "metadata": {},
   "source": [
    "We can force integer values for the rays as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e02d1cfb-f099-40c1-816a-01c144822845",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2   -1]\n",
       "[0    1]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix(ZZ, rays(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a44fafb-aa47-41d4-a0ea-1650549be3a6",
   "metadata": {},
   "source": [
    "Since polyhedral cones are special instances of polyhedra, the polyhedra functionality applies. For instance we can ask for the dimension, ambient dimension and codimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6685f6bf-ee80-422d-bc02-7f9a75756e57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dim(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "f318744f-e7d2-4948-b536-e7c2a54c5e0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ambient_dim(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "615fa9e5-ebb6-4c26-9f5b-a8e930da7e15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codim(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2129607f-f0bc-47fb-88ab-2a16923d83a0",
   "metadata": {},
   "source": [
    "However, there are also new functions. For instance, we can check if a cone is pointed (that is, if there is no lineality space of positive dimension in C):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3eba9638-6d00-4bd0-b2d4-f372ec10ce45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_pointed(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34201226-b49b-40fd-b22f-6fdcebdb4031",
   "metadata": {},
   "source": [
    "We can also compute the polar dual cone:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "112ddbca-b555-4b00-be22-85f670c33767",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedral cone in ambient dimension 2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pdC = polarize(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "99ab5580-632c-47e2-be7b-e71ff315417d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element SubObjectIterator{RayVector{QQFieldElem}}:\n",
       " [1, 0]\n",
       " [1, 2]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rays(pdC)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5607a10-de32-405c-bfb7-4833923bfdb7",
   "metadata": {},
   "source": [
    "We can also compute a Hilbert basis of the lattice points of a cone:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a6aef917-1de4-4a79-850f-3f47649c19b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element SubObjectIterator{PointVector{ZZRingElem}}:\n",
       " [1, 0]\n",
       " [0, 1]\n",
       " [2, -1]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hilbert_basis(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c7e1426-7cd6-452f-84dc-aaff3ef785c7",
   "metadata": {},
   "source": [
    "The informed reader may already have noticed it from the definition, or noticed it from the computation of the Hilbert basis: The cone *C* is not smooth. Even that we can test:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "288aa6b9-8648-440f-8c9a-7e3d92498dba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_smooth(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b2e18b1-8f25-458d-ae5a-44fef3cc2df8",
   "metadata": {},
   "source": [
    "We conclude with a (most definitely incomplete) list of available functionality for cones. The interested reader should consult the documentation (https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/):\n",
    "\n",
    "| Method | Description |\n",
    "| :----------- | :----------- |\n",
    "| `ambient_dim(C::Cone)` | Ambient dimension of  `C`. |\n",
    "| `in(v::AbstractVector, C::Cone)` | Checks whether the vector `v` is contained in the cone `C`. |\n",
    "| `issubset(C0::Cone, C1::Cone)` | Checks whether `C0` is a subset of the cone `C1`. |\n",
    "| `f_vector(C::Cone)` | Vector $(f_1, ..., f_{dim(PF)-1})$, where $f_i$ is the number of faces of `C` of dimension $i$. |\n",
    "| `hilbert_basis(C::Cone{QQFieldElem})` | Hilbert basis of a pointed cone `C` as the rows of a matrix. |\n",
    "| `codim(C::Cone)` | Codimension of `C`. |\n",
    "| `dim(C::Cone)` | Dimension of `C`. |\n",
    "| `polarize(C::Cone)` | Polar dual of `P`. |\n",
    "| `intersect(C0::Cone{T}, C1::Cone{T}) where T<:scalar_types` | Intersection $C0 \\cap C1$ of `C0` and `C1`. |\n",
    "| `is_pointed(C::Cone)` | Determines whether `C` is pointed. |\n",
    "| `is_fulldimensional(C::Cone)` | Determines whether `C` is full-dimensional. |\n",
    "| `lineality_dim(C::Cone)` | Dimension of the largest linear subspace contained in `C`. |\n",
    "| `lineality_space(C::Cone)` | Basis of the lineality space of `C`. |\n",
    "| `n_facets(C::Cone)` | Number of facets of a cone `C`. |\n",
    "| `n_rays(C::Cone)` | Number of rays of `C`. |\n",
    "| `rays(C::Cone)` | Rays of `C`. |\n",
    "| `rays_modulo_lineality(as, C::Cone)` | Rays of the cone of `C` up to lineality as a `NamedTuple` with two iterators.  |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28dbe9e",
   "metadata": {},
   "source": [
    "## 2.B Polyhedral Fans\n",
    "\n",
    "To construct a polyhedral fan, we must provide a list of polyhedral cones. While possible, there is a more efficient way to construct polyhedral fans. First, we do not need the information of all cones, but only the maximal cones. Those are the cones of highest dimension. All other cones in the polyhedral fan are obtained from intersections of these maximal cones. With that being said, we typically collect the rays of all maximal cones into a list and then provide a second argument that states which rays generate maximal cones:\n",
    "- `Rays`: The rays of the fan.\n",
    "- `MC_reps`: IncidenceMatrix whose rows give the indices of the rays which generate maximal cones.\n",
    "\n",
    "For an example, consider the fan $\\Sigma_{\\mathbb{P}^2}$ associated with the projective plane $\\mathbb{P}^2$. This fan has ray generators $e_1$, $e_2$ and $-e_1-e_2$ and the maximal cones are:\n",
    "* $C_1 = \\mathrm{Cone}(e_1, e_2)$,\n",
    "* $C_2 = \\mathrm{Cone}(e_1, - e_1 - e_2)$,\n",
    "* $C_3 = \\mathrm{Cone}(e_2, - e_1 - e_2)$.\n",
    "In *OSCAR*, we construct the polyhedral fan as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "77cbcf4d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Polyhedral fan in ambient dimension 2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = [1 0; 0 1; -1 -1]\n",
    "IM = IncidenceMatrix([[1, 2], [2, 3], [1, 3]])\n",
    "PF = polyhedral_fan(IM, R)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd9d944c-5ed9-4460-b776-62cd39362942",
   "metadata": {},
   "source": [
    "Just as for cones and polyhedra, we can ask about the (ambient) dimension of polyhedral fans:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "e6a30e56-f6b4-4c28-bd0b-f3ca0d9a62a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ambient_dim(PF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e4b7cf1c-8add-4a6c-9040-c8dc68d3e538",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dim(PF)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df305606-a201-4aa6-8a31-bd6d68523a04",
   "metadata": {},
   "source": [
    "The so-called `f_vector` tells us how many cones of dimensions 1, 2, 3, ... do exist in a polyhedral fan. For *PF*, there are three 1-dimensional and three 2-dimensional cones and no higher dimensional cones. So the answer is (3,3):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "957a4bcc-aaa3-4133-bada-2db4f9b5d68a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{ZZRingElem}:\n",
       " 3\n",
       " 3"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f_vector(PF)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "533675b3-c95b-449a-a5aa-820a1128cd8f",
   "metadata": {},
   "source": [
    "A polyhedral fan is pointed, smooth, simplicial, etc. if all of its polyhedral cones are so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "247ddc36-a834-47d2-9a07-fbd2ca6ec2c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_pointed(PF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "bc00a4f5-fde9-448b-946a-4ca0ce3d55c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_smooth(PF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "ae2f7e82-9933-4c4a-b4bd-61055d903655",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_simplicial(PF)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf64b4c6-766a-4a7f-bbf4-5d410eff35b6",
   "metadata": {},
   "source": [
    "There is also the notion of completeness, which means that the union of all cones in the polyhedral fan cover all of the ambient space. For *PF*, this ambient space is $\\mathbb{R}^2$. Indeed, $C_1 \\cup C_2 \\cup C_3 = \\mathbb{R}^2$, and so *PF* is complete. (This is parallel to the projective space $\\mathbb{P}^2$ being complete):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "09adce07-2a23-4f65-82c4-cef84e0812b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_complete(PF)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "116ccb1c-1b61-4759-acef-0ff3259c3860",
   "metadata": {},
   "source": [
    "Many more properties and attributes for polyhedral fans are supported. Here is a (most likely incomplete) list. The interested reader may consult the documentation (https://docs.oscar-system.org/stable/PolyhedralGeometry/intro/):\n",
    "\n",
    "| Methode | Rückgabe |\n",
    "| :----------- | :----------- |\n",
    "| `ambient_dim(PF::PolyhedralFan)` | Ambient dimension of `PF`. |\n",
    "| `dim(PF::PolyhedralFan)` | Dimension of `PF`. |\n",
    "| `f_vector(PF::PolyhedralFan)` | Vector $(f_1, ..., f_{dim(PF)-1})$, where $f_i$ is the number of faces of `PF` of dimension $i$. |\n",
    "| `is_complete(PF::PolyhedralFan)` | Determines whether `PF` is complete. |\n",
    "| `is_pointed(PF::PolyhedralFan)` | Determines whether `PF` is pointed. |\n",
    "| `is_regular(PF::PolyhedralFan)` | Determines whether `PF` is regular. |\n",
    "| `is_simplicial(PF::PolyhedralFan)` | Determines whether `PF` is simpicial. |\n",
    "| `is_smooth(PF::PolyhedralFan{fmpq})` | Determines whether `PF` is smooth. |\n",
    "| `lineality_dim(PF::PolyhedralFan)` | Dimension of the largest linear subspace of `PF`. |\n",
    "| `lineality_space(PF::PolyhedralFan)` | Non-redundant matrix whose rows are generators of the lineality space of  `PF`. |\n",
    "| `maximal_cones(PF::PolyhedralFan)` | Maximal cones of  `PF`. |\n",
    "| `cones(PF::PolyhedralFan, cone_dim::Int)` | Iterator over the cones of `PF` of dimension `cone_dim`. |\n",
    "| `cones(PF::PolyhedralFan)` | Ray indices of all non-zero-dimensional cones in a polyhedral fan `PF`. |\n",
    "| `n_maximal_cones(PF::PolyhedralFan)` | Number of maximal cones of `PF`. |\n",
    "| `n_cones(PF::PolyhedralFan)` | Number of cones of `PF`. |\n",
    "| `n_rays(PF::PolyhedralFan)` | Number of rays of `PF`. |\n",
    "| `rays(PF::PolyhedralFan)` | Rays of `P`. |\n",
    "| `rays_modulo_lineality(as, F::PolyhedralFan)` | Rays of the polyhedral fan `F` up to lineality as a `NamedTuple` with two iterators. |\n",
    "| `primitive_collections(PF::PolyhedralFan)` | Primitive collections of `PF`. |\n",
    "| `starsubdivision(PF::PolyhedralFan, n::Int)` | Star subdivision of a polyhedral fan `PF` at its `n`-th maximal torus orbit. |\n",
    "| `*(PF1::PolyhedralFan, PF2::PolyhedralFan)` | Cartesian/direct product of two polyhedral fans `PF1` and `PF2`. |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eff6eb4e-6a2e-4535-995b-9600b673c513",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.9.2",
   "language": "julia",
   "name": "julia-1.9"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}