001/*
002 * $Id: GroebnerBaseF5zSigSeqIter.java 5476 2016-03-25 17:57:05Z kredel $
003 */
004
005package edu.jas.gb;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import org.apache.log4j.Logger;
012
013import edu.jas.poly.ExpVector;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.structure.RingElem;
016
017
018/**
019 * Groebner Base F5z signature based sequential iterative algorithm. Implements
020 * Groebner bases.
021 * @param <C> coefficient type
022 * @author Heinz Kredel
023 * 
024 * @see edu.jas.application.GBAlgorithmBuilder
025 * @see edu.jas.gbufd.GBFactory
026 */
027
028public class GroebnerBaseF5zSigSeqIter<C extends RingElem<C>> extends GroebnerBaseSigSeqIter<C> {
029
030
031    private static final Logger logger = Logger.getLogger(GroebnerBaseF5zSigSeqIter.class);
032
033
034    //private static final boolean debug = logger.isDebugEnabled();
035
036
037    /**
038     * Constructor.
039     */
040    public GroebnerBaseF5zSigSeqIter() {
041        this(new SigReductionSeq<C>());
042    }
043
044
045    /**
046     * Constructor.
047     * @param red Reduction engine
048     */
049    public GroebnerBaseF5zSigSeqIter(SigReductionSeq<C> red) {
050        super(red);
051    }
052
053
054    /**
055     * Top normalform.
056     * @param A polynomial.
057     * @param F polynomial list.
058     * @param G polynomial list.
059     * @return nf(A) with respect to F and G.
060     */
061    @Override
062    SigPoly<C> sigNormalform(List<GenPolynomial<C>> F, List<SigPoly<C>> G, SigPoly<C> A) {
063        return sred.sigSemiNormalform(F, G, A);
064    }
065
066
067    /**
068     * Prune total pair list P.
069     * @param P pair list.
070     * @param syz list of exponent vectors representing syzygies.
071     * @return updated pair list. <b>Note:<b> stores polynomials not only
072     *         indices.
073     */
074    @Override
075    List<SigPair<C>> pruneP(List<SigPair<C>> P, List<ExpVector> syz) {
076        List<SigPair<C>> res = new ArrayList<SigPair<C>>(P.size());
077        for (SigPair<C> p : P) {
078            ExpVector f = p.sigma.leadingExpVector();
079            if (f == null) {
080                continue;
081            }
082            boolean div = false;
083            for (ExpVector e : syz) {
084                if (f.multipleOf(e)) {
085                    div = true;
086                    break;
087                }
088            }
089            if (div) {
090                continue;
091            }
092            res.add(p);
093        }
094        return res;
095    }
096
097
098    /**
099     * Prune pair list of degree d.
100     * @param S pair list.
101     * @param syz list of exponent vectors representing syzygies.
102     * @param done list of treated polynomials.
103     * @param G polynomial with signature list.
104     * @return updated pair list.
105     */
106    @Override
107    List<SigPair<C>> pruneS(List<SigPair<C>> S, List<ExpVector> syz, List<SigPoly<C>> done, List<SigPoly<C>> G) {
108        List<SigPair<C>> res = new ArrayList<SigPair<C>>(S.size());
109        for (SigPair<C> p : S) {
110            if (p.sigma.isZERO()) {
111                continue;
112            }
113            ExpVector f = p.sigma.leadingExpVector();
114            boolean div = false;
115            for (ExpVector e : syz) {
116                if (f.multipleOf(e)) {
117                    div = true;
118                    break;
119                }
120            }
121            if (div) {
122                continue;
123            }
124            if (p.pi.sigma.isZERO()) {
125                logger.info("pruneS, p.pi.sigma = 0");
126                res.add(p);
127                continue;
128            }
129            ExpVector fi = p.pi.poly.leadingExpVector();
130            ExpVector fj = p.pj.poly.leadingExpVector();
131            ExpVector fu = fi.lcm(fj).subtract(fi);
132            f = p.pi.sigma.leadingExpVector();
133            fu = fu.sum(f);
134            div = false;
135            for (SigPoly<C> q : done) {
136                ExpVector e = q.sigma.leadingExpVector();
137                if (e == null) {
138                    continue;
139                }
140                if (fu.multipleOf(e)) {
141                    if (q.sigma.compareTo(p.pi.sigma) > 0) {
142                        div = true;
143                        break;
144                    }
145                }
146            }
147            if (div) {
148                continue;
149            }
150            res.add(p);
151            logger.debug("added p = " + p.sigma);
152        }
153        return res;
154    }
155
156
157    /**
158     * Initializes syzygy list.
159     * @param F polynomial list.
160     * @param G polynomial with signature list.
161     * @return list of exponent vectors representing syzygies.
162     */
163    @Override
164    List<ExpVector> initializeSyz(List<GenPolynomial<C>> F, List<SigPoly<C>> G) {
165        List<ExpVector> P = new ArrayList<ExpVector>();
166        for (GenPolynomial<C> p : F) {
167            if (p.isZERO()) {
168                continue;
169            }
170            P.add(p.leadingExpVector());
171        }
172        return P;
173    }
174
175
176    /**
177     * Update syzygy list.
178     * @param syz list of exponent vectors representing syzygies.
179     * @param r polynomial. <b>Note:</b> szy is modified to represent updated
180     *            list of exponent vectors.
181     */
182    @Override
183    void updateSyz(List<ExpVector> syz, SigPoly<C> r) {
184        if (r.poly.isZERO() && !r.sigma.isZERO()) {
185            //logger.info("update_syz, sigma = " + r.sigma);
186            syz.add(r.sigma.leadingExpVector());
187        }
188        return;
189    }
190
191}