% generated by GAPDoc2LaTeX from XML source (Frank Luebeck)
\documentclass[a4paper,11pt]{report}
\usepackage{a4wide}
\sloppy
\pagestyle{myheadings}
\usepackage{amssymb}
\usepackage[utf8]{inputenc}
\usepackage{makeidx}
\makeindex
\usepackage{color}
\definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}
\definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083}
\definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179}
\definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894}
\definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894}
\definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000}
\definecolor{Black}{rgb}{0.0,0.0,0.0}
\definecolor{FuncColor}{rgb}{1.0,0.0,0.0}
%% strange name because of pdflatex bug:
\definecolor{Chapter }{rgb}{0.0,0.0,1.0}

\usepackage{fancyvrb}

\usepackage{pslatex}

\usepackage[pdftex=true,
        a4paper=true,bookmarks=false,pdftitle={Written with GAPDoc},
        pdfcreator={LaTeX with hyperref package / GAPDoc},
        colorlinks=true,backref=page,breaklinks=true,linkcolor=RoyalBlue,
        citecolor=RoyalGreen,filecolor=RoyalRed,
        urlcolor=RoyalRed,pagecolor=RoyalBlue]{hyperref}

% write page numbers to a .pnr log file for online help
\newwrite\pagenrlog
\immediate\openout\pagenrlog =\jobname.pnr
\immediate\write\pagenrlog{PAGENRS := [}
\newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}}
%% were never documented, give conflicts with some additional packages


\newcommand{\GAP}{\textsf{GAP}}

\begin{document}

