polyDB
A Database for Discrete Geometric Objects
- database for discrete geometric objects
- polyhedra, polytopes, cones, lattice polytopes
- matroids
- polyhedral and simplicial complexes,
triangulations, manifolds - tropical geometry, polytropes
- started in 2013
- database extension for polymake
- joint project with Silke Horn
- now a separate project, still linked to polymake
- database backend
- MongoDB
- JSON/BSON data for documents
- web interface at polydb.org
In [10]:
from IPython.display import IFrame
IFrame("https://polydb.org", 1200,1000)
Out[10]:
: Aim
- collect/preserve existing data in discrete geometry
- human/automated access
- standard open tools and data formats
- universal access
- persistence
- integration
- not bound to specific math software tool
- separate data from generation/processing/computation
- separate data from mathematical model
- metadata describes content
- credit for authors
- references to original papers
: Available Collections
Manifolds
2/3-dimensional combinatorial manifolds up to 10 vertices
Matroids
Small matroids
Polytopes
0/1-Polytopes up to combinatorial, geometric, lattice isomorphism
Combinatorial Types of Polytopes
Combinatorial types of faces of Birkhoff Polytopes
Combinatorial 3-spheres up to 9 vertices
Reflexive Polytopes
Smooth Reflexive Polytopes
Exceptional maximal hollow lattice polytopes up to dimension 3
Panoptigons
Non-Spanning 3D Lattice Polytopes
3D Lattice Polytopes with Few Lattice Points
Tropical
Schlaefli Fan
Polytropes
Tropical Oriented Matroids
Quartic Curves
: Access
- basic access:
- languages with MongoDB driver
- official drivers/APIs for
- PHP, Python, C/C++, Java
- community drivers/APIs for
- Julia, Swift, Kotlin
- interfaces
- web
- REST
- polymake
- OSCAR (via Polymake.jl)
: Database Backend
- polyDB is based on MongoDB (mongodb.com)
- NoSQL database
- stores JSON/BSON documents
- source available, not open source
- sharding/replication possible
- hierarchy: two levels
- databases, containing
- collections
- MongoDB query language
- licenses
- MongoDB: Server Side Public License (based on GPLv3)
- Official drivers: Apache License v2.0
- interfaces: GPL 2/3
- (open license for data)
: Database Layout
- single MongoDB database with collections
- allows joins over collections
- simplifies access control
- organization of data
- Sections: organize into topics
- Collections: the actual data sets
- separate collections for meta data
- documentation
- JSON schema: syntantic description of data
- access control
- read access for public collections
- collection maintainers: read/write
- main/only instance at polydb.org
- other/private instances possible
- e.g. local instances
- for prepration
- intermediate omputations
: Data Format
- JSON documents
- special tag _polyDB for
- package specific information
- metadata: authors, date, etc.
- current data follows polymake serialization into JSON format
- interfaces
- read raw JSON data
- conversion done in application
- Data format: JSON schema
- syntactic check
- list of required properties
- fix format of properties
: Data Format
In [11]:
info = requests.get('https://polydb.org/rest/current/collection/Polytopes/Lattice/FewLatticePoints3D/')
print_json(info.json(),3)
: The Math behind this Collection
- Polytope $P$: convex hull of finite set of points (vertices)
- Lattice polytope: vertices in $\mathbb Z^d$
- Lattice points in $P$: $$P\cap\mathbb Z^d$$
- width in direction $a\in \mathbb Z^d$ $$w(P,a):=\max_{x\in P}\langle a,x\rangle\ -\ \min_{x\in P}\langle a,x\rangle$$
- width of $P$: $$\min_{a\in\mathbb Z^d\setminus\{0\}}w(P,a)$$
- Consider only up to linear maps preserving $\mathbb Z^d$
- Some known properties
- infinitely many of width $1$ (even tetraedra: White)
- finite number for width $\ge 2$ (Santos, Blanco; Hensley, Lagarias, Nill, Ziegler)
: Data Format
In [12]:
res = requests.get('https://polydb.org/rest/current/id/Polytopes/Lattice/FewLatticePoints3D/15_09386628')
polytope = res.json()
print_json(polytope,3)
: Schemata
In [13]:
res = requests.get('https://polydb.org/rest/current/schema/Polytopes/Lattice/FewLatticePoints3D')
schema = res.json()
print_json(schema,3)
: Schemata
In [14]:
#schema["required"].append("UNKNOWN_PROPERTY")
#schema["required"].remove("UNKNOWN_PROPERTY")
try:
validate(instance=polytope,schema=schema)
print("data validates")
except ValidationError as e:
print("did not validate")
print(e)
data validates
: REST
- base address: polydb.org/rest/current
- written in php, using PHP Mongo Driver
- endpoints:
- metadata
- section, sections, collection, collections
- schema
- math data
- id
- count, distinct
- find, find_one, aggregate
- modifier: limit, skip </ul>
- url format: </ul> </ul>
polydb.org/rest/current/section/<sectionname>/<subsectionname>/...
polydb.org/rest/current/find/<sectionname>/<collectionname>?query=<query>
polydb.org/rest/query.php
: REST
- get description of collection
In [15]:
p = requests.get('https://polydb.org/rest/current/collection/Polytopes/Lattice/FewLatticePoints3D/')
print_json(p.json(),4)
: REST
- get one document with 14 vertices
In [16]:
res = requests.get('https://polydb.org/rest/current/find_one/Polytopes/Lattice/FewLatticePoints3D?query={%22N_VERTICES%22%3A14}')
polytope = res.json()
print_json(polytope,4)
: REST
- count documents with 4 vertices
- prepare query
In [17]:
query=dict(N_VERTICES=4)
params=dict(
task="count",
collection="Polytopes.Lattice.FewLatticePoints3D",
query=json.dumps(query)
)
res = requests.get(url='https://polydb.org/rest/query.php',params=params)
print(res.json())
6677
: REST
In [18]:
query=[
{ "$match" : {"N_LATTICE_POINTS" : {"$lte" : 11}}},
{ "$group" :
{ "_id" : "$N_LATTICE_POINTS",
"MIN_LATTICE_VOLUME" : { "$min" : "$LATTICE_VOLUME" },
"MAX_LATTICE_VOLUME" : { "$max" : "$LATTICE_VOLUME" }
}
}
]
In [19]:
params=dict(
task='aggregate',
collection='Polytopes.Lattice.FewLatticePoints3D',
query=json.dumps(query),
allowDiskUse=1
)
In [20]:
res = requests.get(url='http://localhost:8880/rest/query.php',params=params)
datax = []
datay = []
for a in res.json():
datax.append([a['_id'],a['_id']])
datay.append([a['MIN_LATTICE_VOLUME'],a['MAX_LATTICE_VOLUME']])
plt.scatter(datax, datay)
plt.show()
: sage
In [21]:
from IPython.display import IFrame
IFrame("https://doc.sagemath.org/html/en/reference/discrete_geometry/sage/geometry/lattice_polytope.html", 1200,1000)
Out[21]:
: sage
In [22]:
import json
import requests
query=dict(DIM=int(3))
params=dict(
task="find",
collection="Polytopes.Lattice.SmoothReflexive",
query=json.dumps(query)
)
res = requests.get(url='https://polydb.org/rest/query.php',params=params)
homog_points=res.json()[3]['VERTICES']
points = [r[1:] for r in homog_points]
p = LatticePolytope(points)
In [23]:
p.vertices()
Out[23]:
M( 0, -2, 1), M( 0, 1, 1), M( 1, 1, 0), M( 1, 0, 0), M( 1, -1, 1), M( 1, 1, 1), M( 0, 0, -1), M( 0, 1, -1), M(-1, 1, -1), M(-1, -1, -1), M(-1, -2, 0), M(-1, 1, 0) in 3-d lattice M
In [24]:
p.plot3d().show()
: polymake
- polyDB can be accessed inside polymake
- wrapped driver for all database functions
- implementation
- written in Perl
- will move to C++
In [25]:
$pdb=polyDB();
In [26]:
$pdb->info(collection=>"Polytopes.Lattice.FewLatticePoints3D");
Out[26]:
=============== available polydb collections =============== SECTION: Polytopes.Lattice This database contains various classes of lattice polytopes. COLLECTION: FewLatticePoints3D The finite list of 3-dimensional lattice polytopes of width at least 2 and up to 15 lattice points. This classification has been developed by Monica Blanco and Francisco Santos, who also computed the initial classification up to eleven lattice points. See the references for all proofs and more background. Author(s): Monica Blanco, University of Cantabria Francisco Santos, University of Cantabria Contributor(s): Andreas Paffenholz, TU Darmstadt Maintainer(s): Andreas Paffenholz, TU Darmstadt Cite: Blanco, Monica and Santos, Francisco, On the enumeration of lattice 3-polytopes, arxiv 1601.02577 obtain at: arxiv: https://arxiv.org/abs/1601.02577 Cite: Blanco, Monica and Santos, Francisco, Lattice 3-polytopes with six lattice points, arxiv 1501.01055 obtain at: arxiv: https://arxiv.org/abs/1501.01055 Cite: Blanco, Monica and Santos, Francisco, Lattice 3-polytopes with five lattice points, arxiv 1409.6701 obtain at: arxiv: https://arxiv.org/abs/1409.6701 Online Resources: %wp% contains the original data computed by M. Blanco and F. Santos and additional information on the polytopes and the code they used for the computation.: https://personales.unican.es/santosf/3polytopes/ Online Resources: The source code for the computation of the data in this collection can be %wp%.: https://github.com/apaffenholz/polymake_few_lattice_points_3d
: polymake
- shell language: Perl/polymake
- wrappers for queries
- conversion into polymake objects
- we can retrieve documents one by one
- find those that define a smooth toric variety
In [27]:
$coll=$pdb->get_collection("Polytopes.Lattice.FewLatticePoints3D");
$cursor=$coll->find({"SMOOTH"=>true});
In [28]:
if ( $cursor->has_next()) {
$p=$cursor->next();
print $p->F_VECTOR;
}
Out[28]:
4 6 4
In [29]:
while ( my $p = $cursor->next() ) {
print $p->F_VECTOR, "\n";
}
Out[29]:
10 15 7 8 12 6
: polymake
- or all at once
- obtain all reflexive polytopes with 15 lattice points, only vertices on boundary
In [30]:
$coll=polyDB()->get_collection("Polytopes.Lattice.FewLatticePoints3D");
@polytopes=$coll->find({"N_LATTICE_POINTS"=>15, "REFLEXIVE"=>true, "TERMINAL"=>true})->all;
print scalar(@polytopes), "\n";
$p=$polytopes[0];
Out[30]:
1
In [31]:
print $p->INTERIOR_LATTICE_POINTS;
Out[31]:
1 1 1 1
In [32]:
$q=translate($p,new Vector([-1,-1,-1]));
print $q->VERTICES;
Out[32]:
1 -1 -1 -1 1 0 -1 -1 1 -1 0 -1 1 0 0 -1 1 -1 -1 0 1 0 -1 0 1 -1 0 0 1 1 0 0 1 0 1 0 1 1 1 0 1 0 0 1 1 1 0 1 1 0 1 1 1 1 1 1
: Oscar
- OSCAR (github.com/oscar-system)
- combines (among others)
- singular,
- GAP,
- antic,
- polymake
- interface part of Polymake.jl
- initially written by Alexej Jordan, Marek Kaluba, Benjamin Lorenz, Sascha Timme, ... at TU Berlin
: Oscar
In [33]:
using Oscar
In [34]:
pdb = Polymake.Polydb.get_db()
coll = pdb["Polytopes.Lattice.FewLatticePoints3D"]
Polymake.Polydb.info(coll, 4)
SECTION: Polytopes A collection of families of polytopes SECTION: Polytopes.Lattice This database contains various classes of lattice polytopes. Maintained by Andreas Paffenholz, paffenholz@opt.tu-darmstadt.de, TU Darmstadt COLLECTION: Polytopes.Lattice.FewLatticePoints3D The finite list of 3-dimensional lattice polytopes of width at least 2 and up to 15 lattice points. This classification has been developed by Monica Blanco and Francisco Santos, who also computed the initial classification up to eleven lattice points. See the references for all proofs and more background. Authored by Monica Blanco, University of Cantabria Francisco Santos, https://personales.unican.es/santosf/, University of Cantabria Maintained by Andreas Paffenholz, https://www2.mathematik.tu-darmstadt.de/~paffenholz, TU Darmstadt
: Oscar
- list available properties
In [35]:
Polymake.Polydb.get_fields(coll)
Out[35]:
30-element Vector{String}:
"VERTICES"
"CONE_AMBIENT_DIM"
"N_VERTICES"
"FEASIBLE"
"AFFINE_HULL"
"CONE_DIM"
"LINEALITY_SPACE"
"COMBINATORIAL_DIM"
"SIMPLE"
"SIMPLICIAL"
"H_STAR_VECTOR"
"N_LATTICE_POINTS"
"N_INTERIOR_LATTICE_POINTS"
⋮
"N_HILBERT_BASIS"
"NORMAL"
"REFLEXIVE"
"GORENSTEIN"
"LATTICE_DEGREE"
"LATTICE_VOLUME"
"FACETS"
"N_FACETS"
"FACET_WIDTHS"
"F_VECTOR"
"SMOOTH"
"VERY_AMPLE"
: Oscar
- obtain iterator over all polytopes that correspond to a smooth toric variety
- check this in OSCAR, using combination of polymake and singular
In [36]:
query = Dict("SMOOTH"=>true)
cur = Polymake.Polydb.find(coll, query)
p = iterate(cur)[1]
p.F_VECTOR
Out[36]:
pm::Vector<pm::Integer> 4 6 4
In [37]:
p = iterate(cur)[1]
p.F_VECTOR
Out[37]:
pm::Vector<pm::Integer> 10 15 7
In [38]:
issmooth(NormalToricVariety(normal_fan(Polyhedron(p))))
Out[38]:
true
- polyDB: polydb.org
- polymake: polymake.org
- Polymake.jl: github.com/oscar-system/Polymake.jl
- Oscar: github.com/oscar-system
- Paffenholz, Andreas
polyDB: a database for polytopes and related objects.
Algorithmic and experimental methods in algebra, geometry, and number theory, pp. 533-547,
Springer, 2017