/*
 * $Id$
 */

package edu.jas.gbmod;

import java.util.List;
import java.io.Serializable;

import edu.jas.poly.GenSolvablePolynomial;
import edu.jas.poly.ModuleList;
import edu.jas.poly.PolynomialList;
import edu.jas.structure.RingElem;



/**
 * Syzygy interface for solvable polynomials.
 * Defines syzygy computations and tests.
 * @param  coefficient type
 * @author Heinz Kredel
 */

public interface SolvableSyzygy> extends Serializable {


    /**
     * Left syzygy for left Groebner base.
     * @param F a Groebner base.
     * @return leftSyz(F), a basis for the left module of syzygies for F.
     */
    public List>> 
           leftZeroRelations(List> F);


    /**
     * Left syzygy for left Groebner base.
     * @param modv number of module variables.
     * @param F a Groebner base.
     * @return leftSyz(F), a basis for the left module of syzygies for F.
     */
    public List>>
           leftZeroRelations(int modv, 
                             List> F);


    /**
     * Left syzygy for left module Groebner base.
     * @param M a Groebner base.
     * @return leftSyz(M), a basis for the left module of syzygies for M.
     */
    public ModuleList 
           leftZeroRelations(ModuleList M);


    /**
     * Test if left syzygy.
     * @param Z list of sysygies.
     * @param F a polynomial list.
     * @return true, if Z is a list of left syzygies for F, else false.
     */
    public boolean 
           isLeftZeroRelation(List>> Z, 
                              List> F);


    /**
     * Test if right syzygy.
     * @param Z list of sysygies.
     * @param F a polynomial list.
     * @return true, if Z is a list of right syzygies for F, else false.
     */
    public boolean 
           isRightZeroRelation(List>> Z, 
                               List> F);


    /**
     * Test if left sysygy of modules
     * @param Z list of sysygies.
     * @param F a module list.
     * @return true, if Z is a list of left syzygies for F, else false.
     */
    public boolean 
           isLeftZeroRelation(ModuleList Z, 
                              ModuleList F);


    /**
     * Test if right sysygy of modules
     * @param Z list of sysygies.
     * @param F a module list.
     * @return true, if Z is a list of right syzygies for F, else false.
     */
    public boolean 
           isRightZeroRelation(ModuleList Z, 
                               ModuleList F);


    /**
     * Resolution of a module.
     * Only with direct GBs.
     * @param M a module list of a Groebner basis.
     * @return a resolution of M.
     */
    public List> 
           resolution(ModuleList M);


    /**
     * Resolution of a polynomial list.
     * Only with direct GBs.
     * @param F a polynomial list of a Groebner basis.
     * @return a resolution of F.
     */
    public List // |SolvResPolPart> 
           resolution(PolynomialList F);


    /**
     * Resolution of a module.
     * @param M a module list of an arbitrary basis.
     * @return a resolution of M.
     */
    public List> 
           resolutionArbitrary(ModuleList M);


    /**
     * Resolution of a polynomial list.
     * @param F a polynomial list of an arbitrary basis.
     * @return a resolution of F.
     */
    public List // |SolvResPolPart> 
           resolutionArbitrary(PolynomialList F);


    /**
     * Left syzygy module from arbitrary base.
     * @param F a solvable polynomial list.
     * @return syz(F), a basis for the module of left syzygies for F.
     */
    public List>> 
           leftZeroRelationsArbitrary(List> F);


    /**
     * Left syzygy module from arbitrary base.
     * @param modv number of module variables.
     * @param F a solvable polynomial list.
     * @return syz(F), a basis for the module of left syzygies for F.
     */
    public List>> 
           leftZeroRelationsArbitrary(int modv, List> F);


    /**
     * Left syzygy for arbitrary left module base.
     * @param M an arbitrary base.
     * @return leftSyz(M), a basis for the left module of syzygies for M.
     */
    public ModuleList 
           leftZeroRelationsArbitrary(ModuleList M);


    /**
     * Right syzygy module from arbitrary base.
     * @param F a solvable polynomial list.
     * @return syz(F), a basis for the module of right syzygies for F.
     */
    public List>> 
           rightZeroRelationsArbitrary(List> F);


    /**
     * Right syzygy module from arbitrary base.
     * @param modv number of module variables.
     * @param F a solvable polynomial list.
     * @return syz(F), a basis for the module of right syzygies for F.
     */
    public List>> 
           rightZeroRelationsArbitrary(int modv, List> F);

}