\logpage{[ 0, 0, 0 ]}
\begin{titlepage}
\begin{center}{\Huge \textbf{\textsf{RingsForHomalg}\mbox{}}}\\[1cm]
\hypersetup{pdftitle=\textsf{RingsForHomalg}}
\markright{\scriptsize \mbox{}\hfill \textsf{RingsForHomalg} \hfill\mbox{}}
{\Large \textbf{Rings in External Computer Algebra Systems for the GAP-Package homalg\mbox{}}}\\[1cm]
{Version 2009.11.09 \mbox{}}\\[1cm]
{November 2009\mbox{}}\\[1cm]
\mbox{}\\[2cm]
{\large \textbf{Mohamed Barakat\\
    \mbox{}}}\\
{\large \textbf{Simon Goertzen    \mbox{}}}\\
{\large \textbf{Markus Kirschmer    \mbox{}}}\\
{\large \textbf{Markus Lange-Hegermann    \mbox{}}}\\
{\large \textbf{Max Neunh{\"o}ffer    \mbox{}}}\\
{\large \textbf{Daniel Robertz    \mbox{}}}\\
\hypersetup{pdfauthor=Mohamed Barakat\\
    ; Simon Goertzen    ; Markus Kirschmer    ; Markus Lange-Hegermann    ; Max Neunh{\"o}ffer    ; Daniel Robertz    }
\mbox{}\\[2cm]
\begin{minipage}{12cm}\noindent
(\emph{this manual is still under construction}) \\
\\
 This manual is best viewed as an \textsc{HTML} document. The latest version is available \textsc{online} at: \\
\\
 \href{http://homalg.math.rwth-aachen.de/~barakat/RingsForHomalg/chap0.html} {\texttt{http://homalg.math.rwth-aachen.de/\texttt{\symbol{126}}barakat/RingsForHomalg/chap0.html}} \\
\\
 An \textsc{offline} version should be included in the documentation subfolder of the package. This
package is part of the \textsf{homalg}-project: \\
\\
 \href{http://homalg.math.rwth-aachen.de/index.php/core-packages/ringsforhomalg} {\texttt{http://homalg.math.rwth-aachen.de/index.php/core-packages/ringsforhomalg}} \end{minipage}

\end{center}\vfill

\mbox{}\\
{\mbox{}\\
\small \noindent \textbf{Mohamed Barakat\\
    } --- Email: \href{mailto://barakat@mathematik.uni-kl.de} {\texttt{barakat@mathematik.uni-kl.de}}\\
 --- Homepage: \href{http://wwwb.math.rwth-aachen.de/~barakat/} {\texttt{http://wwwb.math.rwth-aachen.de/\texttt{\symbol{126}}barakat/}}\\
 --- Address: \begin{minipage}[t]{8cm}\noindent
 Department of Mathematics, \\
 University of Kaiserslautern, \\
 67653 Kaiserslautern, \\
 Germany \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Simon Goertzen    } --- Email: \href{mailto://simon.goertzen@rwth-aachen.de} {\texttt{simon.goertzen@rwth-aachen.de}}\\
 --- Homepage: \href{http://wwwb.math.rwth-aachen.de/~simon} {\texttt{http://wwwb.math.rwth-aachen.de/\texttt{\symbol{126}}simon}}\\
 --- Address: \begin{minipage}[t]{8cm}\noindent
 Lehrstuhl B f{\"u}r Mathematik, RWTH Aachen, Templergraben 64, 52056 Aachen,
Germany \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Markus Kirschmer    } --- Email: \href{mailto://markus.kirschmer@math.rwth-aachen.de} {\texttt{markus.kirschmer@math.rwth-aachen.de}}\\
 --- Homepage: \href{http://www.math.rwth-aachen.de/~Markus.Kirschmer} {\texttt{http://www.math.rwth-aachen.de/\texttt{\symbol{126}}Markus.Kirschmer}}\\
 --- Address: \begin{minipage}[t]{8cm}\noindent
 Lehrstuhl D f{\"u}r Mathematik, RWTH Aachen, Templergraben 64, 52056 Aachen,
Germany \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Markus Lange-Hegermann    } --- Email: \href{mailto://markus.lange-hegermann@rwth-aachen.de} {\texttt{markus.lange-hegermann@rwth-aachen.de}}\\
 --- Homepage: \href{http://wwwb.math.rwth-aachen.de/~markus} {\texttt{http://wwwb.math.rwth-aachen.de/\texttt{\symbol{126}}markus}}\\
 --- Address: \begin{minipage}[t]{8cm}\noindent
 Lehrstuhl B f{\"u}r Mathematik, RWTH Aachen, Templergraben 64, 52056 Aachen,
Germany \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Max Neunh{\"o}ffer    } --- Email: \href{mailto://daniel@momo.math.rwth-aachen.de} {\texttt{daniel@momo.math.rwth-aachen.de}}\\
 --- Homepage: \href{http://wwwb.math.rwth-aachen.de/~daniel} {\texttt{http://wwwb.math.rwth-aachen.de/\texttt{\symbol{126}}daniel}}\\
 --- Address: \begin{minipage}[t]{8cm}\noindent
 St Andrews University, School of Mathematics and Statistics, Mathematical
Institute, North Haugh, St Andrews, Fife KY16 9SS, Scotland, UK \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{Daniel Robertz    } --- Email: \href{mailto://daniel@momo.math.rwth-aachen.de} {\texttt{daniel@momo.math.rwth-aachen.de}}\\
 --- Homepage: \href{http://wwwb.math.rwth-aachen.de/~daniel} {\texttt{http://wwwb.math.rwth-aachen.de/\texttt{\symbol{126}}daniel}}\\
 --- Address: \begin{minipage}[t]{8cm}\noindent
 Lehrstuhl B f{\"u}r Mathematik, RWTH Aachen, Templergraben 64, 52056 Aachen,
Germany \end{minipage}
}\\
\end{titlepage}

\newpage\setcounter{page}{2}
{\small 
\section*{Copyright}
\logpage{[ 0, 0, 1 ]}
 {\copyright} 2007-2009 by Mohamed Barakat, Simon G{\"o}rtzen, Markus
Kirschmer, Markus Lange-Hegermann, Max Neunh{\"o}ffer, and Daniel Robertz.

 This package may be distributed under the terms and conditions of the GNU
Public License Version 2. \mbox{}}\\[1cm]
\newpage

\def\contentsname{Contents\logpage{[ 0, 0, 2 ]}}

\tableofcontents
\newpage

 \index{\textsf{RingsForHomalg}}   
\chapter{\textcolor{Chapter }{Introduction}}\label{intro}
\logpage{[ 1, 0, 0 ]}
\hyperdef{L}{X7DFB63A97E67C0A1}{}
{
  This package is part of the \textsf{homalg} project \cite{homalg-project}. The role of the package is described in the manual of the \textsf{homalg} package. 
\section{\textcolor{Chapter }{Ring Constructions for Supported External Computer Algebra Systems}}\label{RingConstructions}
\logpage{[ 1, 1, 0 ]}
\hyperdef{L}{X7B818AF0834AE510}{}
{
  Here are some of the supported ring constructions: 
\subsection{\textcolor{Chapter }{external \textsf{GAP}}}\label{ExternalGAP}
\logpage{[ 1, 1, 1 ]}
\hyperdef{L}{X827FA5FD7CBEE73C}{}
{
  
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> ZZ := HomalgRingOfIntegersInExternalGAP( );
  <A homalg external ring residing in the CAS GAP>
   gap> Display( ZZ );
   Z
  gap> F2 := HomalgRingOfIntegersInExternalGAP( 2, ZZ );
  <A homalg external ring residing in the CAS GAP>
   gap> Display( F2 );
   GF(2)
\end{Verbatim}
 \texttt{F2 := HomalgRingOfIntegersInExternalGAP( 2 )} would launch another GAP. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> Z4 := HomalgRingOfIntegersInExternalGAP( 4, ZZ );
  <A homalg external ring residing in the CAS GAP>
   gap> Display( Z4 );
   Z/4Z
  gap> Z_4 := HomalgRingOfIntegersInExternalGAP( ZZ ) / 4;
  <A homalg residue class ring>
  gap> Display( Z_4 );
  Z/( 4 )
  gap> Q := HomalgFieldOfRationalsInExternalGAP( ZZ );
  <A homalg external ring residing in the CAS GAP>
   gap> Display( Q );
   Q
\end{Verbatim}
 }

 
\subsection{\textcolor{Chapter }{\textsf{Singular}}}\label{Singular}
\logpage{[ 1, 1, 2 ]}
\hyperdef{L}{X840A7A5D7AE407F2}{}
{
  
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> F2 := HomalgRingOfIntegersInSingular( 2 );
  <A homalg external ring residing in the CAS Singular>
   gap> Display( F2 );
   GF(2)
  gap> Q := HomalgFieldOfRationalsInSingular( F2 );
  <A homalg external ring residing in the CAS Singular>
   gap> Display( Q );
   Q
\end{Verbatim}
 \texttt{Q := HomalgFieldOfRationalsInSingular( )} would launch another Singular. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> F2xyz := F2 * "x,y,z";
  <A homalg external ring residing in the CAS Singular>
   gap> Display( F2xyz );
   GF(2)[x,y,z]
  gap> Qxyz := Q * "x,y,z";
  <A homalg external ring residing in the CAS Singular>
   gap> Display( Qxyz );
   Q[x,y,z]
\end{Verbatim}
 }

 
\subsection{\textcolor{Chapter }{\textsf{MAGMA}}}\label{MAGMA}
\logpage{[ 1, 1, 3 ]}
\hyperdef{L}{X839147CF813312D6}{}
{
  
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> ZZ := HomalgRingOfIntegersInMAGMA( );
  <A homalg external ring residing in the CAS MAGMA>
   gap> Display( ZZ );
   Z
  gap> F2 := HomalgRingOfIntegersInMAGMA( 2, ZZ );
  <A homalg external ring residing in the CAS MAGMA>
   gap> Display( F2 );
   GF(2)
\end{Verbatim}
 \texttt{F2 := HomalgRingOfIntegersInMAGMA( 2 )} would launch another MAGMA. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> Z_4 := HomalgRingOfIntegersInMAGMA( ZZ ) / 4;
  <A homalg residue class ring>
  gap> Display( Z_4 );
  Z/( 4 )
  gap> Q := HomalgFieldOfRationalsInMAGMA( ZZ );
  <A homalg external ring residing in the CAS MAGMA>
   gap> Display( Q );
   Q
  gap> F2xyz := F2 * "x,y,z";
  <A homalg external ring residing in the CAS MAGMA>
   gap> Display( F2xyz );
   GF(2)[x,y,z]
  gap> Qxyz := Q * "x,y,z";
  <A homalg external ring residing in the CAS MAGMA>
   gap> Display( Qxyz );
   Q[x,y,z]
\end{Verbatim}
 }

 
\subsection{\textcolor{Chapter }{\textsf{Macaulay2}}}\label{Macaulay2}
\logpage{[ 1, 1, 4 ]}
\hyperdef{L}{X83D66E0279CF39E6}{}
{
  
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> ZZ := HomalgRingOfIntegersInMacaulay2( );
  <A homalg external ring residing in the CAS Macaulay2>
   gap> Display( ZZ );
   Z
  gap> F2 := HomalgRingOfIntegersInMacaulay2( 2, ZZ );
  <A homalg external ring residing in the CAS Macaulay2>
   gap> Display( F2 );
   GF(2)
\end{Verbatim}
 \texttt{F2 := HomalgRingOfIntegersInMacaulay2( 2 )} would launch another Macaulay2. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> Z_4 := HomalgRingOfIntegersInMacaulay2( ZZ ) / 4;
  <A homalg residue class ring>
  gap> Display( Z_4 );
  Z/( 4 )
  gap> Q := HomalgFieldOfRationalsInMacaulay2( ZZ );
  <A homalg external ring residing in the CAS Macaulay2>
   gap> Display( Q );
   Q
  gap> F2xyz := F2 * "x,y,z";
  <A homalg external ring residing in the CAS Macaulay2>
   gap> Display( F2xyz );
   GF(2)[x,y,z]
  gap> Qxyz := Q * "x,y,z";
  <A homalg external ring residing in the CAS Macaulay2>
   gap> Display( Qxyz );
   Q[x,y,z]
\end{Verbatim}
 }

 
\subsection{\textcolor{Chapter }{\textsf{Sage}}}\label{Sage}
\logpage{[ 1, 1, 5 ]}
\hyperdef{L}{X7A9D29E187AA3F83}{}
{
  
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> ZZ := HomalgRingOfIntegersInSage( );
  <A homalg external ring residing in the CAS Sage>
   gap> Display( ZZ );
   Z
  gap> F2 := HomalgRingOfIntegersInSage( 2, ZZ );
  <A homalg external ring residing in the CAS Sage>
   gap> Display( F2 );
   GF(2)
\end{Verbatim}
 \texttt{F2 := HomalgRingOfIntegersInSage( 2 )} would launch another Sage. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> Z_4 := HomalgRingOfIntegersInSage( ZZ ) / 4;
  <A homalg residue class ring>
  gap> Display( Z_4 );
  Z/( 4 )
  gap> Q := HomalgFieldOfRationalsInSage( ZZ );
  <A homalg external ring residing in the CAS Sage>
   gap> Display( Q );
   Q
  gap> F2x := F2 * "x";
  <A homalg external ring residing in the CAS Sage>
   gap> Display( F2x );
   GF(2)[x]
  gap> Qx := Q * "x";
  <A homalg external ring residing in the CAS Sage>
   gap> Display( Qx );
   Q[x]
\end{Verbatim}
 }

 
\subsection{\textcolor{Chapter }{\textsf{Maple}}}\label{Maple}
\logpage{[ 1, 1, 6 ]}
\hyperdef{L}{X83E0B3C584764593}{}
{
  
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> ZZ := HomalgRingOfIntegersInMaple( );
  <A homalg external ring residing in the CAS Maple>
   gap> Display( ZZ );
   Z
  gap> F2 := HomalgRingOfIntegersInMaple( 2, ZZ );
  <A homalg external ring residing in the CAS Maple>
   gap> Display( F2 );
   GF(2)
\end{Verbatim}
 \texttt{F2 := HomalgRingOfIntegersInMaple( 2 )} would launch another Maple. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Example]
  gap> Z4 := HomalgRingOfIntegersInMaple( 4, ZZ );
  <A homalg external ring residing in the CAS Maple>
   gap> Display( Z4 );
   Z/4Z
  gap> Z_4 := HomalgRingOfIntegersInMaple( ZZ ) / 4;
  <A homalg residue class ring>
  gap> Display( Z_4 );
  Z/( 4 )
  gap> Q := HomalgFieldOfRationalsInMaple( ZZ );
  <A homalg external ring residing in the CAS Maple>
   gap> Display( Q );
   Q
  gap> F2xyz := F2 * "x,y,z";
  <A homalg external ring residing in the CAS Maple>
   gap> Display( F2xyz );
   GF(2)[x,y,z]
  gap> Qxyz := Q * "x,y,z";
  <A homalg external ring residing in the CAS Maple>
   gap> Display( Qxyz );
   Q[x,y,z]
\end{Verbatim}
 }

 }

 }

   
\chapter{\textcolor{Chapter }{Installation of the \textsf{RingsForHomalg} Package}}\label{install}
\logpage{[ 2, 0, 0 ]}
\hyperdef{L}{X7B7472BA86FD3177}{}
{
  To install this package just extract the package's archive file to the \textsf{GAP} \texttt{pkg} directory.

 By default the \textsf{RingsForHomalg} package is not automatically loaded by \textsf{GAP} when it is installed. You must load the package with \\
\\
 \texttt{LoadPackage( "RingsForHomalg" );} \\
\\
 before its functions become available.

 Please, send us an e-mail if you have any questions, remarks, suggestions,
etc. concerning this package. Also, we would be pleased to hear about
applications of this package. \\
\\
\\
 The authors.  }

  
\chapter{\textcolor{Chapter }{The Ring Table}}\label{ring table}
\logpage{[ 3, 0, 0 ]}
\hyperdef{L}{X7BE194BD79C972A3}{}
{
  
\section{\textcolor{Chapter }{An Example for a Ring Table - Singular}}\label{HomalgTable:Generic}
\logpage{[ 3, 1, 0 ]}
\hyperdef{L}{X7B7C37BD80727239}{}
{
  todo: introductory text, mention: transposed matrices, the macros, refer to
the philosophy 

\subsection{\textcolor{Chapter }{BasisOfRowModule (in the homalg table for Singular)}}
\logpage{[ 3, 1, 1 ]}\nobreak
\hyperdef{L}{X7CA9554E855D5032}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfRowModule({\slshape M})\index{BasisOfRowModule@\texttt{BasisOfRowModule}!in the homalg table for Singular}
\label{BasisOfRowModule:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{BasisOfRowModule} (\ref{BasisOfRowModule:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  BasisOfRowModule :=
    function( M )
      local N;
      
      N := HomalgVoidMatrix(
        "unknown_number_of_rows",
        NrColumns( M ),
        HomalgRing( M )
      );
      
      homalgSendBlocking( 
        [ "matrix ", N, " = BasisOfRowModule(", M, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.BasisOfModule
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfRowModule (Singular macro)}}
\logpage{[ 3, 1, 2 ]}\nobreak
\hyperdef{L}{X7A0EDA3284F0832B}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfRowModule({\slshape M})\index{BasisOfRowModule@\texttt{BasisOfRowModule}!Singular macro}
\label{BasisOfRowModule:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      BasisOfRowModule := "\n\
  proc BasisOfRowModule (matrix M)\n\
  {\n\
    return(std(M));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfColumnModule (in the homalg table for Singular)}}
\logpage{[ 3, 1, 3 ]}\nobreak
\hyperdef{L}{X7A8574FE7B4DCE59}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfColumnModule({\slshape M})\index{BasisOfColumnModule@\texttt{BasisOfColumnModule}!in the homalg table for Singular}
\label{BasisOfColumnModule:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{BasisOfColumnModule} (\ref{BasisOfColumnModule:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  BasisOfColumnModule :=
    function( M )
      local N;
      
      N := HomalgVoidMatrix(
        NrRows( M ),
        "unknown_number_of_columns",
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = BasisOfColumnModule(", M, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.BasisOfModule
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfColumnModule (Singular macro)}}
\logpage{[ 3, 1, 4 ]}\nobreak
\hyperdef{L}{X870A963687F2867F}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfColumnModule({\slshape M})\index{BasisOfColumnModule@\texttt{BasisOfColumnModule}!Singular macro}
\label{BasisOfColumnModule:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      BasisOfColumnModule := "\n\
  proc BasisOfColumnModule (matrix M)\n\
  {\n\
    return(Involution(BasisOfRowModule(Involution(M))));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroRows (in the homalg table for Singular)}}
\logpage{[ 3, 1, 5 ]}\nobreak
\hyperdef{L}{X7834682C822FC188}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroRows({\slshape A, B})\index{DecideZeroRows@\texttt{DecideZeroRows}!in the homalg table for Singular}
\label{DecideZeroRows:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{DecideZeroRows} (\ref{DecideZeroRows:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  DecideZeroRows :=
    function( A, B )
      local N;
      
      N := HomalgVoidMatrix(
        NrRows( A ),
        NrColumns( A ),
        HomalgRing( A )
      );
      
      homalgSendBlocking( 
        [ "matrix ", N, " = DecideZeroRows(", A, B, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.DecideZero
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroRows (Singular macro)}}
\logpage{[ 3, 1, 6 ]}\nobreak
\hyperdef{L}{X7A7ADD857AAD8158}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroRows({\slshape A, B})\index{DecideZeroRows@\texttt{DecideZeroRows}!Singular macro}
\label{DecideZeroRows:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      DecideZeroRows := "\n\
  proc DecideZeroRows (matrix A, matrix B)\n\
  {\n\
    return(reduce(A,B));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroColumns (in the homalg table for Singular)}}
\logpage{[ 3, 1, 7 ]}\nobreak
\hyperdef{L}{X8721416787B06D9B}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroColumns({\slshape A, B})\index{DecideZeroColumns@\texttt{DecideZeroColumns}!in the homalg table for Singular}
\label{DecideZeroColumns:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{DecideZeroColumns} (\ref{DecideZeroColumns:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  DecideZeroColumns :=
    function( A, B )
      local N;
      
      N := HomalgVoidMatrix(
        NrRows( A ),
        NrColumns( A ),
        HomalgRing( A )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = DecideZeroColumns(", A, B, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.DecideZero
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroColumns (Singular macro)}}
\logpage{[ 3, 1, 8 ]}\nobreak
\hyperdef{L}{X781FC1367F5A2EB7}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroColumns({\slshape A, B})\index{DecideZeroColumns@\texttt{DecideZeroColumns}!Singular macro}
\label{DecideZeroColumns:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      DecideZeroColumns := "\n\
  proc DecideZeroColumns (matrix A, matrix B)\n\
  {\n\
    return(Involution(reduce(Involution(A),Involution(B))));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{SyzygiesGeneratorsOfRows (in the homalg table for Singular)}}
\logpage{[ 3, 1, 9 ]}\nobreak
\hyperdef{L}{X85D2A3EA86796DD5}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{SyzygiesGeneratorsOfRows({\slshape M})\index{SyzygiesGeneratorsOfRows@\texttt{SyzygiesGeneratorsOfRows}!in the homalg table for Singular}
\label{SyzygiesGeneratorsOfRows:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{SyzygiesGeneratorsOfRows} (\ref{SyzygiesGeneratorsOfRows:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  SyzygiesGeneratorsOfRows :=
    function( M )
      local N;
      
      N := HomalgVoidMatrix(
        "unknown_number_of_rows",
        NrRows( M ),
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = SyzygiesGeneratorsOfRows(", M, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.SyzygiesGenerators
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{SyzygiesGeneratorsOfRows (Singular macro)}}
\logpage{[ 3, 1, 10 ]}\nobreak
\hyperdef{L}{X78551C36859F7524}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{SyzygiesGeneratorsOfRows({\slshape M})\index{SyzygiesGeneratorsOfRows@\texttt{SyzygiesGeneratorsOfRows}!Singular macro}
\label{SyzygiesGeneratorsOfRows:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      SyzygiesGeneratorsOfRows := "\n\
  proc SyzygiesGeneratorsOfRows (matrix M)\n\
  {\n\
    return(SyzForHomalg(M));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{SyzygiesGeneratorsOfColumns (in the homalg table for Singular)}}
\logpage{[ 3, 1, 11 ]}\nobreak
\hyperdef{L}{X834F1AF179AE3F7F}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{SyzygiesGeneratorsOfColumns({\slshape M})\index{SyzygiesGeneratorsOfColumns@\texttt{SyzygiesGeneratorsOfColumns}!in the homalg table for Singular}
\label{SyzygiesGeneratorsOfColumns:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{SyzygiesGeneratorsOfColumns} (\ref{SyzygiesGeneratorsOfColumns:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  SyzygiesGeneratorsOfColumns :=
    function( M )
      local N;
      
      N := HomalgVoidMatrix(
        NrColumns( M ),
        "unknown_number_of_columns",
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = SyzygiesGeneratorsOfColumns(", M, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.SyzygiesGenerators
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{SyzygiesGeneratorsOfColumns (Singular macro)}}
\logpage{[ 3, 1, 12 ]}\nobreak
\hyperdef{L}{X7BFA32BA80762292}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{SyzygiesGeneratorsOfColumns({\slshape M})\index{SyzygiesGeneratorsOfColumns@\texttt{SyzygiesGeneratorsOfColumns}!Singular macro}
\label{SyzygiesGeneratorsOfColumns:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      SyzygiesGeneratorsOfColumns := "\n\
  proc SyzygiesGeneratorsOfColumns (matrix M)\n\
  {\n\
    return(Involution(SyzForHomalg(Involution(M))));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfRowsCoeff (in the homalg table for Singular)}}
\logpage{[ 3, 1, 13 ]}\nobreak
\hyperdef{L}{X7F4661FD863E3EB4}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfRowsCoeff({\slshape M, T})\index{BasisOfRowsCoeff@\texttt{BasisOfRowsCoeff}!in the homalg table for Singular}
\label{BasisOfRowsCoeff:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{BasisOfRowsCoeff} (\ref{BasisOfRowsCoeff:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  BasisOfRowsCoeff :=
    function( M, T )
      local v, N;
      
      v := homalgStream( HomalgRing( M ) )!.variable_name;
      
      N := HomalgVoidMatrix(
        "unknown_number_of_rows",
        NrColumns( M ),
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [
          "list ", v, "l=BasisOfRowsCoeff(", M, "); ",
          "matrix ", N, " = ", v, "l[1]; ",
          "matrix ", T, " = ", v, "l[2]"
        ],
        "need_command",
        HOMALG_IO.Pictograms.BasisCoeff
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfRowsCoeff (Singular macro)}}
\logpage{[ 3, 1, 14 ]}\nobreak
\hyperdef{L}{X874402C08793EDAD}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfRowsCoeff({\slshape M, T})\index{BasisOfRowsCoeff@\texttt{BasisOfRowsCoeff}!Singular macro}
\label{BasisOfRowsCoeff:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      BasisOfRowsCoeff := "\n\
  proc BasisOfRowsCoeff (matrix M)\n\
  {\n\
    matrix B = std(M);\n\
    matrix T = lift(M,B);\n\
    list l = B,T;\n\
    return(l)\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfColumnsCoeff (in the homalg table for Singular)}}
\logpage{[ 3, 1, 15 ]}\nobreak
\hyperdef{L}{X796A404D7A059D47}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfColumnsCoeff({\slshape M, T})\index{BasisOfColumnsCoeff@\texttt{BasisOfColumnsCoeff}!in the homalg table for Singular}
\label{BasisOfColumnsCoeff:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{BasisOfColumnsCoeff} (\ref{BasisOfColumnsCoeff:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  BasisOfColumnsCoeff :=
    function( M, T )
      local v, N;
      
      v := homalgStream( HomalgRing( M ) )!.variable_name;
      
      N := HomalgVoidMatrix(
        NrRows( M ),
        "unknown_number_of_columns",
        HomalgRing( M )
      );
      
      homalgSendBlocking( 
        [
          "list ", v, "l=BasisOfColumnsCoeff(", M, "); ",
          "matrix ", N, " = ", v, "l[1]; ",
          "matrix ", T, " = ", v, "l[2]"
        ],
        "need_command",
        HOMALG_IO.Pictograms.BasisCoeff
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{BasisOfColumnsCoeff (Singular macro)}}
\logpage{[ 3, 1, 16 ]}\nobreak
\hyperdef{L}{X7A404EC486BAD561}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{BasisOfColumnsCoeff({\slshape M, T})\index{BasisOfColumnsCoeff@\texttt{BasisOfColumnsCoeff}!Singular macro}
\label{BasisOfColumnsCoeff:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      BasisOfColumnsCoeff := "\n\
  proc BasisOfColumnsCoeff (matrix M)\n\
  {\n\
    list l = BasisOfRowsCoeff(Involution(M));\n\
    matrix B = l[1];\n\
    matrix T = l[2];\n\
    l = Involution(B),Involution(T);\n\
    return(l);\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroRowsEffectively (in the homalg table for Singular)}}
\logpage{[ 3, 1, 17 ]}\nobreak
\hyperdef{L}{X8009817D78CF032B}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroRowsEffectively({\slshape A, B, T})\index{DecideZeroRowsEffectively@\texttt{DecideZeroRowsEffectively}!in the homalg table for Singular}
\label{DecideZeroRowsEffectively:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{DecideZeroRowsEffectively} (\ref{DecideZeroRowsEffectively:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  DecideZeroRowsEffectively :=
    function( A, B, T )
      local v, N;
      
      v := homalgStream( HomalgRing( A ) )!.variable_name;
      
      N := HomalgVoidMatrix(
        NrRows( A ),
        NrColumns( A ),
        HomalgRing( A )
      );
      
      homalgSendBlocking(
        [
          "list ", v, "l=DecideZeroRowsEffectively(", A, B, "); ",
          "matrix ", N, " = ", v, "l[1]; ",
          "matrix ", T, " = ", v, "l[2]"
        ],
        "need_command",
        HOMALG_IO.Pictograms.DecideZeroEffectively
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroRowsEffectively (Singular macro)}}
\logpage{[ 3, 1, 18 ]}\nobreak
\hyperdef{L}{X80A26CC279614874}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroRowsEffectively({\slshape A, B, T})\index{DecideZeroRowsEffectively@\texttt{DecideZeroRowsEffectively}!Singular macro}
\label{DecideZeroRowsEffectively:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      DecideZeroRowsEffectively := "\n\
  proc DecideZeroRowsEffectively (matrix A, matrix B)\n\
  {\n\
    matrix M = reduce(A,B);\n\
    matrix T = lift(B,M-A);\n\
    list l = M,T;\n\
    return(l);\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroColumnsEffectively (in the homalg table for Singular)}}
\logpage{[ 3, 1, 19 ]}\nobreak
\hyperdef{L}{X833A271E83F7B7E6}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroColumnsEffectively({\slshape A, B, T})\index{DecideZeroColumnsEffectively@\texttt{DecideZeroColumnsEffectively}!in the homalg table for Singular}
\label{DecideZeroColumnsEffectively:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{DecideZeroColumnsEffectively} (\ref{DecideZeroColumnsEffectively:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  DecideZeroColumnsEffectively :=
    function( A, B, T )
      local v, N;
      
      v := homalgStream( HomalgRing( A ) )!.variable_name;
      
      N := HomalgVoidMatrix(
        NrRows( A ),
        NrColumns( A ),
        HomalgRing( A )
      );
      
      homalgSendBlocking(
        [
          "list ", v, "l=DecideZeroColumnsEffectively(", A, B, "); ",
          "matrix ", N, " = ", v, "l[1]; ",
          "matrix ", T, " = ", v, "l[2]"
        ],
        "need_command",
        HOMALG_IO.Pictograms.DecideZeroEffectively
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{DecideZeroColumnsEffectively (Singular macro)}}
\logpage{[ 3, 1, 20 ]}\nobreak
\hyperdef{L}{X7F239DE47B7EEA55}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{DecideZeroColumnsEffectively({\slshape A, B, T})\index{DecideZeroColumnsEffectively@\texttt{DecideZeroColumnsEffectively}!Singular macro}
\label{DecideZeroColumnsEffectively:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      DecideZeroColumnsEffectively := "\n\
  proc DecideZeroColumnsEffectively (matrix A, matrix B)\n\
  {\n\
    list l = DecideZeroRowsEffectively(Involution(A),Involution(B));\n\
    matrix B = l[1];\n\
    matrix T = l[2];\n\
    l = Involution(B),Involution(T);\n\
    return(l);\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{RelativeSyzygiesGeneratorsOfRows (in the homalg table for Singular)}}
\logpage{[ 3, 1, 21 ]}\nobreak
\hyperdef{L}{X87131F9182FD3B1C}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{RelativeSyzygiesGeneratorsOfRows({\slshape M, M2})\index{RelativeSyzygiesGeneratorsOfRows@\texttt{RelativeSyzygiesGeneratorsOfRows}!in the homalg table for Singular}
\label{RelativeSyzygiesGeneratorsOfRows:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{RelativeSyzygiesGeneratorsOfRows} (\ref{RelativeSyzygiesGeneratorsOfRows:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  RelativeSyzygiesGeneratorsOfRows :=
    function( M, M2 )
      local N;
      
      N := HomalgVoidMatrix(
        "unknown_number_of_rows",
        NrRows( M ),
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = RelativeSyzygiesGeneratorsOfRows(", M, M2, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.SyzygiesGenerators
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{RelativeSyzygiesGeneratorsOfRows (Singular macro)}}
\logpage{[ 3, 1, 22 ]}\nobreak
\hyperdef{L}{X7BF27670874C5CE1}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{RelativeSyzygiesGeneratorsOfRows({\slshape M, M2})\index{RelativeSyzygiesGeneratorsOfRows@\texttt{RelativeSyzygiesGeneratorsOfRows}!Singular macro}
\label{RelativeSyzygiesGeneratorsOfRows:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      RelativeSyzygiesGeneratorsOfRows := "\n\
  proc RelativeSyzygiesGeneratorsOfRows (matrix M1, matrix M2)\n\
  {\n\
    return(std(modulo(M1, M2)));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{RelativeSyzygiesGeneratorsOfColumns (in the homalg table for Singular)}}
\logpage{[ 3, 1, 23 ]}\nobreak
\hyperdef{L}{X7FEB3B37852B72D4}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{RelativeSyzygiesGeneratorsOfColumns({\slshape M, M2})\index{RelativeSyzygiesGeneratorsOfColumns@\texttt{RelativeSyzygiesGeneratorsOfColumns}!in the homalg table for Singular}
\label{RelativeSyzygiesGeneratorsOfColumns:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{RelativeSyzygiesGeneratorsOfColumns} (\ref{RelativeSyzygiesGeneratorsOfColumns:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  RelativeSyzygiesGeneratorsOfColumns :=
    function( M, M2 )
      local N;
      
      N := HomalgVoidMatrix(
        NrColumns( M ),
        "unknown_number_of_columns",
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = RelativeSyzygiesGeneratorsOfColumns(", M, M2, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.SyzygiesGenerators
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{RelativeSyzygiesGeneratorsOfColumns (Singular macro)}}
\logpage{[ 3, 1, 24 ]}\nobreak
\hyperdef{L}{X78370E58780C91C2}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{RelativeSyzygiesGeneratorsOfColumns({\slshape M, M2})\index{RelativeSyzygiesGeneratorsOfColumns@\texttt{RelativeSyzygiesGeneratorsOfColumns}!Singular macro}
\label{RelativeSyzygiesGeneratorsOfColumns:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      RelativeSyzygiesGeneratorsOfColumns := "\n\
  proc RelativeSyzygiesGeneratorsOfColumns (matrix M1, matrix M2)\n\
  {\n\
    return(Involution(RelativeSyzygiesGeneratorsOfRows(Involution(M1),Involution(M2))));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{ReducedSyzygiesGeneratorsOfRows (in the homalg table for Singular)}}
\logpage{[ 3, 1, 25 ]}\nobreak
\hyperdef{L}{X7E533B0A8392EBC6}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{ReducedSyzygiesGeneratorsOfRows({\slshape M})\index{ReducedSyzygiesGeneratorsOfRows@\texttt{ReducedSyzygiesGeneratorsOfRows}!in the homalg table for Singular}
\label{ReducedSyzygiesGeneratorsOfRows:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{ReducedSyzygiesGeneratorsOfRows} (\ref{ReducedSyzygiesGeneratorsOfRows:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  ReducedSyzygiesGeneratorsOfRows :=
    function( M )
      local N;
      
      N := HomalgVoidMatrix(
        "unknown_number_of_rows",
        NrRows( M ),
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = ReducedSyzygiesGeneratorsOfRows(", M, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.SyzygiesGenerators
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{ReducedSyzygiesGeneratorsOfRows (Singular macro)}}
\logpage{[ 3, 1, 26 ]}\nobreak
\hyperdef{L}{X7A6E97FA7F1FF73D}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{ReducedSyzygiesGeneratorsOfRows({\slshape M})\index{ReducedSyzygiesGeneratorsOfRows@\texttt{ReducedSyzygiesGeneratorsOfRows}!Singular macro}
\label{ReducedSyzygiesGeneratorsOfRows:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      ReducedSyzForHomalg := "\n\
  proc ReducedSyzForHomalg (matrix M)\n\
  {\n\
    return(matrix(nres(M,2)[2]));\n\
  }\n\n",
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{ReducedSyzygiesGeneratorsOfColumns (in the homalg table for Singular)}}
\logpage{[ 3, 1, 27 ]}\nobreak
\hyperdef{L}{X7FF049FA85A2C82E}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{ReducedSyzygiesGeneratorsOfColumns({\slshape M})\index{ReducedSyzygiesGeneratorsOfColumns@\texttt{ReducedSyzygiesGeneratorsOfColumns}!in the homalg table for Singular}
\label{ReducedSyzygiesGeneratorsOfColumns:in the homalg table for Singular}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 This is the entry of the \textsf{homalg} table, which calls the corresponding macro \texttt{ReducedSyzygiesGeneratorsOfColumns} (\ref{ReducedSyzygiesGeneratorsOfColumns:Singular macro}) inside the computer algebra system. 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
  ReducedSyzygiesGeneratorsOfColumns :=
    function( M )
      local N;
      
      N := HomalgVoidMatrix(
        NrColumns( M ),
        "unknown_number_of_columns",
        HomalgRing( M )
      );
      
      homalgSendBlocking(
        [ "matrix ", N, " = ReducedSyzygiesGeneratorsOfColumns(", M, ")" ],
        "need_command",
        HOMALG_IO.Pictograms.SyzygiesGenerators
      );
      
      return N;
      
    end,
\end{Verbatim}
 }

 

\subsection{\textcolor{Chapter }{ReducedSyzygiesGeneratorsOfColumns (Singular macro)}}
\logpage{[ 3, 1, 28 ]}\nobreak
\hyperdef{L}{X7AF938828299812C}{}
{\noindent\textcolor{FuncColor}{$\Diamond$\ \texttt{ReducedSyzygiesGeneratorsOfColumns({\slshape M})\index{ReducedSyzygiesGeneratorsOfColumns@\texttt{ReducedSyzygiesGeneratorsOfColumns}!Singular macro}
\label{ReducedSyzygiesGeneratorsOfColumns:Singular macro}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }




 
\begin{Verbatim}[fontsize=\small,frame=single,label=Code]
      ReducedSyzygiesGeneratorsOfRows := "\n\
  proc ReducedSyzygiesGeneratorsOfRows (matrix M)\n\
  {\n\
    return(ReducedSyzForHomalg(M));\n\
  }\n\n",
\end{Verbatim}
 }

 }

 }

 \def\bibname{References\logpage{[ "Bib", 0, 0 ]}
\hyperdef{L}{X7A6F98FD85F02BFE}{}
}

\bibliographystyle{alpha}
\bibliography{RingsForHomalgBib.xml}

\def\indexname{Index\logpage{[ "Ind", 0, 0 ]}
\hyperdef{L}{X83A0356F839C696F}{}
}


\printindex

\newpage
\immediate\write\pagenrlog{["End"], \arabic{page}];}
\immediate\closeout\pagenrlog
\end{document}
