passagemath-gap-pkg-normalizinterface 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

gap/pkg/normalizinterface/etc/download.sh

@@ -0,0 +1,85 @@
+#!/bin/sh
+#
+# Download a file and verify its checksum; repeat until
+# the checksum matches or the user told us to give up.
+
+set -e
+
+usage() {
+    cat <<EOF
+Usage: $0 URL [SHA256 [FILENAME]]
+EOF
+
+    exit $1
+}
+
+if [ $# -lt 1 ]; then
+    usage 1
+fi
+if [ $# -gt 3 ]; then
+    usage 1
+fi
+
+FileURL="$1"
+ExpectedChecksum="$2"
+if [ $# = 3 ]; then
+    Filename="$3"
+else
+    Filename=$(basename ${FileURL})
+fi
+
+while : ; do
+
+    #
+    # Download
+    #
+    if [ -e ${Filename} ] ; then
+        echo "Checking for ${Filename}... found existing file, using that"
+        # TODO: add a checksum check?
+    elif command -v wget >/dev/null 2>&1 ; then
+        echo "Checking for ${Filename}... downloading with wget"
+        wget ${FileURL}
+    elif command -v curl >/dev/null 2>&1 ; then
+        echo "Checking for ${Filename}... downloading with curl"
+        curl -L -O ${FileURL}
+    else
+        echo "Checking for ${Filename}... not found and unable to download"
+        echo
+        echo "Please manually download the following file:"
+        echo "  ${FileURL}"
+        echo "Put it into the current directory and re-run this script."
+        exit 1
+    fi
+
+    #
+    # Compute checksum
+    #
+    echo "Verifying SHA256 checksum of ${Filename}..."
+    if command -v sha256sum >/dev/null 2>&1 ; then
+        ActualChecksum=$(sha256sum ${Filename})
+    elif command -v shasum >/dev/null 2>&1 ; then
+        ActualChecksum=$(shasum -a 256 ${Filename})
+    elif command -v openssl >/dev/null 2>&1 ; then
+        ActualChecksum=$(openssl sha256 ${Filename})
+    else
+        ActualChecksum=skip
+    fi
+
+    #
+    # Compare checksum
+    #
+    case ${ActualChecksum} in
+       *${ExpectedChecksum}* )
+           echo "   valid SHA256 checksum"
+           break
+           ;;
+       *)  echo "   invalid SHA256 checksum, expected ${ExpectedChecksum} but got ${ActualChecksum}"
+           echo "     retrying in 30 seconds..."
+           sleep 30
+           rm -f ${Filename}
+           ;;
+    esac
+
+done;
+
+exit 0

gap/pkg/normalizinterface/etc/generate_cone_property_wrappers.g

@@ -0,0 +1,380 @@
+LoadPackage("NormalizInterface");
+
+docstrings := rec(
+
+AffineDim := rec(
+  returns := "the affine dimension",
+  description := """
+The affine dimension of the polyhedron in inhomogeneous computations. Its computation is triggered if necessary.
+""",
+),
+
+ClassGroup := rec(
+  returns := "the class group in a special format",
+  description := """
+A normal affine monoid $M$ has a well-defined divisor class group.
+It is naturally isomorphic to the divisor class group of $K[M]$ where $K$
+is a field (or any unique factorization domain).
+We represent it as a vector where the first entry is the rank. It is
+followed by sequence of pairs of entries <M>n,m</M>. Such two entries
+represent a free cyclic summand <M>(\mathbb{Z}/n\mathbb{Z})^m</M>.
+Not allowed in inhomogeneous computations.
+""",
+),
+
+Congruences := rec(
+  returns := "a matrix whose rows represent the congruences",
+  description := """
+The equations, congruences and support hyperplanes together
+describe the lattice points of the cone.
+""",
+),
+
+Deg1Elements := rec(
+  returns := "a matrix whose rows are the degree 1 elements",
+  description := """
+Requires the presence of a grading. Not allowed in inhomogeneous computations.
+""",
+),
+
+Dehomogenization := rec(
+  returns := "the dehomgenization vector",
+  description := """
+Only for inhomogeneous computations.
+""",
+),
+
+EmbeddingDim := rec(
+  rename := "EmbeddingDimension",
+  returns := "the embedding dimension of the cone",
+  description := """
+The embedding dimension is the dimension of the space in which the
+computation is done. It is the number of components of the output vectors.
+This value is always known directly after the creation of the cone.
+""",
+),
+
+Equations := rec(
+  returns := "a matrix whose rows represent the equations",
+  description := """
+The equations cut out the linear space generated by the cone.
+The equations, congruences and support hyperplanes together
+describe the lattice points of the cone.
+""",
+),
+
+ExcludedFaces := rec(
+  returns := "a matrix whose rows represent the excluded faces",
+  description := "",
+),
+
+ExtremeRays := rec(
+  returns := "a matrix whose rows are the extreme rays",
+  description := "",
+),
+
+Generators := rec(
+  returns := "a matrix whose rows are the generators of <A>cone</A>",
+  description := "",
+),
+
+GeneratorOfInterior := rec(
+  returns := "a vector representing the generator of the interior of <A>cone</A>",
+  description := """
+If <A>cone</A> is Gorenstein, this function returns the generator of the interior of <A>cone</A>.
+If <A>cone</A> is not Gorenstein, an error is raised.
+""",
+),
+
+Grading := rec(
+  returns := "the grading vector",
+  description := "",
+),
+
+HilbertBasis := rec(
+  returns := "a matrix whose rows are the Hilbert basis elements",
+  description := "",
+),
+
+HilbertQuasiPolynomial := rec(
+  returns := "the Hilbert function as a quasipolynomial",
+  description := """
+The Hilbert function counts the lattice points degreewise. The result is a
+quasipolynomial <M>Q</M>, that is, a polynomial with periodic coefficients. It is
+given as list of polynomials <M>P_0, \ldots, P_{(p-1)}</M> such that <M>Q(i) = P_{(i \bmod p)} (i)</M>.
+""",
+),
+
+HilbertSeries := rec(
+  returns := "the Hilbert series as rational function",
+  description := """
+The result consists of a list with two entries. The first is the numerator
+polynomial. In inhomogeneous computations this can also be a Laurent
+polynomial. The second list entry represents the denominator. It is a list
+of pairs <M>[k_i, l_i]</M>. Such a pair represents the factor <M>(1-t^{k_i})^{l_i}</M>.
+""",
+),
+
+InclusionExclusionData := rec(
+  returns := "inclusion-exclusion data",
+  description := """
+List of faces which are internally have been used in the inclusion-exclusion
+scheme. Given as a list pairs. The first pair entry is a key of generators
+contained in the face (compare also <Ref Func="NmzTriangulation"/>) and the
+multiplicity with which it was considered.
+Only available with excluded faces or strict constraints as input.
+""",
+),
+
+IsDeg1ExtremeRays := rec(
+  returns := "<K>true</K> if all extreme rays have degree 1; <K>false</K> otherwise",
+  description := "",
+),
+
+IsDeg1HilbertBasis := rec(
+  returns := "<K>true</K> if all Hilbert basis elements have degree 1; <K>false</K> otherwise",
+  description := "",
+),
+
+IsGorenstein := rec(
+  returns := "whether the cone is Gorenstein",
+  description := """
+Returns true if <A>cone</A> is Gorenstein, false otherwise.
+""",
+),
+
+IsInhomogeneous := rec(
+  returns := "whether the cone is inhomogeneous",
+  description := """
+This value is always known directly after the creation of the cone.
+""",
+),
+
+IsIntegrallyClosed := rec(
+  returns := "<K>true</K> if the cone is integrally closed; <K>false</K> otherwise",
+  description := """
+It is integrally closed when the Hilbert basis is a subset of the original monoid generators. So it is only computable if we have original monoid generators.
+""",
+),
+
+IsPointed := rec(
+  returns := "<K>true</K> if the cone is pointed; <K>false</K> otherwise",
+  description := "",
+),
+
+IsReesPrimary := rec(
+  returns := "<K>true</K> if is the monomial ideal is primary to the irrelevant maximal ideal, <K>false</K> otherwise",
+  description := """
+Only used with the input type <C>rees_algebra</C>.
+""",
+),
+
+MaximalSubspace := rec(
+  returns := "a matrix whose rows generate the maximale linear subspace",
+  description := "",
+),
+
+ModuleGenerators := rec(
+  returns := "a matrix whose rows are the module generators",
+  description := "",
+),
+
+ModuleGeneratorsOverOriginalMonoid := rec(
+  returns := "a matrix whose rows are the module generators over the original monoid",
+  description := """
+A minimal system of generators of  the integral closure over the original monoid.
+Requires the existence of original monoid generators. Not allowed in inhomogeneous computations.
+""",
+),
+
+ModuleRank := rec(
+  returns := "the rank of the module of lattice points in the polyhedron as a module over the recession monoid",
+  description := """
+Only for inhomogeneous computations.
+""",
+),
+
+OriginalMonoidGenerators := rec(
+  returns := "a matrix whose rows are the original monoid generators",
+  description := "",
+),
+
+Rank := rec(
+  returns := "the rank of the cone",
+  description := """
+This value is the rank of the lattice generated by the lattice points of the cone.
+""",
+),
+
+RecessionRank := rec(
+  returns := "the rank of the recession cone",
+  description := """
+Only for inhomogeneous computations.
+""",
+),
+
+ReesPrimaryMultiplicity := rec(
+  description := """
+the multiplicity of a monomial ideal, provided it is primary to the maximal
+ideal generated by the indeterminates. Used only with the input type
+<C>rees_algebra</C>.
+""",
+),
+
+SupportHyperplanes := rec(
+  returns := "a matrix whose rows represent the support hyperplanes",
+  description := """
+The equations cut out the linear space generated by the cone.
+The equations, congruences and support hyperplanes together
+describe the lattice points of the cone.
+""",
+),
+
+Triangulation := rec(
+  returns := "the triangulation",
+  description := """
+This returns a list of the maximal simplicial cones in a triangulation, i.e., a list of cones dividing the
+cone into simplicial cones. Each cone in the list is represented by a pair.
+The first entry of such a pair is the key of the simplex, i.e., a list of integers $a_1,\dots,a_n$
+referring to the <Ref Func="NmzGenerators"/> (counting from 0) which are used in this simplicial cone.
+The second entry of each pair in the list is the absolute value of the determinant of the generator matrix of the simplicial cone.
+""",
+),
+
+TriangulationDetSum := rec(
+  returns := "sum of the absolute values of the determinants of the simplicial cones in the used triangulation",
+  description := "",
+),
+
+TriangulationSize := rec(
+  returns := "the number of simplicial cones in the used triangulation",
+  description := "",
+),
+
+VerticesFloat := rec(
+  returns := "a matrix whose rows are the vertices of the polyhedron <A>cone</A> with float coordinates",
+  description := """
+The rows of this matrix represent the vertices of <A>cone</A>, printed as floats for better readability.
+The result might be inexact, and should therefore not be used for computations.
+""",
+),
+
+VerticesOfPolyhedron := rec(
+  returns := "a matrix whose rows are the vertices of the polyhedron",
+  description := "",
+),
+
+
+EhrhartSeries := rec(
+  description := """
+ Supported in Normaliz >= 3.5.0.
+""",
+),
+
+EuclideanVolume := rec(
+  description := """
+ Supported in Normaliz >= 3.5.0.
+""",
+),
+
+ProjectCone := rec(
+  description := """
+ Supported in Normaliz >= 3.5.0.
+""",
+),
+
+SuppHypsFloat := rec(
+  description := """
+ Supported in Normaliz >= 3.5.2.
+""",
+),
+
+Volume := rec(
+  description := """
+ Supported in Normaliz >= 3.5.0.
+""",
+),
+
+FVector := rec(
+  description := """
+ Supported in Normaliz >= 3.7.0.
+""",
+),
+
+FaceLattice := rec(
+  description := """
+ Supported in Normaliz >= 3.7.0.
+""",
+),
+
+Incidence := rec(
+  description := """
+ Supported in Normaliz >= 3.8.0.
+""",
+),
+
+);
+
+all_props := Set(RecNames(_NmzRecordOfConeProperties));
+documented_props := RecNames(docstrings);
+
+for x in Difference(documented_props, all_props) do
+    Print("Property ", x, " is documented but not actually available\n");
+od;
+
+for x in Difference(all_props, documented_props) do
+    Print("Property ", x, " is undocumented\n");
+od;
+
+stream := OutputTextFile("lib/cone_property_wrappers.gd", false);
+SetPrintFormattingStatus(stream, false);
+
+PrintTo(stream,"""# WARNING: This file was generated by etc/generate_cone_property_wrappers.g,
+# DO NOT EDIT IT BY HAND!
+
+#! @Chapter Functions
+#! @Section Cone properties
+
+""");
+for x in all_props do
+    if IsBound(docstrings.(x)) then
+        r := docstrings.(x);
+    else
+        r := rec(description:="");
+    fi;
+    if IsBound(r.rename) then y := r.rename; else y := x; fi;
+    PrintTo(stream, "#! @Arguments cone\n");
+    if IsBound(r.returns) then
+        PrintTo(stream, "#! @Returns ", r.returns, "\n");
+    fi;
+    PrintTo(stream, "#! @Description\n");
+    lines := SplitString(r.description, "\n");
+    for l in lines do
+        PrintTo(stream, "#! ", l ,"\n");        
+    od;
+    if Length(lines) > 0 then
+        PrintTo(stream, "#! <P/>\n");
+    fi;
+    PrintTo(stream, "#! This is an alias for <C>NmzConeProperty( cone, \"", x, "\" );</C> see <Ref Func=\"NmzConeProperty\"/>.\n");
+    PrintTo(stream, "DeclareGlobalFunction( \"Nmz", y, "\" );\n");
+od;
+
+CloseStream(stream);
+
+
+stream := OutputTextFile("lib/cone_property_wrappers.gi", false);
+SetPrintFormattingStatus(stream, false);
+PrintTo(stream,"""# WARNING: This file was generated by etc/generate_cone_property_wrappers.g,
+# DO NOT EDIT IT BY HAND!
+
+""");for x in all_props do
+    y := x;
+    if IsBound(docstrings.(x)) then
+        r := docstrings.(x);
+        if IsBound(r.rename) then
+            y := r.rename;
+        fi;
+    fi;
+    PrintTo(stream, "InstallGlobalFunction( Nmz", y, ", cone -> NmzConeProperty( cone, \"", x,"\" ) );\n");
+od;
+CloseStream(stream);

gap/pkg/normalizinterface/examples/5x5.g

@@ -0,0 +1,22 @@
+## 5x5 magic square
+LoadPackage("NormalizInterface");
+
+
+5x5eq := [
+[1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1],
+[0, 1, 1, 1, 1, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0],
+[1, 0, 1, 1, 1, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0],
+[1, 1, 0, 1, 1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0],
+[1, 1, 1, 0, 1, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0],
+[1, 1, 1, 1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1],
+[0, 1, 1, 1, 1, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1],
+[1, 1, 1, 1, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0]
+];
+5x5grading := [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];
+
+NmzSetVerboseDefault(true);
+5x5cone := NmzCone(["equations", 5x5eq,"grading",5x5grading]);
+NmzHilbertSeries(5x5cone); time;

gap/pkg/normalizinterface/examples/demo.g

@@ -0,0 +1,53 @@
+#! @BeginChunk Demo_example
+#! @BeginExample
+C := NmzCone(["integral_closure",[[2,1],[1,3]]]);
+#! <a Normaliz cone>
+NmzHasConeProperty(C,"HilbertBasis");
+#! false
+NmzHasConeProperty(C,"SupportHyperplanes");
+#! false
+NmzConeProperty(C,"HilbertBasis");
+#! [ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 1 ] ]
+NmzHasConeProperty(C,"SupportHyperplanes");
+#! true
+NmzConeProperty(C,"SupportHyperplanes");
+#! [ [ -1, 2 ], [ 3, -1 ] ]
+#! @EndExample
+#! @EndChunk
+
+
+#! @BeginChunk Demo_example_equation
+#! @BeginExample
+D := NmzCone(["equations",[[1,2,-3]], "grading",[[0,-1,3]]]);
+#! <a Normaliz cone>
+NmzCompute(D,["DualMode","HilbertSeries"]);
+#! true
+NmzHilbertBasis(D);
+#! [ [ 1, 1, 1 ], [ 0, 3, 2 ], [ 3, 0, 1 ] ]
+NmzHilbertSeries(D);
+#! [ t^2-t+1, [ [ 1, 1 ], [ 3, 1 ] ] ]
+NmzHasConeProperty(D,"SupportHyperplanes");
+#! true
+NmzSupportHyperplanes(D);
+#! [ [ 0, 1, 0 ], [ 1, 0, 0 ] ]
+NmzEquations(D);
+#! [ [ 1, 2, -3 ] ]
+#! @EndExample
+#! @EndChunk
+
+
+#! @BeginChunk Demo_example_inhom_equation
+#! @BeginExample
+P := NmzCone(["inhom_equations",[[1,2,-3,1]], "grading", [[1,1,1]]]);
+#! <a Normaliz cone>
+NmzIsInhomogeneous(C);
+#! false
+NmzIsInhomogeneous(P);
+#! true
+NmzHilbertBasis(P);
+#! [ [ 1, 1, 1, 0 ], [ 3, 0, 1, 0 ], [ 0, 3, 2, 0 ] ]
+NmzModuleGenerators(P);
+#! [ [ 0, 1, 1, 1 ], [ 2, 0, 1, 1 ] ]
+#! @EndExample
+#! @EndChunk
+

gap/pkg/normalizinterface/examples/docs.g

@@ -0,0 +1,43 @@
+#! @BeginChunk NmzCone_example
+#! @BeginExample
+cone := NmzCone(["integral_closure",[[2,1],[1,3]]]);
+#! <a Normaliz cone>
+#! @EndExample
+#! @EndChunk
+
+#! @BeginChunk NmzHasConeProperty_example
+#! @BeginExample
+NmzHasConeProperty(cone, "ExtremeRays");
+#! false
+#! @EndExample
+#! @EndChunk
+
+#! @BeginChunk NmzKnownConeProperties_example
+#! @BeginExample
+NmzKnownConeProperties(cone);
+#! [ "EmbeddingDim", "Generators", "InternalIndex", "IsInhomogeneous", 
+#!   "OriginalMonoidGenerators", "Sublattice" ]
+#! @EndExample
+#! @EndChunk
+
+#! @BeginChunk NmzCompute_example
+#! @BeginExample
+NmzKnownConeProperties(cone);
+#! [ "EmbeddingDim", "Generators", "InternalIndex", "IsInhomogeneous", 
+#!   "OriginalMonoidGenerators", "Sublattice" ]
+NmzCompute(cone, ["SupportHyperplanes", "IsPointed"]);
+#! true
+NmzKnownConeProperties(cone);
+#! [ "EmbeddingDim", "ExtremeRays", "Generators", "InternalIndex", 
+#!   "IsDeg1ExtremeRays", "IsInhomogeneous", "IsPointed", "MaximalSubspace", 
+#!   "OriginalMonoidGenerators", "Rank", "Sublattice", "SupportHyperplanes" ]
+NmzCompute(cone);;
+NmzKnownConeProperties(cone);
+#! [ "ClassGroup", "EmbeddingDim", "ExtremeRays", "Generators", "HilbertBasis", 
+#!   "InternalIndex", "IsDeg1ExtremeRays", "IsInhomogeneous", 
+#!   "IsIntegrallyClosed", "IsPointed", "IsTriangulationNested", 
+#!   "IsTriangulationPartial", "MaximalSubspace", "OriginalMonoidGenerators", 
+#!   "Rank", "Sublattice", "SupportHyperplanes", "TriangulationDetSum", 
+#!   "TriangulationSize", "UnitGroupIndex" ]
+#! @EndExample
+#! @EndChunk

gap/pkg/normalizinterface/examples/dual_mode.g

@@ -0,0 +1,26 @@
+#! @BeginChunk example_dual
+#! @BeginExample
+M := [
+ [ 8,  8,  8,  7 ],
+ [ 0,  4,  0,  1 ],
+ [ 0,  1,  0,  7 ],
+ [ 0, -2,  0,  7 ],
+ [ 0, -2,  0,  1 ],
+ [ 8, 48,  8, 17 ],
+ [ 1,  6,  1, 34 ],
+ [ 2,-12, -2, 37 ],
+ [ 4,-24, -4, 14 ]
+];;
+D := NmzCone(["inhom_inequalities", M,
+              "signs", [[1,1,1]],
+              "grading", [[1,1,1]]]);
+#! <a Normaliz cone>
+NmzCompute(D,["DualMode","HilbertBasis","ModuleGenerators"]);
+#! true
+NmzHilbertBasis(D);
+#! [ [ 1, 0, 0, 0 ], [ 1, 0, 1, 0 ] ]
+NmzModuleGenerators(D);
+#! [ [ 0, 0, 0, 1 ], [ 0, 0, 1, 1 ], [ 0, 0, 2, 1 ], [ 0, 0, 3, 1 ] ]
+#! @EndExample
+#! @EndChunk
+

gap/pkg/normalizinterface/examples/magic_square.g

@@ -0,0 +1,36 @@
+#! @BeginChunk Demo_example_3x3magiceven
+#! @BeginExample
+Magic3x3even := NmzCone(["equations",
+[ [1, 1, 1,  -1, -1, -1,   0,  0,  0],
+  [1, 1, 1,   0,  0,  0,  -1, -1, -1],
+  [0, 1, 1,  -1,  0,  0,  -1,  0,  0],
+  [1, 0, 1,   0, -1,  0,   0, -1,  0],
+  [1, 1, 0,   0,  0, -1,   0,  0, -1],
+  [0, 1, 1,   0, -1,  0,   0,  0, -1],
+  [1, 1, 0,   0, -1,  0,  -1,  0,  0] ],
+"congruences",
+[ [1, 0, 0,   0, 0, 0,   0, 0, 0,  2],
+  [0, 0, 1,   0, 0, 0,   0, 0, 0,  2],
+  [0, 0, 0,   0, 0, 0,   1, 0, 0,  2],
+  [0, 0, 0,   0, 0, 0,   0, 0, 1,  2] ],
+"grading",
+[ [1, 1, 1,   0, 0, 0,   0, 0, 0] ] ] );
+#! <a Normaliz cone>
+
+NmzHilbertBasis(Magic3x3even);
+#! [ [ 0, 4, 2, 4, 2, 0, 2, 0, 4 ], [ 2, 0, 4, 4, 2, 0, 0, 4, 2 ], 
+#!   [ 2, 2, 2, 2, 2, 2, 2, 2, 2 ], [ 2, 4, 0, 0, 2, 4, 4, 0, 2 ], 
+#!   [ 4, 0, 2, 0, 2, 4, 2, 4, 0 ], [ 2, 3, 4, 5, 3, 1, 2, 3, 4 ], 
+#!   [ 2, 5, 2, 3, 3, 3, 4, 1, 4 ], [ 4, 1, 4, 3, 3, 3, 2, 5, 2 ], 
+#!   [ 4, 3, 2, 1, 3, 5, 4, 3, 2 ] ]
+
+
+NmzHilbertSeries(Magic3x3even);
+#! [ t^3+3*t^2-t+1, [ [ 1, 1 ], [ 2, 2 ] ] ]
+
+NmzHilbertQuasiPolynomial(Magic3x3even);
+#! [ 1/2*t^2+t+1, 1/2*t^2-1/2 ]
+
+#! @EndExample
+#! @EndChunk
+

gap/pkg/normalizinterface/init.g

@@ -0,0 +1,7 @@
+if LoadKernelExtension("NormalizInterface") = false then
+    Error("failed to load NormalizInterface kernel extension");
+fi;
+
+ReadPackage("NormalizInterface", "lib/normaliz.gd");
+
+ReadPackage("NormalizInterface", "lib/cone_property_wrappers.gd" );