\documentclass{amsart}
\usepackage{enumerate}
\usepackage{amssymb}
\usepackage{graphicx}
\usepackage{url}

\author{Bjarke Hammersholt Roune}

\newcommand{\frobbyVersion}{0.9.9}
\title{Frobby User Manual - Version \frobbyVersion}

\theoremstyle{definition}
\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{algorithm}[theorem]{Algorithm}
\newtheorem{example}[theorem]{Example}

\DeclareMathOperator{\lcm}{lcm}
\DeclareMathOperator{\irr}{irr}
\DeclareMathOperator{\supp}{supp}
\DeclareMathOperator{\hilbSym}{hilb}
\DeclareMathOperator{\msmSym}{msm}
\DeclareMathOperator{\conSym}{con}
\DeclareMathOperator{\lcmLatSym}{lat}

\def\cocoa{{\hbox{\rm C\kern-.13em o\kern-.07em C\kern-.13em o\kern-.15em A}}}

\newcommand{\hp}{Hilbert-Poincar\'e}
\newcommand{\hps}{Hilbert-Poincar\'e series}

\newcommand{\R}{\mathbb{R}}
\newcommand{\Q}{\mathbb{Q}}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\La}{{\mathcal{L}_p}}
\newcommand{\s}{\ensuremath{^*}}
\newcommand{\p}{\ensuremath{^\prime}}
\newcommand{\pp}{\ensuremath{^{\prime\prime}}}
\newcommand{\biimp}{\Leftrightarrow}
\newcommand{\imp}{\Rightarrow}
\newcommand{\impby}{\Leftarrow}

\newcommand{\setBuilder}[2]{\left\{#1\left|#2\right.\right\}}
\newcommand{\idealBuilder}[2]{\left\langle#1\left|#2\right.\right\rangle}
\newcommand{\card}[1]{\left|#1\right|}

\newcommand{\grobner}{Gr\"obner}

\newcommand{\proofPart}[1]{{\bf $\boldsymbol{#1}$:}}
\newcommand{\proofCase}[1]{\proofPart{\text{The case }#1}}
\newcommand{\proofSubPart}[1]{{\underline{${#1}$:}}}

\newcommand{\icode}[1]{\hspace{20pt}\mbox{#1}}

\newcommand{\msm}[1]{\msmSym\left({#1}\right)}
\newcommand{\con}[3]{\conSym\left({#1},{#2},{#3}\right)}
\newcommand{\cont}[1]{\conSym\left({#1}\right)}
\newcommand{\hilb}[1]{\hilbSym\left({#1}\right)}
\newcommand{\decom}[1]{\irr\left({#1}\right)}
\newcommand{\ming}[1]{\min\left({#1}\right)}
\newcommand{\deSym}{\phi}
\newcommand{\de}[1]{\deSym\left(#1\right)}
\newcommand{\ideal}[1]{\left<#1\right>}
\newcommand{\mono}[1]{\text{M}\left(#1\right)}
\newcommand{\expo}[2]{e_{#1}\left({#2}\right)}
\newcommand{\set}[1]{\left\{{#1}\right\}}
\newcommand{\lcmlat}[1]{\lcmLatSym\left({#1}\right)}
\newcommand{\lcmlatp}[1]{\lcmLatSym^\prime\left({#1}\right)}

\newcommand{\degx}[2]{\ensuremath{\deg_{x_{#1}}\!\!\left({#2}\right)}}

\newcommand{\projSym}{\ensuremath{\pi}}
\newcommand{\proj}[1]{\ensuremath{\projSym\left({#1}\right)}}

\begin{document}

\maketitle

\tableofcontents

This is a minimal manual for Frobby. At present it contains
information on how to install Frobby on your system, as well as
documentation in the form of a tutorial which shows how to do most
things that Frobby can do.

The most complete reference for the functionality of Frobby is the
help system built into Frobby. However that system may be \emph{too}
complete to serve as a good introduction, and this manual is intended
to cover that area.

This manual will be expanded in time to cover the algorithms that
Frobby uses, explain the file formats in detail and cover the
mathematical meaning of the computations that Frobby performs.

\section{Installation}

Frobby is tested to work on Linux, Mac OS 10.5 and Cygwin on
Windows. It may work on other platforms, but that has not been
tested. Although the procedure to install Frobby is the same on these
platforms, Frobby requires the GMP library, which is installed in
different ways depending on platform.

\subsection{Cygwin preparation}

Before installing Frobby, first run the Cygwin file setup.exe, and
then install the following Cygwin packages.

\begin{description}
\item[libgmp-devel] In category libs. For infinite-precision integers.
\item[make] In category devel. To build Frobby.
\item[gcc-g++] In category devel. To compile Frobby.
\item[diffutils] In category utils. For Frobby's test system, which uses diff.
\end{description}

\subsection{Mac OS 10.5 preparation using Fink}

If you have fink installed on your system, simply type

\begin{verbatim}
fink install gmp-shlibs libgmpxx-shlibs
\end{verbatim}

\subsection{Linux or Mac preparation without Fink}

Download the newest version of GMP from \url{http://gmplib.org/} and
unpack it somewhere. Then start a terminal, go to the directory where
you unpacked it, and type

\begin{verbatim}
./configure --enable-cxx
make
make check
make install
\end{verbatim}

Typing ``make check'' is optional but recommended to make sure that
your system compiled GMP properly. If you have trouble installing GMP,
first consult the GMP manual and then ask for help on the
gmp-discuss@gmplib.org mailing list.

\subsection{Installation of Frobby}

This step is the same on all platforms. First download the latest
version of Frobby from \url{http://www.broune.com/frobby/}. Then open
a terminal, go to the directory where you downloaded Frobby, and type
\begin{verbatim}
tar -xvf frobby_v0.8.2.tar.gz
cd frobby_v0.8.2
make
make install
\end{verbatim}

To see if your installation of Frobby is working, type
\begin{verbatim}
frobby
\end{verbatim}
You should now be looking at information about Frobby and its help
system. If you instead get a message along the lines of ``command not
found'', type
\begin{verbatim}
bin/frobby
\end{verbatim}
If that works, the install script was not able to place Frobby in a
convenient place on your system, probably because you don't have the
access rights to install programs centrally on your system. In that
case you can simply call Frobby as bin/frobby from the directory where
you unpacked it, or you can place the binary somewhere on your path
where you do have access rights to put it.

If you want to check that your Frobby compiled correctly, type
\begin{verbatim}
make test
\end{verbatim}
This will run a comprehensive battery of tests on Frobby, which can
take a while, especially on Cygwin, which is generally a slower
platform.

\section{Tutorial}

This is a tutorial on how to use the command line interface for
Frobby.

\subsection{File formats}

All of the file formats that Frobby understands are files that will
make sense to some other piece of mathematical software as well. In
general Frobby will figure out by itself which of the possible formats
you are using, and will produce output in that same format, so this is
not something you normally have to think about. In this tutorial we
will be using the Macaulay 2 format, which looks like this:
\begin{verbatim}
R = QQ[a, b, c, d];
I = monomialIdeal(
 a^2,
 a*b^5,
 c
);
\end{verbatim}
This describes the monomial ideal $\ideal{a^2,a*b^5,c}$ as an ideal in
the polynomial ring $\Q[a,b,c]$. There is some syntaxtic noice in this
file format, such as ``I = monomialIdeal('', which is solely there so
that Macaulay 2 will understand the file. In general, if the variables
are $x_1,\ldots,x_n$ and the generators are $g_1,\ldots,g_k$, then the
corresponding file will look like
\begin{verbatim}
R = QQ[x1,...,xn];
I = monomialIdeal(
 g1,
 ...,
 gk
);
\end{verbatim}

It is important to note that Frobby does not understand Macaulay 2
code at all -- it merely reads this very specific file format. This is
why Frobby is so fussy about this precise syntax being used. E.g. this
is not valid:
\begin{verbatim}
T = QQ[a, b, c, d];
I = monomialIdeal(
 a^2,
 a*b^5,
 c
);
\end{verbatim}
The error is that it must be ``R='' and not ``T='', so Frobby will
display the error
\begin{verbatim}
SYNTAX ERROR (format m2, line 1):
  Expected R, but got "T".
\end{verbatim}
Likewise, this will also result in an error:
\begin{verbatim}
R = QQ[a, b, c, d];
I = monomialideal(
 a\^2,
 a*b\^5,
 c
);
\end{verbatim}
The error is that the second i in ``monomialIdeal'' is lower-case, and
it is supposed to be upper-case. Frobby will diplay the error
\begin{verbatim}
SYNTAX ERROR (format m2, line 2):
  Expected monomialIdeal, but got "monomialideal".
\end{verbatim}
There is one particular error that is easy to make, namely that
indeterminates in the same monomial must be separated by an asterisk
*. This is because indeterminates can have names of more than one
character, so otherwise there is no way to distinguish between the
product of a and b and a single indeterminate named ab. Thus on this
input:
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 a^2b,
 b*c^2,
 c^3*a^3
);
\end{verbatim}
Frobby will produce the following error:
\begin{verbatim}
SYNTAX ERROR (format m2, line 3):
  Expected ), but got "b".
\end{verbatim}
Frobby is expecting a right parenthesis because that would make sense
after the 2 on line 3, seeing as there is no * there.

Note that Frobby does not care about additional space, and it does
not distinguish between a space and a newline.

To see a list of all file formats that Frobby supports, type
\begin{verbatim}
frobby help io
\end{verbatim}
To see an example of a monomial ideal in a format X, type
\begin{verbatim}
frobby genideal -oformat X
\end{verbatim}
If you do not specify a format, the Macaulay 2 format will be used, so
if you type simply
\begin{verbatim}
frobby genideal
\end{verbatim}
You will get something like
\begin{verbatim}
R = QQ[x1, x2, x3];
I = monomialIdeal(
 x1^3*x2^5*x3^6,
 x1^2*x2^6*x3,
 x1^5*x2^2*x3^8,
 x1^8*x2*x3^3,
 x1^5*x2^4*x3^7
);
\end{verbatim}
However, genideal generates a random ideal, so every time you run it,
you will likely get a different ideal.

\subsection{An example file and transformation}

We will need an example to run the following commands on, so take the
following lines and put them into a file called ``input''.
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 a^2*b,
 b*c^2,
 c^3*a^3
);
\end{verbatim}

To check that you wrote the format correctly, try to get Frobby to
read the file by typing
\begin{verbatim}
frobby transform < input
\end{verbatim}
If you get an error from Frobby, then you didn't type the file in correctly.

Note how transform produced output in the Macaulay 2 format. If you
want to transform your file into a different format, you can do so by typing
\begin{verbatim}
frobby transform < input -oformat monos
\end{verbatim}
which will produce output in a format that can be understood by the
program Monos. It will print
\begin{verbatim}
vars a, b, c;
[
 a^2*b,
 b*c^2,
 a^3*c^3
];
\end{verbatim}
In general Frobby uses the first non-space character of an input file
to figure out what format it is in, and it then produces output in
that same format, unless you specify the input or output format
explicitly using the command-line options -oformat and -iformat.

In general you tell frobby to do something by typing
\begin{verbatim}
frobby ACTION OPTIONS
\end{verbatim}
where ACTION is something to do, and OPTIONS is a possibly empty list
of options that specify how to do that thing. Thus you can make the
transform action behave in a number of different ways depending on the
options you give it. To take a look at everything that transform can do, type
\begin{verbatim}
frobby help transform
\end{verbatim}
In general you can get information on any action by typing
\begin{verbatim}
frobby help ACTION
\end{verbatim}
where ACTION is the name of the action. To get a list of all actions,
type
\begin{verbatim}
frobby help
\end{verbatim}

\subsection{Compute the Alexander dual of an ideal}

To compute the Alexander dual of our ideal, type
\begin{verbatim}
frobby alexdual < input
\end{verbatim}
which produces the output
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 b*c,
 a^2*c^2,
 a*b
);
\end{verbatim}
And it is indeed true that the Alexander dual of
$\ideal{a^2b,bc^2,a^3c^3}$ is $\ideal{bc,a^2c^2,ab}$.

By default Frobby will compute the Alexander dual of the input
according to the point that is the least common multiple of the
minimal generators of the input ideal. To use some other point, append
that monomial at the end of the file.

We can append a line by using echo and cat like this:
\begin{verbatim}
echo a^10*b^10*c^10|cat input -
\end{verbatim}
which prints
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 b*c,
 a^2*c^2,
 a*b
);
a^10*b^10*c^10
\end{verbatim}
so if we feed this to alexdual like this:
\begin{verbatim}
echo a^10*b^10*c^10|cat input -|frobby alexdual
\end{verbatim}
we get the Alexander dual of the ideal according to
$a^{10}b^{10}c^{10}$, which is
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 b^10*c^8,
 a^9*c^9,
 a^8*b^10
);
\end{verbatim}

To see the options that alexdual accepts, type
\begin{verbatim}
frobby help alexdual
\end{verbatim}

Also note that you generally don't have to type actions out, you only
have to specify a unique prefix. So to get the Alexander dual, it is
sufficient to type
\begin{verbatim}
frobby al < input
\end{verbatim}
However, it is not enough to just type
\begin{verbatim}
frobby a < input
\end{verbatim}
Since this is ambigous with the actions assoprimes and analyze, that
also have ``a'' as a prefix. In this case, Frobby reports that:
\begin{verbatim}
ERROR: Prefix "a" is ambigous.
Possibilities are: alexdual assoprimes analyze
\end{verbatim}

\subsection{\hp{} Series}

To get the \hps{}, type
\begin{verbatim}
frobby hilbert < input
\end{verbatim}
which produces the output
\begin{verbatim}
R = QQ[a, b, c];
p =
 1 +
 -b*c^2 +
 -a^2*b +
 a^2*b*c^2 +
 -a^3*c^3 +
 a^3*b*c^3;
\end{verbatim}
This means that the numerator of the \hps{} of $\ideal{a^2b,bc^2,a^3c^3}$ is
\[
 1
 -bc^2
 -a^2b +
 a^2bc^2
 -a^3c^3 +
 a^3bc^3
\]
so the series itself is
\[
\frac{
 1
 -bc^2
 -a^2b +
 a^2bc^2
 -a^3c^3 +
 a^3bc^3
}{
(1-a)(1-b)(1-c)}
\]
This is the multivariate, $\N^n$-graded hilbert series. You may want
the numerator of the univariate \hps{}, which you get by typing
\begin{verbatim}
frobby hilbert < input -univariate
\end{verbatim}
This produces the output
\begin{verbatim}
R = QQ[t];
p =
 t^7 +
 -t^6 +
 t^5 +
 -2*t^3 +
 1;
\end{verbatim}
so the univariate \hps{} is
\[
\frac{
 t^7
 -t^6 +
 t^5
 -2t^3 +
 1}{(1-t)^3}
\]
Frobby always uses the variable $t$ for the univariate series. The
univariate series is gotten from the multivariate series by
substituting $t$ for each of the variables in the ring, in this case
$a=t$, $b=t$ and $c=t$.

\subsection{Intersection of ideals}

We will now intersect two ideals, so we need another file with an
ideal in it. Type the following ideal into a file named input2:
\begin{verbatim}
R = QQ[d, b, c];
I = monomialIdeal(
 d*b*c,
 b^2*c
);
\end{verbatim}
This is the ideal $\ideal{dbc,b^2c}$. To intersect that with the ideal
$\ideal{a^2b,bc^2,a^3c^3}$, we will need to concatenate the two files
representing these two ideals. This is done by typing
\begin{verbatim}
cat input input2
\end{verbatim}
which produces the output
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 a^2*b,
 b*c^2,
 a^3*c^3
);
R = QQ[d, b, c];
I = monomialIdeal(
 d*b*c,
 b^2*c
);
\end{verbatim}
If we pass this to the intersect action, we will get the intersection. So type
\begin{verbatim}
cat input input2|frobby intersect
\end{verbatim}
to get the output
\begin{verbatim}
R = QQ[a, b, c, d];
I = monomialIdeal(
 b*c^2*d,
 b^2*c^2,
 a^2*b*c*d,
 a^2*b^2*c
);
\end{verbatim}
Note that we now have 4 variables in the first line, since the two
ideals together used these 4 variables. We see that the intersection is
\[
\ideal{
 bc^2d,
 b^2c^2,
 a^2bcd,
 a^2b^2c}
\]

\subsection{Irreducible decomposition}

To get the irreducible decomposition, type

\begin{verbatim}
frobby irrdecom < input
\end{verbatim}
which produces the output
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 b,
 c^3
);
I = monomialIdeal(
 a^2,
 c^2
);
I = monomialIdeal(
 a^3,
 b
);
\end{verbatim}
Note how the list of the variables does not have to be repeated
because all three ideals lie in the same ring. This is saying that the
irreducible decomposition of $\ideal{a^2b,bc^2,a^3c^3}$ is
\[
\set{\ideal{b,c^3},\ideal{a^2,c^2},\ideal{a^3,b}}
\]
Then it should be true that the intersection of these three ideals is
the original ideal, and indeed, if we type
\begin{verbatim}
frobby irrdecom < input|frobby intersection
\end{verbatim}
we get the output
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 b*c^2,
 a^2*b,
 a^3*c^3
);
\end{verbatim}
This format for a list of the irreducible components takes up a lot of
space and is not the easiest to read. We can get a more compact
notation by encoding each irreducible ideal as the product of its
generators, noting that this is a bijection between irreducible ideals
and monomials. Do this by typing
\begin{verbatim}
frobby irrdecom < input -encode
\end{verbatim}
to get the output
\begin{verbatim}
R = QQ[a, b, c];
I = monomialIdeal(
 b*c^3,
 a^2*c^2,
 a^3*b
);
\end{verbatim}
Here the monomial generator $bc^3$ corresponds to the irreducible
ideal $\ideal{b,c^3}$.

\subsection{Primary decomposition}

Frobby can compute primary decompositions as well as irreducible
decompositions. We need an example where there is a difference between
these two things, so type this into a file named input3:
\begin{verbatim}
R = QQ[d, b, c];
I = monomialIdeal(
 d*b*c,
 b^2*c,
 b^10,
 d^10
);
\end{verbatim}
To get the primary decomposition, type
\begin{verbatim}
frobby primdecom < input3
\end{verbatim}
which produces the decomposition
\begin{verbatim}
R = QQ[d, b, c];
I = monomialIdeal(
 d^10,
 b^10,
 c
);
I = monomialIdeal(
 d*b,
 d^10,
 b^2
);
\end{verbatim}
Note that these two ideals are primary, and that their intersection
equals the original ideal (you should know how to check the
intersection yourself by now).

An irreducble decomposition is also a primary decomposition, since an
irreducible ideal is primary, but the irreducible decomposition can
have many more elements than the primary decomposition does. In this
case it has one more, since we get the irreducible decomposition by typing
\begin{verbatim}
frobby irrdecom < input3
\end{verbatim}
which produces the output
\begin{verbatim}
R = QQ[d, b, c];
I = monomialIdeal(
 d,
 b^2
);
I = monomialIdeal(
 d^10,
 b
);
I = monomialIdeal(
 d^10,
 b^10,
 c
);
\end{verbatim}

The primary decomposition is not unique, but Frobby computes the
``nicest'' primary decomposition, which is the one gotten by
intersecting irreducible components of the same support, and that
primary decomposition is unique.

\subsection{Associated primes}

You get the associated primes by typing
\begin{verbatim}
frobby assoprimes < input3
\end{verbatim}

\begin{verbatim}
R = QQ[d, b, c];
I = monomialIdeal(
 d*b,
 d*b*c
);
\end{verbatim}
Each generator encodes an associated prime. In this case the
associated primes are $\ideal{d,b}$ and $\ideal{d,b,c}$. You can check
that these are the radicals of the primary components,

\subsection{Transform a polynomial}

Transform does a number of things to ideals, and ptransform is the
corresponding action for polynomials. Put a polynomial into the file
pinput by typing
\begin{verbatim}
frobby hilbert < input > pinput
\end{verbatim}
Then type
\begin{verbatim}
cat pinput
\end{verbatim}
to get
\begin{verbatim}
R = QQ[a, b, c];
p =
 1 +
 -b*c^2 +
 -a^2*b +
 a^2*b*c^2 +
 -a^3*c^3 +
 a^3*b*c^3;
\end{verbatim}
This is a file that Macaulay 2 can understand. To change the format of
this file to something that Singular can understand, type
\begin{verbatim}
frobby ptransform < pinput -oformat singular
\end{verbatim}
to get
\begin{verbatim}
ring R = 0, (a, b, c), lp;
int noVars = 0;
poly p =
 1
 -b*c^2
 -a^2*b
 +a^2*b*c^2
 -a^3*c^3
 +a^3*b*c^3;
\end{verbatim}
You might notice that the Singular format has something called
noVars. This is there merely because all Frobby formats must be able
to represent a ring with no variables, and Singular has no such
concept. Thus Frobby gets around that by always giving the ring at
least one variable, but writing noVars=1 if there really should not be
any, and noVars=0 otherwise.

To get the polynomial into a format that 4ti2 might have produced, if
it had a concept of polynomials, type
\begin{verbatim}
frobby ptransform < pinput -oformat 4ti2
\end{verbatim}
to get
\begin{verbatim}
6 4
1  0 0 0
-1  0 1 2
-1  2 1 0
1  2 1 2
-1  3 0 3
1  3 1 3
(coefficient) a b c
\end{verbatim}
The first line indicates the size of the matrix, and each row of the
matrix is a term, with the first number being the coefficient, and the
remaining numbers being the exponent vector. I.e. the exponent of $a$,
$b$ and $c$ respectively in that order.

To see what else ptransform can do, type
\begin{verbatim}
frobby help ptransform
\end{verbatim}

Note that if we knew in advance that we wanted to change the format
to, say, 4ti2 format, we could have produced the file pinput in that
format directly by typing
\begin{verbatim}
frobby hilbert < input > pinput -oformat 4ti2
\end{verbatim}

\subsection{Maximal standard monomials}

To produce the maximal standard monomials, type
\begin{verbatim}
frobby maxstandard < input3
\end{verbatim}
to get
\begin{verbatim}
R = QQ[d, b, c];
I = monomialIdeal(
 d^9*b^9
);
\end{verbatim}

\subsection{The Frobenius problem}

Given an input vector $p=(p_1,\ldots,p_n)$ of positive relatively
prime integers, the Frobenius number of $p$ is the largest integer
that cannot be written as a linear combination of $p_1,\ldots,p_n$
where the coefficients in the combination are non-negative integers.

To work with this, put the following example in a file named frob
\begin{verbatim}
6 10 15
\end{verbatim}
and type
\begin{verbatim}
frobby frobdyn < frob
\end{verbatim}
to get as output that the Frobenius number is
\begin{verbatim}
29
\end{verbatim}
The frobdyn action uses an obscenely slow dynamic programming
algorithm to compute the Frobenius number. If you install the program
4ti2 and put it into the empty 4ti2 subfolder of the Frobby folder,
you can use an algorithm that is much faster when the Frobenius number
itself is moderately large.

Assume that you have installed 4ti2 in that folder. Then, within the
Frobby folder, type
\begin{verbatim}
./frobgrob frob
\end{verbatim}
which will produce the same output, namely
\begin{verbatim}
29
\end{verbatim}
Now put this input into a file named frob2
\begin{verbatim}
1234567890001
348461546433
6484646532513541
45464188888115164
1561484651561864468465310
\end{verbatim}
and type
\begin{verbatim}
./frobgrob frob2
\end{verbatim}
to get that the Frobenius number is
\begin{verbatim}
15111053020091472900
\end{verbatim}
This computation would never have completed using the dynfrob
action. Note that you get better performance if you sort the numbers
in increasing order.

Note that ./frobgrob is a script that uses 4ti2 and the frobgrob
action of Frobby. This is a bit annoying to get right, which is why
there is a script doing it. To get a hint on how to do this yourself
directly without using the script, take a look at the script, look at
the documentation for 4ti2, and type
\begin{verbatim}
frobby help frobgrob
\end{verbatim}
to get an idea about what input frobgrob expects.

You can also generate random Frobenius instances by typing
\begin{verbatim}
frobby genfrob
\end{verbatim}
to produce something like
\begin{verbatim}
4259 8346 12295 18936 22645 27086 34182 69298 74617 84570
\end{verbatim}
The output is random, so you will likely get a different instance.

\subsection{Analyze an ideal}

To get Frobby to analyze the ideal and tell you what it figured out
about it, type
\begin{verbatim}
frobby analyze < input
\end{verbatim}
which produces the output
\begin{verbatim}
3 generators
3 variables
\end{verbatim}
This is admittedly not an impressive level of analysis being
performed. To see a few more things that analyze can do, type
\begin{verbatim}
frobby help analyze
\end{verbatim}
The idea is that this action will be expanded to provide actual
valuable information, such as whether the ideal is strongly generic,
if it is weakly generic, strongly/weakly co-generic, how many
irreducible and primary components it has, if any of the given
generators are non-minimal and various things like that.
\begin{verbatim}
\end{verbatim}


\end{document}
