user_guide:tutorials:latest:json_and_polydb

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

user_guide:tutorials:latest:json_and_polydb [2020/01/29 11:00] (current)
Line 1: Line 1:
 +====== polymake file format and the polyDB ======
 +
 +===== Polymake Data Files =====
 +
 +==== JSON File Format ====
 +
 +With release 4.0 polymake adopts a new file format for its data files. In the new version all data is now serialized to JSON instead of XML.
 +
 +polymake can still read files in XML format.
 +
 +<code perl>
 +> $p = new Polytope(POINTS=>​[[1,​0,​0],​[1,​1,​0],​[1,​0,​1]]);​
 +> print JSON->​new->​pretty->​encode(Core::​Serializer::​serialize($p));​
 +{
 +  "​_ns"​ : {
 +    "​polymake"​ : [
 +      "​https://​polymake.org",​
 +      "​4.0"​
 +    ]
 +  },
 +  "​POINTS"​ : [
 +    [
 +      "​1",​
 +      "​0",​
 +      "​0"​
 +    ],
 +    [
 +      "​1",​
 +      "​1",​
 +      "​0"​
 +    ],
 +    [
 +      "​1",​
 +      "​0",​
 +      "​1"​
 +    ]
 +  ],
 +  "​_id"​ : "​p",​
 +  "​CONE_AMBIENT_DIM"​ : 3,
 +  "​_type"​ : "​polytope::​Polytope<​Rational>"​
 +}
 +</​code>​
 +JSON is a pretty simple format. Entries in a JSON object are either * number: no distinction between float and int * string * boolean: true/false * array: comma separated list of elements in square brackets * object: comma separeted key-value pairs in curly brackets. associative array * null
 +
 +Polymake stores * perl builtin numbers a number * vectors, matrices as array * tuples as object * Integer/​Rartional as string * Bool as boolean * big objects as objects (with properties as keys)
 +
 +Type information that cannot be infered from the rule base (sparse, attachment) is stored in an separate key-value pair.
 +
 +There are only a few meta tags left in a data file: * //id: name *//ns: mark it as a polymake file * //info: credits and description *//type: big object type * //attrs: additional attributes for properties, marks e.g. attachments,​ non-standard types (e.g. sparse) *//ext: extensions * //load: further applications needed to read data file *//polyDB: database information,​ if object is retrieved from db
 +
 +==== Object Arrays ====
 +
 +You can now use standard perl arrays to store a list of objects.
 +
 +<code perl>
 +> $cube = cube(2);
 +> $simplex = simplex(2);
 +> $array = [ $cube, $simplex ];
 +> print JSON->​new->​pretty->​encode(Core::​Serializer::​serialize($array));​
 +{
 +  "​data"​ : [
 +    {
 +      "​_type"​ : "​polytope::​Polytope<​Rational>",​
 +      "​_info"​ : {
 +        "​description"​ : "cube of dimension 2\n"
 +      },
 +      "​FACETS"​ : [
 +        {
 +          "​0"​ : "​1",​
 +          "​1"​ : "​1"​
 +        },
 +        {
 +          "​0"​ : "​1",​
 +          "​1"​ : "​-1"​
 +        },
 +        {
 +          "​0"​ : "​1",​
 +          "​2"​ : "​1"​
 +        },
 +        {
 +          "​0"​ : "​1",​
 +          "​2"​ : "​-1"​
 +        },
 +        {
 +          "​cols"​ : 3
 +        }
 +      ],
 +      "​VERTICES_IN_FACETS"​ : [
 +        [
 +          0,
 +          2
 +        ],
 +        [
 +          1,
 +          3
 +        ],
 +        [
 +          0,
 +          1
 +        ],
 +        [
 +          2,
 +          3
 +        ],
 +        {
 +          "​cols"​ : 4
 +        }
 +      ],
 +      "​_attrs"​ : {
 +        "​FACETS"​ : {
 +          "​_type"​ : "​SparseMatrix<​Rational,​ NonSymmetric>"​
 +        }
 +      },
 +      "​BOUNDED"​ : true,
 +      "​CONE_AMBIENT_DIM"​ : 3,
 +      "​CONE_DIM"​ : 3,
 +      "​AFFINE_HULL"​ : [
 +        {
 +          "​cols"​ : 3
 +        }
 +      ],
 +      "​_id"​ : "​cube"​
 +    },
 +    {
 +      "​_id"​ : "​simplex",​
 +      "​CONE_DIM"​ : 3,
 +      "​N_VERTICES"​ : 3,
 +      "​CONE_AMBIENT_DIM"​ : 3,
 +      "​BOUNDED"​ : true,
 +      "​_attrs"​ : {
 +        "​VERTICES"​ : {
 +          "​_type"​ : "​SparseMatrix<​Rational,​ NonSymmetric>"​
 +        }
 +      },
 +      "​POINTED"​ : true,
 +      "​FEASIBLE"​ : true,
 +      "​_info"​ : {
 +        "​description"​ : "​standard simplex of dimension 2\n"
 +      },
 +      "​CENTERED"​ : false,
 +      "​SIMPLICIALITY"​ : 2,
 +      "​_type"​ : "​polytope::​Polytope<​Rational>",​
 +      "​VERTICES"​ : [
 +        {
 +          "​0"​ : "​1"​
 +        },
 +        {
 +          "​0"​ : "​1",​
 +          "​1"​ : "​1"​
 +        },
 +        {
 +          "​0"​ : "​1",​
 +          "​2"​ : "​1"​
 +        },
 +        {
 +          "​cols"​ : 3
 +        }
 +      ]
 +    }
 +  ],
 +  "​_type"​ : null,
 +  "​_ns"​ : {
 +    "​polymake"​ : [
 +      "​https://​polymake.org",​
 +      "​4.0"​
 +    ]
 +  }
 +}
 +</​code>​
 +==== Background: JSON Schemata ====
 +
 +<code perl>
 +> $p = new Polytope(VERTICES=>​[[1,​0,​0],​[1,​1,​0],​[1,​0,​1]]);​
 +> $p->​N_VERTICES;​
 +> $schema = create_restrictive_schema($p);​
 +> print JSON->​new->​pretty->​encode($schema->​source);​
 +{
 +  "​definitions"​ : {
 +    "​common-Matrix-Rational-NonSymmetric"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​oneOf"​ : [
 +          {
 +            "​$ref"​ : "#/​definitions/​common-Vector-Rational"​
 +          },
 +          {
 +            "​properties"​ : {
 +              "​cols"​ : {
 +                "​type"​ : "​integer",​
 +                "​minimum"​ : 0
 +              }
 +            },
 +            "​required"​ : [
 +              "​cols"​
 +            ],
 +            "​type"​ : "​object",​
 +            "​additionalProperties"​ : false
 +          }
 +        ]
 +      }
 +    },
 +    "​common-Rational"​ : {
 +      "​type"​ : "​string",​
 +      "​pattern"​ : "​^-?​(\\d+(/​\\d+)?​|inf)$"​
 +    },
 +    "​common-Vector-Rational"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Rational"​
 +      }
 +    },
 +    "​common-Int"​ : {
 +      "​type"​ : "​integer"​
 +    }
 +  },
 +  "​additionalProperties"​ : false,
 +  "​required"​ : [
 +    "​_ns",​
 +    "​_type",​
 +    "​VERTICES",​
 +    "​CONE_AMBIENT_DIM",​
 +    "​N_VERTICES"​
 +  ],
 +  "​properties"​ : {
 +    "​_ns"​ : {
 +      "​additionalProperties"​ : false,
 +      "​properties"​ : {
 +        "​polymake"​ : {
 +          "​items"​ : [
 +            {
 +              "​const"​ : "​https://​polymake.org"​
 +            },
 +            {
 +              "​const"​ : "​4.0"​
 +            }
 +          ],
 +          "​additionalItems"​ : false,
 +          "​type"​ : "​array"​
 +        }
 +      },
 +      "​type"​ : "​object"​
 +    },
 +    "​_type"​ : {
 +      "​const"​ : "​polytope::​Polytope<​Rational>"​
 +    },
 +    "​VERTICES"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Matrix-Rational-NonSymmetric"​
 +    },
 +    "​_info"​ : {
 +      "​$ref"​ : "​https://​polymake.org/​schemas/​data.json#/​definitions/​obj_info"​
 +    },
 +    "​CONE_AMBIENT_DIM"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​N_VERTICES"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​_canonical"​ : {
 +      "​type"​ : "​boolean"​
 +    },
 +    "​_load"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​type"​ : "​string"​
 +      }
 +    },
 +    "​_id"​ : {
 +      "​$ref"​ : "​https://​polymake.org/​schemas/​data.json#/​definitions/​obj_id"​
 +    }
 +  },
 +  "​type"​ : "​object",​
 +  "​$schema"​ : "​http://​json-schema.org/​draft-07/​schema#"​
 +}
 +> print $schema->​validate(Core::​Serializer::​serialize($p));​
 +true
 +</​code>​
 +We can use a schema to modify a data file so that it validates against the schema
 +
 +<code perl>
 +> $q = new Polytope(VERTICES=>​[[1,​0,​0],​[1,​1,​0],​[1,​0,​1],​[1,​1,​1]]);​
 +> print JSON->​new->​pretty->​encode(Core::​Serializer::​serialize($q));​
 +{
 +  "​_type"​ : "​polytope::​Polytope<​Rational>",​
 +  "​VERTICES"​ : [
 +    [
 +      "​1",​
 +      "​0",​
 +      "​0"​
 +    ],
 +    [
 +      "​1",​
 +      "​1",​
 +      "​0"​
 +    ],
 +    [
 +      "​1",​
 +      "​0",​
 +      "​1"​
 +    ],
 +    [
 +      "​1",​
 +      "​1",​
 +      "​1"​
 +    ]
 +  ],
 +  "​CONE_AMBIENT_DIM"​ : 3,
 +  "​_ns"​ : {
 +    "​polymake"​ : [
 +      "​https://​polymake.org",​
 +      "​4.0"​
 +    ]
 +  },
 +  "​_id"​ : "​q"​
 +}
 +> print JSON->​new->​pretty->​encode(Core::​Serializer::​serialize($q,​ { schema => $schema } ));
 +{
 +  "​VERTICES"​ : [
 +    [
 +      "​1",​
 +      "​0",​
 +      "​0"​
 +    ],
 +    [
 +      "​1",​
 +      "​1",​
 +      "​0"​
 +    ],
 +    [
 +      "​1",​
 +      "​0",​
 +      "​1"​
 +    ],
 +    [
 +      "​1",​
 +      "​1",​
 +      "​1"​
 +    ]
 +  ],
 +  "​_type"​ : "​polytope::​Polytope<​Rational>",​
 +  "​N_VERTICES"​ : 4,
 +  "​CONE_AMBIENT_DIM"​ : 3,
 +  "​_ns"​ : {
 +    "​polymake"​ : [
 +      "​https://​polymake.org",​
 +      "​4.0"​
 +    ]
 +  },
 +  "​_id"​ : "​q"​
 +}
 +> help "​prescribe_property_types";​
 +core/​objects/​Schema/​methods/​prescribe_property_types:​
 +prescribe_property_types(properties; ​ ... )
 +
 + ​Change the stored data type for properties in a restrictive schema
 +
 + ​Selected properties will be coerced to a different type when the object is stored in a data file
 + or in PolyDB using this schema.
 +
 + Note: This function does not try to verify that the properties can be serialized as the given type
 + or will be successfully deserialized when reading the object from a file or retrieving it from a database.
 + ​It'​s solely in the users responsibility to choose a compatible and convertible data type.
 +
 +Arguments:
 +  Any properties list of pairs PROPERTY_NAME => type
 +    A property in a subobject is written in dotted path notation: "​NAME1.NAME2.NAME3..."​
 +    Types can be specified by name in a string or as a typeof expression or as a type of an exsiting data object.
 +    Specifying undef or "​default"​ will enforce storing the properties in their original form, as declared in the rulebase.
 +    This operation might be useful e.g. to update the schema after a data mode change.
 +
 +Examples:
 +
 +*) Require FACETS to be stored as a sparse matrix
 +   > $schema->​prescribe_property_types(FACETS => typeof SparseMatrix<​Rational>​);​
 +*) Require F_VECTOR and F2_VECTOR to be stored with simple integer entries
 +   > $schema->​prescribe_property_types(F_VECTOR => "​Vector<​Int>",​ F2_VECTOR => "​Matrix<​Int>"​);​
 +*) Require VERTICES to be stored as declared in the rules, that is, as a dense matrix
 +   > $schema->​prescribe_property_types(VERTICES => "​default"​);​
 +</​code>​
 +We can change the type of VERTICES in our schema:
 +
 +<code perl>
 +> $schema->​prescribe_property_types(VERTICES => typeof SparseMatrix<​Rational>​);​
 +> print JSON->​new->​pretty->​encode(Core::​Serializer::​serialize($q,​ { schema => $schema } ));
 +{
 +  "​VERTICES"​ : [
 +    {
 +      "​0"​ : "​1"​
 +    },
 +    {
 +      "​0"​ : "​1",​
 +      "​1"​ : "​1"​
 +    },
 +    {
 +      "​0"​ : "​1",​
 +      "​2"​ : "​1"​
 +    },
 +    [
 +      "​1",​
 +      "​1",​
 +      "​1"​
 +    ],
 +    {
 +      "​cols"​ : 3
 +    }
 +  ],
 +  "​_type"​ : "​polytope::​Polytope<​Rational>",​
 +  "​_attrs"​ : {
 +    "​VERTICES"​ : {
 +      "​_type"​ : "​SparseMatrix<​Rational,​ NonSymmetric>"​
 +    }
 +  },
 +  "​N_VERTICES"​ : 4,
 +  "​CONE_AMBIENT_DIM"​ : 3,
 +  "​_id"​ : "​q",​
 +  "​_ns"​ : {
 +    "​polymake"​ : [
 +      "​https://​polymake.org",​
 +      "​4.0"​
 +    ]
 +  }
 +}
 +</​code>​
 +We can also create a schema for a complete big object type
 +
 +<code perl>
 +> $full_schema=create_permissive_schema(typeof graph::​Graph);​
 +> print JSON->​new->​pretty->​encode($full_schema->​source);​
 +{
 +  "​$schema"​ : "​http://​json-schema.org/​draft-07/​schema#",​
 +  "​definitions"​ : {
 +    "​common-Array-Int"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Int"​
 +      }
 +    },
 +    "​common-SparseVector-Int"​ : {
 +      "​type"​ : [
 +        "​array",​
 +        "​object"​
 +      ],
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Int"​
 +      },
 +      "​additionalProperties"​ : false,
 +      "​patternProperties"​ : {
 +        "​^\\d+$"​ : {
 +          "​$ref"​ : "#/​definitions/​common-Int"​
 +        }
 +      },
 +      "​properties"​ : {
 +        "​_dim"​ : {
 +          "​minimum"​ : 0,
 +          "​type"​ : "​integer"​
 +        }
 +      }
 +    },
 +    "​common-Int"​ : {
 +      "​type"​ : "​integer"​
 +    },
 +    "​common-SparseVector-Float"​ : {
 +      "​patternProperties"​ : {
 +        "​^\\d+$"​ : {
 +          "​$ref"​ : "#/​definitions/​common-Float"​
 +        }
 +      },
 +      "​additionalProperties"​ : false,
 +      "​properties"​ : {
 +        "​_dim"​ : {
 +          "​minimum"​ : 0,
 +          "​type"​ : "​integer"​
 +        }
 +      },
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Float"​
 +      },
 +      "​type"​ : [
 +        "​array",​
 +        "​object"​
 +      ]
 +    },
 +    "​common-Float"​ : {
 +      "​type"​ : [
 +        "​number",​
 +        "​string"​
 +      ],
 +      "​pattern"​ : "​^-?​[Ii]nf$"​
 +    },
 +    "​common-Vector-Float"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Float"​
 +      }
 +    },
 +    "​common-HashMap-Int-Rational"​ : {
 +      "​additionalProperties"​ : false,
 +      "​patternProperties"​ : {
 +        "​^-?​\\d+$"​ : {
 +          "​$ref"​ : "#/​definitions/​common-Rational"​
 +        }
 +      },
 +      "​type"​ : "​object"​
 +    },
 +    "​common-Bool"​ : {
 +      "​type"​ : "​boolean"​
 +    },
 +    "​common-String"​ : {
 +      "​type"​ : "​string"​
 +    },
 +    "​common-Set-Int"​ : {
 +      "​uniqueItems"​ : true,
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Int"​
 +      },
 +      "​type"​ : "​array"​
 +    },
 +    "​common-SparseMatrix-Int-NonSymmetric"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​oneOf"​ : [
 +          {
 +            "​$ref"​ : "#/​definitions/​common-SparseVector-Int"​
 +          },
 +          {
 +            "​additionalProperties"​ : false,
 +            "​properties"​ : {
 +              "​cols"​ : {
 +                "​minimum"​ : 0,
 +                "​type"​ : "​integer"​
 +              }
 +            },
 +            "​type"​ : "​object",​
 +            "​required"​ : [
 +              "​cols"​
 +            ]
 +          }
 +        ]
 +      }
 +    },
 +    "​common-UniPolynomial-Rational-Int"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Serialized-UniPolynomial-Rational-Int"​
 +    },
 +    "​common-IncidenceMatrix-NonSymmetric"​ : {
 +      "​items"​ : {
 +        "​oneOf"​ : [
 +          {
 +            "​$ref"​ : "#/​definitions/​common-Set-Int"​
 +          },
 +          {
 +            "​required"​ : [
 +              "​cols"​
 +            ],
 +            "​additionalProperties"​ : false,
 +            "​properties"​ : {
 +              "​cols"​ : {
 +                "​type"​ : "​integer",​
 +                "​minimum"​ : 0
 +              }
 +            },
 +            "​type"​ : "​object"​
 +          }
 +        ]
 +      },
 +      "​type"​ : "​array"​
 +    },
 +    "​common-PowerSet-Int"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Set-Int"​
 +      }
 +    },
 +    "​common-Serialized-UniPolynomial-Rational-Int"​ : {
 +      "​minItems"​ : 1,
 +      "​items"​ : [
 +        {
 +          "​$ref"​ : "#/​definitions/​common-HashMap-Int-Rational"​
 +        }
 +      ],
 +      "​type"​ : "​array",​
 +      "​additionalItems"​ : false
 +    },
 +    "​common-Rational"​ : {
 +      "​pattern"​ : "​^-?​(\\d+(/​\\d+)?​|inf)$",​
 +      "​type"​ : "​string"​
 +    },
 +    "​common-Array-String"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-String"​
 +      }
 +    },
 +    "​common-Graph-Undirected"​ : {
 +      "​properties"​ : {
 +        "​_dim"​ : {
 +          "​type"​ : "​integer",​
 +          "​minimum"​ : 0
 +        }
 +      },
 +      "​patternProperties"​ : {
 +        "​^\\d+$"​ : {
 +          "​$ref"​ : "#/​definitions/​common-Set-Int"​
 +        }
 +      },
 +      "​additionalProperties"​ : false,
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Set-Int"​
 +      },
 +      "​type"​ : [
 +        "​array",​
 +        "​object"​
 +      ]
 +    },
 +    "​common-Map-Int-Int"​ : {
 +      "​patternProperties"​ : {
 +        "​^-?​\\d+$"​ : {
 +          "​$ref"​ : "#/​definitions/​common-Int"​
 +        }
 +      },
 +      "​additionalProperties"​ : false,
 +      "​type"​ : "​object"​
 +    },
 +    "​graph-Graph-Undirected"​ : {
 +      "​allOf"​ : [
 +        {
 +          "​$ref"​ : "​https://​polymake.org/​schemas/​data.json#/​definitions/​big_obj"​
 +        },
 +        {
 +          "​properties"​ : {
 +            "​MAX_CLIQUES"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-PowerSet-Int"​
 +                }
 +              ]
 +            },
 +            "​N_CONNECTED_COMPONENTS"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Int"​
 +                }
 +              ]
 +            },
 +            "​BIPARTITE"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Bool"​
 +                }
 +              ]
 +            },
 +            "​CHARACTERISTIC_POLYNOMIAL"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-UniPolynomial-Rational-Int"​
 +                }
 +              ]
 +            },
 +            "​NODE_LABELS"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Array-String"​
 +                }
 +              ]
 +            },
 +            "​CONNECTIVITY"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Int"​
 +                }
 +              ]
 +            },
 +            "​NODE_DEGREES"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Array-Int"​
 +                }
 +              ]
 +            },
 +            "​CONNECTED_COMPONENTS"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-IncidenceMatrix-NonSymmetric"​
 +                }
 +              ]
 +            },
 +            "​NodePerm.pure"​ : false,
 +            "​SIGNATURE"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Int"​
 +                }
 +              ]
 +            },
 +            "​DIAMETER"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Int"​
 +                }
 +              ]
 +            },
 +            "​TRIANGLE_FREE"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Bool"​
 +                }
 +              ]
 +            },
 +            "​SIGNED_INCIDENCE_MATRIX"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-SparseMatrix-Int-NonSymmetric"​
 +                }
 +              ]
 +            },
 +            "​DEGREE_SEQUENCE"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Map-Int-Int"​
 +                }
 +              ]
 +            },
 +            "​NodePerm"​ : false,
 +            "​CONNECTED"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Bool"​
 +                }
 +              ]
 +            },
 +            "​N_NODES"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Int"​
 +                }
 +              ]
 +            },
 +            "​BICONNECTED_COMPONENTS"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-IncidenceMatrix-NonSymmetric"​
 +                }
 +              ]
 +            },
 +            "​AVERAGE_DEGREE"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Rational"​
 +                }
 +              ]
 +            },
 +            "​N_EDGES"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Int"​
 +                }
 +              ]
 +            },
 +            "​ADJACENCY"​ : {
 +              "​anyOf"​ : [
 +                {
 +                  "​type"​ : "​null"​
 +                },
 +                {
 +                  "​$ref"​ : "#/​definitions/​common-Graph-Undirected"​
 +                }
 +              ]
 +            }
 +          }
 +        },
 +        {
 +          "​anyOf"​ : [
 +            {
 +              "​properties"​ : {
 +                "​_attrs"​ : {
 +                  "​properties"​ : {
 +                    "​EIGENVALUES_LAPLACIAN"​ : {
 +                      "​properties"​ : {
 +                        "​_type"​ : false
 +                      }
 +                    }
 +                  }
 +                },
 +                "​EIGENVALUES_LAPLACIAN"​ : {
 +                  "​anyOf"​ : [
 +                    {
 +                      "​type"​ : "​null"​
 +                    },
 +                    {
 +                      "​$ref"​ : "#/​definitions/​common-Vector-Float"​
 +                    }
 +                  ]
 +                }
 +              }
 +            },
 +            {
 +              "​properties"​ : {
 +                "​_attrs"​ : {
 +                  "​properties"​ : {
 +                    "​EIGENVALUES_LAPLACIAN"​ : {
 +                      "​properties"​ : {
 +                        "​_type"​ : {
 +                          "​const"​ : "​SparseVector<​Float>"​
 +                        }
 +                      }
 +                    }
 +                  }
 +                },
 +                "​EIGENVALUES_LAPLACIAN"​ : {
 +                  "​$ref"​ : "#/​definitions/​common-SparseVector-Float"​
 +                }
 +              }
 +            }
 +          ]
 +        }
 +      ]
 +    }
 +  },
 +  "​title"​ : "​polymake data objects of type graph::​Graph<​Undirected>",​
 +  "​allOf"​ : [
 +    {
 +      "​properties"​ : {
 +        "​_type"​ : {
 +          "​const"​ : "​graph::​Graph<​Undirected>"​
 +        }
 +      }
 +    },
 +    {
 +      "​$ref"​ : "​https://​polymake.org/​schemas/​data.json#/​definitions/​top_level"​
 +    },
 +    {
 +      "​$ref"​ : "#/​definitions/​graph-Graph-Undirected"​
 +    }
 +  ]
 +}
 +> $m=graph::​petersen();​
 +> print $full_schema->​validate(Core::​Serializer::​serialize($m));​
 +true
 +</​code>​
 +===== PolyDB =====
 +
 +==== General Information ====
 +
 +Database for mathematical objects. Intended for data related to the projects within OSCAR.
 +
 +Database is independent of particular software package, but information necessary for in-/output to a software can be stored alongside.
 +
 +Currently accessible via web (still at an experimental stage) and via polymake.
 +
 +https:​%%//​%%polydb.org
 +
 +A database connection is established by calling the function ''​polyDB'':​
 +
 +<code perl>
 +> $pdb_default=polyDB();​
 +</​code>​
 +==== Get info ====
 +
 +<code perl>
 +> $pdb_default->​info();​
 +===============
 +available polydb collections
 +===============
 +
 +SECTION: Manifolds
 +This database contains combinatorial manifolds
 +
 +COLLECTION: DIM2_3
 +This is a collection of  combinatorial 2-  and  3-manifolds with up to 10 vertices given as triangulations and calculcated by Frank Lutz found at: http://​page.math.tu-berlin.de/​~lutz/​stellar/​mixed.html.
 +
 +SECTION: Matroids
 +This database contains various classes of matroids.
 +
 +COLLECTION: Small
 +Collection of small matroids based on the census by Yoshitake Matsumoto, Sonoko Moriyama, Hiroshi Imai, David Bremner.
 +
 +SECTION: Polytopes
 +A collection of families of polytopes
 +
 +SECTION: Polytopes.Combinatorial
 +This database contains various classes of combinatorial polytopes.
 +
 +COLLECTION: 01Polytopes
 +0/​1-Polytopes up to combinatorial equivalence
 +
 +COLLECTION: CombinatorialTypes
 +Combinatorial types of polytopes of small dimension and number of vertices
 +
 +COLLECTION: FacesBirkhoffPolytope
 +Combinatorial types of faces up to dimension ​ 8 of a Birkhoff polytope in any dimension
 +
 +COLLECTION: SmallSpheresDim4
 +Combinatorial 3-spheres with up to 9 vertices
 +
 +SECTION: Polytopes.Geometric
 +This database contains various classes of geometric polytopes.
 +
 +COLLECTION: 01Polytopes
 +0/​1-Polytopes up to rotation and reflection
 +
 +SECTION: Polytopes.Lattice
 +This database contains various classes of lattice polytopes.
 +
 +COLLECTION: 01Polytopes
 +0/​1-Polytopes up to lattice equivalence
 +
 +COLLECTION: ExceptionalMaximalHollow
 +Exceptional maximal hollow lattice polytopes up to dimension 3
 +
 +COLLECTION: Reflexive
 +Reflexive Polytopes in dimension 4
 +
 +COLLECTION: SmoothReflexive
 +Smooth reflexive polytopes in dimensions 1 to 9 with splitting data
 +
 +SECTION: Tropical
 +This database contains tropical objects.
 +
 +COLLECTION: Cubics
 +Regular unimodular triangulations of the triple tetrahedron and their motifs.
 +
 +COLLECTION: Polytropes
 +Representatives for all combinatorial tropical types of full-dimensional polytropes in TP3.
 +
 +COLLECTION: TOM
 +All known non-realisable tropical oriented matroids with parameters n=6, d=3 or n=d=4.
 +</​code>​
 +For individual collections we can get more detailed information:​ * level 1: short description (default if no collection is given), * level 2: description,​ * level 3: description,​ authors, maintainers,​ * level 4: full info * level 5: full info and list of recommended search fields, if defined in info (default if collection is given)
 +
 +<code perl>
 +> $pdb_default->​info(section=>"​Polytopes.Combinatorial",​ collection=>"​CombinatorialTypes",​ info_level=>​4);​
 +===============
 +available polydb collections
 +===============
 +
 +SECTION: Polytopes.Combinatorial
 +This database contains various classes of combinatorial polytopes.
 +
 +COLLECTION: CombinatorialTypes
 +Combinatorial types of polytopes of small dimension and number of vertices, see [[http://​www-imai.is.s.u-tokyo.ac.jp/​~hmiyata/​oriented_matroids/​index.html]]
 +Author(s): ​
 +  Hiroyuki Miyata, University of Tokyo, Bunkyo-ku, Tokyo, Japan, hmiyata@is.s.u-tokyo.ac.jp
 +  Sonoko Moriyama, Tokuyama laboratory, System Information Sciences, Graduate School of Information Sciences, Tohoku University, moriso@dais.is.tohoku.ac.jp ​
 +  Komei Fukuda, Theory of Combinatorial Algorithms, Department of Mathematics,​ ETHZ, fukuda@math.ethz.ch
 +Contributor(s): ​
 +  Constantin Fischer, TU Berlin, cfischer@mailbox.tu-berlin.de
 +Maintainer(s): ​
 +  Constantin Fischer, TU Berlin, cfischer@mailbox.tu-berlin.de
 +Online Resources:
 +Classification of Oriented Matroids: http://​www-imai.is.s.u-tokyo.ac.jp/​~hmiyata/​oriented_matroids/​index.html
 +Searchable fields in this collection: ​
 +_ns
 +_type
 +_polyDB
 +FLAG_VECTOR
 +COMBINATORIAL_DIM
 +N_FACETS
 +G_VECTOR
 +H_VECTOR
 +F2_VECTOR
 +TWO_FACE_SIZES
 +SIMPLICIAL
 +FACET_SIZES
 +F_VECTOR
 +N_VERTICES
 +SIMPLE
 +VERTICES_IN_FACETS
 +</​code>​
 +==== Reading Data from polymake ====
 +
 +=== Simple reading ===
 +
 +<code perl>
 +> $coll_default=$pdb_default->​get_collection("​Polytopes.Lattice.SmoothReflexive"​);​
 +> $a=$coll_default->​find({"​DIM"​=>​3});​
 +</​code>​
 +This returns a cursor over the data.
 +
 +<code perl>
 +> print $a->​has_next;​
 +true
 +> $p=$a->​next;​
 +> print $p->​F_VECTOR;​
 +8 12 6
 +> while ( $p = $a->next ) {
 +>   print $p->​F_VECTOR,​ "​\n";​
 +> }
 +6 9 5
 +10 15 7
 +12 18 8
 +10 15 7
 +8 12 6
 +8 12 6
 +10 15 7
 +10 15 7
 +12 18 8
 +8 12 6
 +8 12 6
 +8 12 6
 +6 9 5
 +6 9 5
 +8 12 6
 +6 9 5
 +4 6 4
 +</​code>​
 +=== Objects from the database know where they come from ===
 +
 +<code perl>
 +> $a=$coll_default->​find({"​DIM"​=>​3});​
 +> $p=$a->​next;​
 +> $info=$p->​get_attachment("​_polyDB"​);​
 +> foreach (keys %$info) { print $_, ": ", $info->​{$_},​ "​\n";​ };
 +app: polytope
 +section: Polytopes.Lattice
 +version: 2.1
 +uri: http://​polymake.org/​polytopes/​paffenholz/​www/​fano.html
 +id: F.3D.0000
 +database: LatticePolytopes
 +tag: object
 +collection: SmoothReflexive
 +creation_date:​ 2019-08-01
 +type: polytope::​Polytope<​Rational>​
 +</​code>​
 +==== Queries ====
 +
 +<code perl>
 +> $cur=$coll_default->​find({"​DIM"​=>​3,​ "​N_VERTICES"​ => 8});
 +</​code>​
 +A query usually returns a cursor over all matching results.
 +
 +<code perl>
 +> while ( $p = $cur->​next ) {
 +>   print "​(",​ $p->DIM, ", ", $p->​N_VERTICES,​ ") ";
 +> }
 +(3, 8) (3, 8) (3, 8) (3, 8) (3, 8) (3, 8) (3, 8) 
 +</​code>​
 +The cursor keeps its position, so to return to the first result we need to reset the cursor.
 +
 +<code perl>
 +> $cur->​reset;​
 +> while ( $p = $cur->​next ) {
 +>   print "​(",​ $p->DIM, ", ", $p->​N_VERTICES,​ ") ";
 +> }
 +(3, 8) (3, 8) (3, 8) (3, 8) (3, 8) (3, 8) (3, 8) 
 +</​code>​
 +We can collect all results into an array.
 +
 +<code perl>
 +> @a=$coll_default->​find({"​DIM"​=>​3,​ "​N_VERTICES"​ => 8})->​all;​
 +> print scalar(@a);
 +7
 +</​code>​
 +We can ask for ranges:
 +
 +<code perl>
 +> @a=$coll_default->​find({"​DIM"​ => { '​$lt'​ => 4}})->​all;​
 +> print scalar(@a);
 +25
 +> foreach (@a) {
 +>   print $_->​F_VECTOR,​ "​\n";​
 +> }
 +
 +2
 +3 3
 +4 4
 +4 4
 +5 5
 +6 6
 +8 12 6
 +6 9 5
 +10 15 7
 +12 18 8
 +10 15 7
 +8 12 6
 +8 12 6
 +10 15 7
 +10 15 7
 +12 18 8
 +8 12 6
 +8 12 6
 +8 12 6
 +6 9 5
 +6 9 5
 +8 12 6
 +6 9 5
 +4 6 4
 +</​code>​
 +Boolean operations are possible:
 +
 +<code perl>
 +> @a=$coll_default->​find({'​$or'​ => [{ '​DIM'​ => 2}, { '​DIM'​ => 4}]})->​all;​
 +> foreach (@a) {
 +>   print $_->​F_VECTOR,​ "​\n";​
 +> }
 +3 3
 +4 4
 +4 4
 +5 5
 +6 6
 +11 22 18 7
 +8 16 14 6
 +17 34 25 8
 +13 26 20 7
 +15 30 23 8
 +18 36 27 9
 +15 30 23 8
 +16 32 24 8
 +12 24 19 7
 +12 24 19 7
 +15 30 23 8
 +16 32 24 8
 +16 32 24 8
 +12 24 19 7
 +16 32 24 8
 +16 32 24 8
 +16 32 24 8
 +13 26 20 7
 +12 24 19 7
 +12 24 19 7
 +9 18 15 6
 +21 42 30 9
 +17 34 25 8
 +17 34 25 8
 +23 46 32 9
 +30 60 40 10
 +13 26 20 7
 +17 34 25 8
 +15 30 23 8
 +18 36 27 9
 +16 32 24 8
 +15 30 23 8
 +12 24 19 7
 +17 34 25 8
 +21 42 30 9
 +21 42 30 9
 +18 36 26 8
 +24 48 33 9
 +18 36 26 8
 +17 34 25 8
 +16 32 24 8
 +13 26 20 7
 +13 26 20 7
 +12 24 19 7
 +15 30 23 8
 +12 24 19 7
 +9 18 15 6
 +20 40 29 9
 +24 48 34 10
 +20 40 29 9
 +16 32 24 8
 +16 32 24 8
 +20 40 29 9
 +20 40 29 9
 +24 48 34 10
 +20 40 29 9
 +24 48 34 10
 +20 40 29 9
 +20 40 29 9
 +16 32 24 8
 +20 40 29 9
 +24 48 34 10
 +20 40 29 9
 +21 42 30 9
 +20 40 29 9
 +24 48 34 10
 +24 48 34 10
 +20 40 29 9
 +20 40 29 9
 +16 32 24 8
 +16 32 24 8
 +16 32 24 8
 +16 32 24 8
 +12 24 19 7
 +25 50 35 10
 +30 60 41 11
 +36 72 48 12
 +20 40 29 9
 +24 48 34 10
 +20 40 29 9
 +16 32 24 8
 +16 32 24 8
 +16 32 24 8
 +20 40 29 9
 +16 32 24 8
 +12 24 19 7
 +17 34 25 8
 +16 32 24 8
 +16 32 24 8
 +16 32 24 8
 +16 32 24 8
 +20 40 29 9
 +16 32 24 8
 +12 24 19 7
 +15 30 23 8
 +18 36 27 9
 +15 30 23 8
 +20 40 29 9
 +24 48 34 10
 +18 36 27 9
 +15 30 23 8
 +15 30 23 8
 +16 32 24 8
 +11 22 18 7
 +11 22 18 7
 +12 24 19 7
 +12 24 19 7
 +12 24 19 7
 +13 26 20 7
 +16 32 24 8
 +16 32 24 8
 +12 24 19 7
 +12 24 19 7
 +12 24 19 7
 +8 16 14 6
 +8 16 14 6
 +12 24 19 7
 +9 18 15 6
 +16 32 24 8
 +12 24 19 7
 +8 16 14 6
 +8 16 14 6
 +9 18 15 6
 +5 10 10 5
 +> @a=$coll_default->​find({'​$and'​ => [{ '​DIM'​ => 2}, { '​N_VERTICES'​ => 4}]})->​all;​
 +> foreach (@a) {
 +>   print $_->​F_VECTOR,​ "​\n";​
 +> }
 +4 4
 +4 4
 +</​code>​
 +Type matters
 +
 +<code perl>
 +> @a=$coll_default->​find({'​LATTICE_VOLUME'​ => "​8"​})->​all;​
 +> print scalar(@a);
 +2
 +> @a=$coll_default->​find({'​LATTICE_VOLUME'​ => 8})->​all;​
 +> print scalar(@a);
 +0
 +</​code>​
 +==== Creating and filling new collections ====
 +
 +Some preparations for a test database
 +
 +<code perl>
 +> $PolyDB::​default::​db_host="​db-test-server";​
 +> $PolyDB::​default::​useSSL = 0;
 +> $pdb_local_admin = polyDB(user=>"​admin",​ password=>"​admin"​);​
 +> $pdb_local_admin->​create_default_user_and_role();​
 +</​code>​
 +We initiate a new collection. MongoDB is lazy, so what this function actually does is just creating access permisssions. The collection is only created when the first document is inserted.
 +
 +<code perl>
 +> $pdb_local_admin->​initiate_collection(collection=>"​Polytopes.01Polytopes"​);​
 +</​code>​
 +We insert an info document for the section. This can only be done by database admins. A documentation entry is necessary, otherwise the section is not listed by the ''​info()''​-function.
 +
 +<code perl>
 +> $section_doc=load_json("​files/​json_and_polydb/​polydb_meta/​Polytopes/​Polytopes.2.1.json"​);​
 +> print JSON->​new->​pretty->​encode($section_doc);​
 +{
 +  "​description"​ : "A collection of families of polytopes",​
 +  "​sectionDepth"​ : 1,
 +  "​section"​ : [
 +    "​Polytopes"​
 +  ],
 +  "​maintainer"​ : {
 +    "​email"​ : "​paffenholz@opt.tu-darmstadt.de",​
 +    "​affiliation"​ : "TU Darmstadt",​
 +    "​name"​ : "​Andreas Paffenholz"​
 +  },
 +  "​short_description"​ : "A collection of families of polytopes",​
 +  "​polydb_version"​ : "​2.1"​
 +}
 +> $pdb_local_admin->​set_section_doc($section_doc,​ section=>"​Polytopes"​);​
 +</​code>​
 +From now on we can hand over the administration of the collection to a user that has admin permissions just on this collection, not the whole database. We create a new one, we could also extend an existing user.
 +
 +<code perl>
 +> $pdb_local_admin->​create_user(user=>"​workshop",​ password=>"​workshop",​ admin_collections=>​["​Polytopes.01Polytopes"​]);​
 +> print $pdb_local_admin->​user_exists("​workshop"​);​
 +true
 +</​code>​
 +Now we can connect as the newly created user with admin rights on the new collection.
 +
 +<code perl>
 +> $pdb_local = polyDB(user=>"​workshop",​ password=>"​workshop"​);​
 +> $coll_local = $pdb_local->​get_collection("​Polytopes.01Polytopes"​);​
 +</​code>​
 +We first set the documentation for the collection. Again, without a documentation entry the collection is not listed by the ''​info()''​ command.
 +
 +<code perl>
 +> $collection_doc=load_json("​files/​json_and_polydb/​polydb_meta/​Polytopes/​01Polytopes/​Polytopes.01Polytopes.2.1.json"​);​
 +> print JSON->​new->​pretty->​encode($collection_doc);​
 +{
 +  "​contributor"​ : [
 +    {
 +      "​affiliation"​ : "TU Darmstadt",​
 +      "​email"​ : "​paffenholz@opt.tu-darmstadt.de",​
 +      "​name"​ : "​Andreas Paffenholz"​
 +    }
 +  ],
 +  "​description"​ : "​0/​1-Polytopes up to rotation and reflection",​
 +  "​collection"​ : "​01Polytopes",​
 +  "​polydb_version"​ : "​2.1",​
 +  "​_id"​ : "​Polytopes.01Polytopes.2.1",​
 +  "​maintainer"​ : [
 +    {
 +      "​name"​ : "​Andreas Paffenholz",​
 +      "​email"​ : "​paffenholz@opt.tu-darmstadt.de",​
 +      "​affiliation"​ : "TU Darmstadt"​
 +    }
 +  ],
 +  "​section"​ : [
 +    "​Polytopes"​
 +  ],
 +  "​author"​ : [
 +    {
 +      "​name"​ : "Oswin Aichholzer"​
 +    }
 +  ],
 +  "​short_description"​ : "​0/​1-Polytopes up to rotation and reflection"​
 +}
 +> $coll_local->​set_collection_doc($collection_doc);​
 +</​code>​
 +We need to insert two further documents before we can insert data: * a schema * an info document with some meta information on the collection. The second needs the id of the schema, so the schema must be inserted first.
 +
 +We create a schema from a polymake object.
 +
 +<code perl>
 +> $a = load_data("​files/​json_and_polydb/​data/​geometric_01.pdata"​);​
 +> print join " ", $a->​[0]->​list_properties;​
 +CONE_AMBIENT_DIM VERTICES
 +> $p=$a->​[0];​
 +> $p->​provide("​VERTICES","​FACETS","​F_VECTOR","​SIMPLE","​SIMPLICIAL"​);​
 +> print join " ", $p->​list_properties;​
 +CONE_AMBIENT_DIM VERTICES FEASIBLE N_VERTICES POINTED BOUNDED FAR_FACE AFFINE_HULL CONE_DIM LINEALITY_DIM LINEALITY_SPACE COMBINATORIAL_DIM SIMPLICITY SIMPLICIALITY SIMPLE SIMPLICIAL FACETS N_FACETS F_VECTOR
 +> $schema=create_restrictive_schema($p);​
 +> print JSON->​new->​pretty->​encode($schema->​source);​
 +{
 +  "​definitions"​ : {
 +    "​common-Set-Int"​ : {
 +      "​type"​ : "​array",​
 +      "​uniqueItems"​ : true,
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Int"​
 +      }
 +    },
 +    "​common-Int"​ : {
 +      "​type"​ : "​integer"​
 +    },
 +    "​common-Vector-Rational"​ : {
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Rational"​
 +      },
 +      "​type"​ : "​array"​
 +    },
 +    "​common-Integer"​ : {
 +      "​type"​ : "​string",​
 +      "​pattern"​ : "​^-?​(\\d+|inf)$"​
 +    },
 +    "​common-Bool"​ : {
 +      "​type"​ : "​boolean"​
 +    },
 +    "​common-Vector-Integer"​ : {
 +      "​items"​ : {
 +        "​$ref"​ : "#/​definitions/​common-Integer"​
 +      },
 +      "​type"​ : "​array"​
 +    },
 +    "​common-Rational"​ : {
 +      "​pattern"​ : "​^-?​(\\d+(/​\\d+)?​|inf)$",​
 +      "​type"​ : "​string"​
 +    },
 +    "​common-Matrix-Rational-NonSymmetric"​ : {
 +      "​items"​ : {
 +        "​oneOf"​ : [
 +          {
 +            "​$ref"​ : "#/​definitions/​common-Vector-Rational"​
 +          },
 +          {
 +            "​additionalProperties"​ : false,
 +            "​required"​ : [
 +              "​cols"​
 +            ],
 +            "​properties"​ : {
 +              "​cols"​ : {
 +                "​type"​ : "​integer",​
 +                "​minimum"​ : 0
 +              }
 +            },
 +            "​type"​ : "​object"​
 +          }
 +        ]
 +      },
 +      "​type"​ : "​array"​
 +    }
 +  },
 +  "​additionalProperties"​ : false,
 +  "​properties"​ : {
 +    "​AFFINE_HULL"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Matrix-Rational-NonSymmetric"​
 +    },
 +    "​N_FACETS"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​_load"​ : {
 +      "​type"​ : "​array",​
 +      "​items"​ : {
 +        "​type"​ : "​string"​
 +      }
 +    },
 +    "​N_VERTICES"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​LINEALITY_SPACE"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Matrix-Rational-NonSymmetric"​
 +    },
 +    "​F_VECTOR"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Vector-Integer"​
 +    },
 +    "​POINTED"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Bool"​
 +    },
 +    "​SIMPLICIAL"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Bool"​
 +    },
 +    "​COMBINATORIAL_DIM"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​SIMPLICITY"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​VERTICES"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Matrix-Rational-NonSymmetric"​
 +    },
 +    "​SIMPLICIALITY"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​_type"​ : {
 +      "​const"​ : "​polytope::​Polytope<​Rational>"​
 +    },
 +    "​_id"​ : {
 +      "​$ref"​ : "​https://​polymake.org/​schemas/​data.json#/​definitions/​obj_id"​
 +    },
 +    "​CONE_AMBIENT_DIM"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​LINEALITY_DIM"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​BOUNDED"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Bool"​
 +    },
 +    "​_ns"​ : {
 +      "​properties"​ : {
 +        "​polymake"​ : {
 +          "​additionalItems"​ : false,
 +          "​items"​ : [
 +            {
 +              "​const"​ : "​https://​polymake.org"​
 +            },
 +            {
 +              "​const"​ : "​4.0"​
 +            }
 +          ],
 +          "​type"​ : "​array"​
 +        }
 +      },
 +      "​type"​ : "​object",​
 +      "​additionalProperties"​ : false
 +    },
 +    "​FACETS"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Matrix-Rational-NonSymmetric"​
 +    },
 +    "​_canonical"​ : {
 +      "​type"​ : "​boolean"​
 +    },
 +    "​CONE_DIM"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Int"​
 +    },
 +    "​SIMPLE"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Bool"​
 +    },
 +    "​FAR_FACE"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Set-Int"​
 +    },
 +    "​FEASIBLE"​ : {
 +      "​$ref"​ : "#/​definitions/​common-Bool"​
 +    },
 +    "​_info"​ : {
 +      "​$ref"​ : "​https://​polymake.org/​schemas/​data.json#/​definitions/​obj_info"​
 +    }
 +  },
 +  "​required"​ : [
 +    "​_ns",​
 +    "​_type",​
 +    "​CONE_AMBIENT_DIM",​
 +    "​VERTICES",​
 +    "​FEASIBLE",​
 +    "​N_VERTICES",​
 +    "​POINTED",​
 +    "​BOUNDED",​
 +    "​FAR_FACE",​
 +    "​AFFINE_HULL",​
 +    "​CONE_DIM",​
 +    "​LINEALITY_DIM",​
 +    "​LINEALITY_SPACE",​
 +    "​COMBINATORIAL_DIM",​
 +    "​SIMPLICITY",​
 +    "​SIMPLICIALITY",​
 +    "​SIMPLE",​
 +    "​SIMPLICIAL",​
 +    "​FACETS",​
 +    "​N_FACETS",​
 +    "​F_VECTOR"​
 +  ],
 +  "​type"​ : "​object",​
 +  "​$schema"​ : "​http://​json-schema.org/​draft-07/​schema#"​
 +}
 +> $coll_local->​set_schema($schema->​source);​
 +</​code>​
 +Now we can insert the info document.
 +
 +<code perl>
 +> $info_doc=load_json("​files/​json_and_polydb/​polydb_meta/​Polytopes/​01Polytopes/​info.2.1.json"​);​
 +> print JSON->​new->​pretty->​encode($info_doc);​
 +{
 +  "​_id"​ : "​info.2.1",​
 +  "​polydb_version"​ : "​2.1",​
 +  "​packages"​ : {
 +    "​polymake"​ : {
 +      "​type"​ : "​polytope::​Polytope<​Rational>",​
 +      "​version"​ : "​3.4"​
 +    }
 +  },
 +  "​description"​ : "0/1 Polytopes",​
 +  "​collection"​ : "​01Polytopes",​
 +  "​contributor"​ : "​Andreas Paffenholz",​
 +  "​creator"​ : "Oswin Aichholzer",​
 +  "​uri"​ : "​https://​polymake.org",​
 +  "​section"​ : [
 +    "​Polytopes"​
 +  ],
 +  "​maintainer"​ : "​Andreas Paffenholz"​
 +}
 +> $coll_local->​set_info($info_doc,​ schema_id=>"​schema.2.1"​);​
 +</​code>​
 +Now the new collection is fully prepared and is listed with ''​info()'':​
 +
 +<code perl>
 +> $pdb_local->​info();​
 +===============
 +available polydb collections
 +===============
 +
 +SECTION: Polytopes
 +A collection of families of polytopes
 +
 +COLLECTION: 01Polytopes
 +0/​1-Polytopes up to rotation and reflection
 +</​code>​
 +We can now insert our data.
 +
 +<code perl>
 +> $coll_local->​insert(@$a);​
 +> print $coll_local->​count({});​
 +14
 +> @b=$coll_local->​find({})->​all;​
 +> print scalar(@b);
 +14
 +> $p=$coll_local->​find_one({});​
 +> print join " ", $p->​list_properties;​
 +FACETS LINEALITY_DIM BOUNDED AFFINE_HULL CONE_AMBIENT_DIM N_FACETS COMBINATORIAL_DIM SIMPLICITY VERTICES SIMPLICIALITY SIMPLE FAR_FACE FEASIBLE POINTED SIMPLICIAL LINEALITY_SPACE F_VECTOR CONE_DIM N_VERTICES
 +> $coll_local->​remove($p->​name);​
 +> print $coll_local->​count({});​
 +13
 +</​code>​
  
  • user_guide/tutorials/latest/json_and_polydb.txt
  • Last modified: 2020/01/29 11:00
  • (external edit)