@comment -*-texinfo-*-
@comment $Id: start.doc,v 1.5 1998-05-07 16:19:19 Singular Exp $
@comment this file contains the "Introduction" chapter.
@menu
* Background::
* How to use this manual::
* Getting started::
@end menu

@c ------------------------------------------------------------------
@node Background, How to use this manual, Introduction, Introduction
@section Background
@cindex Background

@sc{Singular} performs algebraic manipulations on numbers, polynomials, ideals,
rings, modules, matrices and maps between rings.
The baserings are polynomial rings or localizations hereof over a field
(e.g finite fields, the rationals, reals, algebraic extensions,
transcendental extensions) or quotient rings with respect to an ideal.
The main objects in @sc{Singular} are ideals and modules,
one of the main algorithms is a general standard basis
algorithm with respect to
any semigroup ordering. This includes Buchberger's algorithm
(if the ordering is a wellordering) and Mora's algorithm (if the ordering is
a tangent cone ordering) as special cases.
Other algorithms include computing modules of syzygies,
finite free resolutions, Hilbert-Poincare series, etc.
The first implementation of the tangent cone algorithm
was done in Modula 2 at the Humboldt
University of Berlin by Gerhard Pfister and Hans
@tex
 Sch\"onemann
@end tex
@ifinfo
 Schoenemann
@end ifinfo
 in 1986.
@c It was mainly able to compute certain special invariants of singularities.
In September 1991 it became a joint project of the Humboldt University of
Berlin and the University of Kaiserslautern.
Since 1994 the development of @sc{Singular} is continued at Kaiserslautern.
@c The goal was to have all the
@c well known algorithms for computing in
@c nonhomogeneous ideals in polynomial and powers series rings.
The need for a new system arose from
the investigation of mathematical problems
coming from singularity theory which none of the existing systems
were able to compute.
Later we included an algorithm for multivariate polynomial factorization
in order to perform efficiently primary decomposition of ideals.
The need for solving big systems of polynomial equations, orginating
from practical problems in microelectronics, let us implement FGLM-techniques;
further algorithms for this purpose are to be implemented.
Thus, we hope to offer a useful system
for dealing with local and global computational aspects
of systems of polynomial equations.

@c ------------------------------------------------------------------
@node How to use this manual, Getting started, Background, Introduction
@section How to use this manual
@cindex How to use this manual
Generally speaking, the manual starts as a user manual and becomes more
and more a reference manual in the later chapters.
Somewhat outstanding from this rule is @ref{Mathematical background}.  It
introduces some of the mathematical notions and definitions used
throughout this manual.  For example, if in doubt what exactly
@sc{Singular} means by a ``negative degree reverse lexicographical
ordering'' one should refer to this chapter.

In @ref{Getting started}, some simple examples are explained in a
step-by-step manner to introduce into @sc{Singular}.  This includes the
most important steps: how to enter and exit.

For real learning-by-doing or to quickly solve some given mathematical
problem without dwelling to deeply into @sc{Singular} one should
continue with @ref{Examples} (which is the last exception to the
rule stated in the first paragraph).  This chapter contains a lot of
real-life examples and detailed instructions and explanations how to
solve them using @sc{Singular}.

Users preferring the systematic approach maybe would like to continue
with @ref{General concepts}, instead of/in addition to running the
examples.  All basic concepts important to use and understand
@sc{Singular} are developed there more or less in the order the novice
user has to deal with them.

@itemize @bullet
@item
In @ref{Interactive use}, and its subsections there are again some words
on entering and exiting @sc{Singular}, followed by a number of other
aspects concerning the interactive user-interface.

@item
To do anything more than trivial integer computations, one needs to
define a basering in @sc{Singular}.  This is explained in detail in
@ref{Rings and orderings}.

@item
In @ref{The SINGULAR language}, language specific concepts are
introduced such as the notions of names and objects, data types and
conversion between them, etc.

@item
The more complex concepts of procedures and libraries of procedures as
well as tools to debug them are considered in the following sections:
@ref{Procedures}, @ref{Libraries}, and @ref{Debugging tools}.

@item
An overview of the algorithms implemented in @sc{Singular} is given in
@ref{Implemented algorithms}.
@end itemize

@ref{Data types}, is a complete treatment for @sc{Singular}'s data types
where each section corresponds to one data type.  Except from the syntax
of declarations, expressions, and operations, in each section there is a
subsection listing all functions related to that particular type.

@ref{Functions and variables}, is a large alphabetically ordered list of
all of @sc{Singular}'s functions, control structures, and system
variables.  Each entry includes a description of the syntax and
semantics of the item being explained as well as one or more examples
how to use it.

@ref{Tricks and pitfalls}, is a loose collection of limitations and
features which may be unexpected by those who expect to be the
@sc{Singular} language an exact copy of the C programming language.  But
some mathematical tips are collected there, too.

The libraries which come with @sc{Singular} and the functions contained
in them are listed in @ref{SINGULAR libraries}, and @ref{Library function
index}, resp.

@c ------------------------------------------------------------------
@node Getting started,  , How to use this manual, Introduction
@section Getting started
@cindex Getting started