<p>When applying a noncommutative rewriting system we conventionally apply a rule <span class="SimpleMath">\(\ell \to r\)</span> to a word <span class="SimpleMath">\(w\)</span> if and only if <span class="SimpleMath">\(w\)</span> has the form <span class="SimpleMath">\(w = u \ell v\)</span>, where <span class="SimpleMath">\(u\)</span> or <span class="SimpleMath">\(v\)</span> may be the empty word <span class="SimpleMath">\(\epsilon\)</span>. Then <span class="SimpleMath">\(w\)</span> reduces to <span class="SimpleMath">\(urv\)</span>.</p>
<p>An <em>involutive monoid rewriting system</em> <span class="SimpleMath">\(I\)</span> will restrict these conventional reductions by imposing a limitation on the letters allowed in <span class="SimpleMath">\(u\)</span> and <span class="SimpleMath">\(v\)</span>. Sets <span class="SimpleMath">\(M^L_I(w)\)</span>, the <em>left multiplicative variables</em> for <span class="SimpleMath">\(w\)</span>, and <span class="SimpleMath">\(M^R_I(w)\)</span>, the <em>right multiplicative variables</em> for <span class="SimpleMath">\(w\)</span>, are defined by <span class="SimpleMath">\(I\)</span>.</p>
<p>An <em>involutive division</em> <span class="SimpleMath">\(\mathbb{I}\)</span> is a procedure for determining, given an arbitrary set of monomials <span class="SimpleMath">\(W\)</span>, sets of left and right multiplicative letters <span class="SimpleMath">\(M^L_I(\ell,W)\)</span> and <span class="SimpleMath">\(M^R_I(\ell,W)\)</span> for any <span class="SimpleMath">\(\ell \in W\)</span>. Then set <span class="SimpleMath">\(M^L_I(W) = \{M^L_I(\ell,W) \mid \ell \in W\}\)</span> and <span class="SimpleMath">\(M^R_I(W) = \{M^R_I(\ell,W) \mid \ell \in W\}\)</span>.</p>
<p>An <em>involutive rewriting system</em> <span class="SimpleMath">\(I\)</span> is <em>based on <spanclass="SimpleMath">\(\mathbb{I}\)</span></em> if <span class="SimpleMath">\(M^L_I(W)\)</span> and <span class="SimpleMath">\(M^R_I(W)\)</span> are determined using <span class="SimpleMath">\(\mathbb{I}\)</span>, in which case we may write <span class="SimpleMath">\(M^L_{\mathbb{I}}(W)\)</span> and <span class="SimpleMath">\(M^R_{\mathbb{I}}(W)\)</span> for these sets of letters.</p>
<p>A word <span class="SimpleMath">\(\ell\)</span> is an <em>involutive divisor</em> of <span class="SimpleMath">\(w\)</span>, written <span class="SimpleMath">\(\ell \mid_I w\)</span>, if</p>
<ul>
<li><p><span class="SimpleMath">\(w = u \ell v\)</span>;</p>
</li>
<li><p>either <span class="SimpleMath">\(u = \epsilon\)</span>, or the <em>last</em> letter of <span class="SimpleMath">\(u\)</span> is <em>left</em> multiplicative for <span class="SimpleMath">\(\ell\)</span>;</p>
</li>
<li><p>and either <span class="SimpleMath">\(v = \epsilon\)</span>, or the <em>first</em> letter of <span class="SimpleMath">\(v\)</span> is <em>right</em> multiplicative for <span class="SimpleMath">\(\ell\)</span>.</p>
</li>
</ul>
<p>When this is the case, <span class="SimpleMath">\(w\)</span> <em>involutively reduces</em> to <span class="SimpleMath">\(urv\)</span> by the rule <span class="SimpleMath">\(\ell \to r\)</span>.</p>
<p>For example, let <span class="SimpleMath">\(S = rws(\{x,y,z\},~ \{xy \to z,~ yz \to x\})\)</span>, so that <span class="SimpleMath">\(W = \{xy,yz\}\)</span>. Choose left and right multiplicative variables as shown in the following table:</p>
<p>We consider reductions of <span class="SimpleMath">\(w = xyzx\)</span>. Conventionally, both rules may be used, giving reductions <span class="SimpleMath">\(z^2x\)</span> and <span class="SimpleMath">\(x^3\)</span> respectively. Involutively, we see that <span class="SimpleMath">\(xy \mid_I xyzx\)</span> because <span class="SimpleMath">\(z\)</span> is right multiplicative for <span class="SimpleMath">\(xy\)</span>, but <span class="SimpleMath">\(yz \not{\mid}_I~ xyzx\)</span> because <span class="SimpleMath">\(x\)</span> is left nonmultiplicative for <span class="SimpleMath">\(yz\)</span>. Thus the only involutive reduction is <span class="SimpleMath">\(xyzx \to_I z^2x\)</span>.</p>
<p>If an involutive division <span class="SimpleMath">\(\mathbb{I}\)</span> determines the left and right multiplicative variables for a word <span class="SimpleMath">\(\ell \in W\)</span> <em>independently</em> of the set <span class="SimpleMath">\(W\)</span>, then the division is known as a <em>global involutive division</em>. Otherwise <span class="SimpleMath">\(\mathbb{I}\)</span> is a <em>local involutive division</em>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LeftDivision</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Given a word <span class="SimpleMath">\(w\)</span>, the <em>left division</em> <span class="SimpleMath">\(\triangleleft\)</span> assigns all letters to be left multiplicative for <span class="SimpleMath">\(w\)</span>, and all letters to be right nonmultiplicative for <span class="SimpleMath">\(w\)</span>. The example is taken from Example 5.5.12 in the thesis <a href="chapBib_mj.html#biBgareth-thesis">[Eva05]</a>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RightDivision</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Given a word <span class="SimpleMath">\(w\)</span>, the <em>right division</em> <span class="SimpleMath">\(\triangleright\)</span> assigns all letters to be left nonmultiplicative for <span class="SimpleMath">\(w\)</span>, and all letters to be right multiplicative for <span class="SimpleMath">\(w\)</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LeftOverlapDivision</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Let <span class="SimpleMath">\(W = \{w_1, \ldots, w_m\}\)</span>. The <em>left overlap division</em> <span class="SimpleMath">\(\mathbb{L}\)</span> assumes, to begin with, that all letters are left and right multiplicative for every <span class="SimpleMath">\(w_i\)</span>. It then assigns some letters to be right nonmultiplicative as follows.</p>
<ul>
<li><p>Suppose <span class="SimpleMath">\(w_j \in W\)</span> is a <em>subword</em>, but not a suffix, of a (different) word <span class="SimpleMath">\(w_i \in W\)</span>. Then, for some <span class="SimpleMath">\(k\)</span>, we have <span class="SimpleMath">\(w_j =\)</span> Subword(<span class="SimpleMath">\(w_i,k,k+deg(w_j)-1\)</span>). Assign the letter in position <span class="SimpleMath">\(k+deg(w_j) \in w_i\)</span> to be right nonmultiplicative for <span class="SimpleMath">\(w_j\)</span>.</p>
</li>
<li><p>Suppose a proper <em>prefix</em> of <span class="SimpleMath">\(w_i\)</span> is equal to a proper <em>suffix</em> of a (not neccessarily different) <span class="SimpleMath">\(w_j\)</span>, and that <span class="SimpleMath">\(w_i\)</span> is not a proper subword of <span class="SimpleMath">\(w_j\)</span>, or vice versa. Then, for some <span class="SimpleMath">\(k\)</span>, we have Prefix(<span class="SimpleMath">\(w_i,k\)</span>) = Suffix(<span class="SimpleMath">\(w_j,k\)</span>). Assign the letter in position <span class="SimpleMath">\(k+1\)</span> in <span class="SimpleMath">\(w_i\)</span> to be right nonmultiplicative for <span class="SimpleMath">\(w_j\)</span>.</p>
</li>
</ul>
<p>Fox example, consider the rewriting system with rules <span class="SimpleMath">\(\{ab^2 \to b,~ ba^2 \to a\}\)</span>, so that the leading monomials are <span class="SimpleMath">\(\{u=ab^2, v=ba^2\}\)</span>. Neither monomial is a subword of the other, so the first rule above does not apply. Since Prefix(<span class="SimpleMath">\(v,1) = b =\)</span> Suffix(<span class="SimpleMath">\(u,1\)</span>), then <span class="SimpleMath">\(v[2]=a\)</span> is assigned to be right nonmulitplicative for <span class="SimpleMath">\(u\)</span>. By symmetry, <span class="SimpleMath">\(u[2]=b\)</span> is assigned to be right nonmulitplicative for <span class="SimpleMath">\(v\)</span>. The resulting sets are shown in the following table.</p>
<p>The following example takes <span class="SimpleMath">\(W\)</span> to be the list <code class="code">U6</code>, continuing Example 5.5.12 in the thesis <a href="chapBib_mj.html#biBgareth-thesis">[Eva05]</a>. As <span class="SimpleMath">\(a\)</span> is a subword of <span class="SimpleMath">\(ab\)</span> and <span class="SimpleMath">\(ac\)</span>, so <span class="SimpleMath">\(b\)</span> and <span class="SimpleMath">\(c\)</span> are right nonmultiplicative for <span class="SimpleMath">\(a\)</span>. Secondly, <span class="SimpleMath">\(ab\)</span> and <span class="SimpleMath">\(cb\)</span> have suffix <span class="SimpleMath">\(b\)</span> which is a prefix of <span class="SimpleMath">\(bc\)</span>, so <span class="SimpleMath">\(c\)</span> is right nonmultiplicative for <span class="SimpleMath">\(ab\)</span> and <span class="SimpleMath">\(cb\)</span>. Thirdly, <span class="SimpleMath">\(ac, bc, c^2\)</span> all have suffix <span class="SimpleMath">\(c\)</span>, which is a prefix of <span class="SimpleMath">\(cb\)</span> and <span class="SimpleMath">\(c^2\)</span>, so <span class="SimpleMath">\(b\)</span> and <span class="SimpleMath">\(c\)</span> are both right nonmultiplicative for <span class="SimpleMath">\(ac, bc, c^2\)</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RightOverlapDivision</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This division is the mirror image of <code class="code">LeftOverlapDivision</code>.</p>
<p>In the example, <span class="SimpleMath">\(a\)</span> is a prefix of <span class="SimpleMath">\(ab\)</span> and <span class="SimpleMath">\(ac\)</span> but is not a proper suffix of any monomial. However, <span class="SimpleMath">\(bc\)</span> has prefix <span class="SimpleMath">\(b\)</span> which is a suffix of <span class="SimpleMath">\(ab\)</span> and <span class="SimpleMath">\(cb\)</span>, so <span class="SimpleMath">\(a\)</span> and <span class="SimpleMath">\(c\)</span> and left nonmultiplicative for <span class="SimpleMath">\(bc\)</span>. Also <span class="SimpleMath">\(cb\)</span> and <span class="SimpleMath">\(c^2\)</span> have prefix <span class="SimpleMath">\(c\)</span> which is a suffix of <span class="SimpleMath">\(ac, bc, c^2\)</span>, so all of <span class="SimpleMath">\(a,b,c\)</span> are left nonmultiplicative for <span class="SimpleMath">\(cb\)</span> and <span class="SimpleMath">\(c^2\)</span>.</p>
<h5>6.1-5 <span class="Heading">Selecting a Division</span></h5>
<p>The global variable <code class="code">NoncommutativeDivision</code> can take values "Left", "Right", "LeftOverlap", "RightOverlap", "StrongLeftOverlop" or "StrongRightOverlap". The default is "LeftOverlap". The example shows how to select the left overlap division.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DivisionRecordNP</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation is called by the global function <code class="code">DivisionRecord</code> when the algebra is noncommutative. This operation finds the sets of multiplicative variables for a set of polynomials using one of the involutive divisions listed above. As in the commutative case, a three-field record <code class="code">drec</code> is returned: <code class="code">drec.div</code> is the division string; <code class="code">drec.mvars</code> is a two-element list, the first listing the sets of left multiplicative variables, and the second listing the sets of right multiplicative variables; <code class="code">drec.polys</code> is the list of polynomials in NP-format.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IPolyReduceNP</code>( <var class="Arg">algebra</var>, <var class="Arg">polynomial</var>, <var class="Arg">DivisionRecord</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation is called by the global function <code class="code">IPolyReduce</code> when the algebra is noncommutative. This function reduces a polynomial <span class="SimpleMath">\(p\)</span> using the current overlap record for a basis, and an ordering.</p>
<p>In the example <span class="SimpleMath">\(p = 5c^2a^2b^2 + 6b^2c^2a^2 + 7a^2b^2c^2\)</span>. The monomial <span class="SimpleMath">\(c^2a^2b^2\)</span> reduces to <span class="SimpleMath">\(c^2ac\)</span> by <span class="SimpleMath">\(ab^2 \to c\)</span>, since there are no letters to the right, but not by <span class="SimpleMath">\(ca^2 \to b\)</span> since <span class="SimpleMath">\(b\)</span> is not right multiplicative for <span class="SimpleMath">\(ca^2\)</span>. The other terms are similar, and <span class="SimpleMath">\(p\)</span> reduces to <span class="SimpleMath">\(5c^2ac + 6b^2cb + 7a^2ba\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">## choose a polynomial to reduce</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">p := 5*c^2*a^2*b^2 + 6*b^2*c^2*a^2 + 7*a^2*b^2*c^2;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">## convert to NP format and reduce</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Lp := GP2NP( p );</span>
[ [ [ 3, 3, 1, 1, 2, 2 ], [ 2, 2, 3, 3, 1, 1 ], [ 1, 1, 2, 2, 3, 3 ] ],
[ 5, 6, 7 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Lrp := IPolyReduce( A3, Lp, drec, ord );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">## convert back to a polynomial</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rp := NP2GP( Lrp, A3 );</span>
(5)*c^2*a*c+(6)*b^2*c*b+(7)*a^2*b*a
<span class="GAPprompt">gap></span> <span class="GAPinput">## p-rp should now belong to the ideal and reduce to 0</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">q := p - rp;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Lq := GP2NP( q );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Lrq := IPolyReduce( A3, Lq, drec, ord );;</span>
[ [ ], [ ] ]
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LoggedIPolyReduceNP</code>( <var class="Arg">algebra</var>, <var class="Arg">polynomial</var>, <varclass="Arg">DivisionRecord</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation is called by the global function <code class="code">LoggedIPolyReduce</code> when the algebra is noncommutative. This function is similar to <code class="code">IPolyReduceNP</code>, reducing a polynomial <span class="SimpleMath">\(p\)</span> using the current overlap record for a basis, and an ordering. It's output, however, is a record containing, as well as the reduced polynomial \(r\), logging information \(L\) which shows how the reduction has been obtained:
<p class="center">\[
p ~=~ r + \sum_{i,j} L[i][j][1] * L[i][j][2] * polys[i] * L[i][j][3].
\]</p>
<p>In the example <code class="code">r = logr.result</code> is equal to <span class="SimpleMath">\(Lrp\)</span>, and the equation above is then verified:</p>
<p class="center">\[
p ~=~ r + 5c^2a(ab^2-c) + 7a^2b(bc^2-a) + 6b^2c(ca^2-b).
\]</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IAutoreduceNP</code>( <var class="Arg">alg</var>, <var class="Arg">polys</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation is called by the global function <code class="code">IAutoreduce</code> when the algebra is noncommutative. This function applies <code class="code">IPolyReduceNP</code> to a list of polynomials recursively until no more reductions are possible. More specifically, this function involutively reduces each member of a list of polynomials with respect to all the other members of the list, removing the polynomial from the list if it is involutively reduced to 0. This process is iterated until no more reductions are possible.</p>
<p>If the set of polynomials is already reduced, then <code class="code">true</code> is returned.</p>
<p>In the example we form <code class="code">L4</code> by adding <code class="code">Lp</code> to <code class="code">L3</code>. Applying <code class="code">IAutoreduceNP</code>, only <span class="SimpleMath">\(p\)</span> reduces, and the concatenation of <code class="code">L3</code> with <span class="SimpleMath">\(Lrp\)</span> is returned.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">L4 := Concatenation( L3, [Lp] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R4 := IAutoreduceNP( A3, L4, ord );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintNPList( R4 );</span>
5c^2ac + 6b^2cb + 7a^2ba
ca^2 - b
bc^2 - a
ab^2 - c
<span class="GAPprompt">gap></span> <span class="GAPinput">IAutoreduceNP( A3, R4, ord );</span>
true
<h4>6.2 <span class="Heading">Computing a Noncommutative Involutive Basis</span></h4>
<p>The involutive algorithm for constructing an involutive basis in the noncommutative case also uses <em>prolongations</em> and <em>autoreduction</em>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InvolutiveBasisNP</code>( <var class="Arg">alg</var>, <var class="Arg">polys</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation is called by the global function <code class="code">InvolutiveBasis</code> when the algebra is noncommutative. This function finds an involutive basis for the ideal generated by a set of polynomials, using a chosen ordering.</p>
<p>In the example we find that a Gröbner basis starting from <code class="code">L3</code> is rather large, so add a fourth polynomial <span class="SimpleMath">\(a^2b-c\)</span> defining the ideal. The resulting Gröbner basis then has just three terms. We then calculate an involutive basis, which has just seven terms. We also find the reduced form of <span class="SimpleMath">\(p\)</span> to be <span class="SimpleMath">\(18a^2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">gbas := SGrobner( L3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( gbas ); </span>
64
<span class="GAPprompt">gap></span> <span class="GAPinput">## that's too large an example for this manual, so add a fourth poly
<span class="GAPprompt">gap></span> <span class="GAPinput">K4 := Concatenation( L3, [ [ [ [1,1,2], [3] ], [1,-1] ] ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintNPList( K4 ); </span>
ab^2 - c
bc^2 - a
ca^2 - b
a^2b - c
<span class="GAPprompt">gap></span> <span class="GAPinput">gbas := SGrobner( K4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintNPList( gbas );</span>
b - a
c - a
a^3 - a
<span class="GAPprompt">gap></span> <span class="GAPinput">## so the only reduced elements are {1,a,a^2} with a^3=a</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ibasK := InvolutiveBasis( A3, K4, ord );</span>
rec( div := "LeftOverlap",
mvars :=
[
[ [ 1 .. 3 ], [ 1 .. 3 ], [ 1 .. 3 ], [ 1 .. 3 ], [ 1 .. 3 ],
[ 1 .. 3 ], [ 1 .. 3 ] ],
[ [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], [ 2, 3 ]
] ],
polys := [ [ [ [ 3, 1, 1 ], [ 1 ] ], [ 1, -1 ] ],
[ [ [ 2, 1, 1 ], [ 1 ] ], [ 1, -1 ] ],
[ [ [ 1, 1, 1 ], [ 1 ] ], [ 1, -1 ] ],
[ [ [ 3, 1 ], [ 1, 1 ] ], [ 1, -1 ] ],
[ [ [ 2, 1 ], [ 1, 1 ] ], [ 1, -1 ] ], [ [ [ 3 ], [ 1 ] ], [ 1, -1 ] ],
[ [ [ 2 ], [ 1 ] ], [ 1, -1 ] ] ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintNPList( ibasK.polys ); </span>
ca^2 - a
ba^2 - a
a^3 - a
ca - a^2
ba - a^2
c - a
b - a
<span class="GAPprompt">gap></span> <span class="GAPinput">Lr := IPolyReduce( A3, p, ibasK, ord );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintNP( Lr );</span>
18a^2
</pre></div>
<p>In this simple example the left division produces the same basis, while the right and right overlap divisions <em>do not</em> produce (as might be expected) a mirror image basis.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">NoncommutativeDivision := "RightOverlap";;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ribasK := InvolutiveBasis( A3, K4, ord );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintNPList( ribasK.polys ); </span>
a^3 - a
c - a
b - a
<p>The <em>disjoint right cones condition</em> for a set of monomials <span class="SimpleMath">\(W\)</span> requires that, for each monomial <span class="SimpleMath">\(w_i \in W\)</span>, at least one variable in every monomial <span class="SimpleMath">\(w_j \in W\)</span> is right nonmultiplicative for <span class="SimpleMath">\(w_i\)</span>. The <em>disjoint left cones condition</em> is the mirror image of this.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StrongLeftOverlapDivision</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The strong left overlap division is the extension of the left overlap division obtained by enforcing the disjoint right cones condition. This is achieved by considering all pairs <span class="SimpleMath">\([w_i,w_j]\)</span> and, if no variable in <span class="SimpleMath">\(w_j\)</span> is right nonmultiplicative for <span class="SimpleMath">\(w_i\)</span>, then <span class="SimpleMath">\(w_j[1]\)</span> is removed from the list of right multiplicative variables for <spanclass="SimpleMath">\(w_i\)</span>.</p>
<p>In the example, the involutive basis using the left overlap division contains six polynomials with leading monomials <span class="SimpleMath">\([c^2,cb,ca,ba,ac,ab]\)</span> and with corresponding right non-multiplicative variables <span class="SimpleMath">\([[a,b,c],[a],[b,c],[b,c],[a,b,c],[a]]\)</span>. Every monomial contains either <span class="SimpleMath">\(b\)</span> or <span class="SimpleMath">\(c\)</span>. When using the strong left overlap division, the first change is in the case <span class="SimpleMath">\(i=j=2\)</span> when neither <span class="SimpleMath">\(b\)</span> nor <span class="SimpleMath">\(c\)</span> is non-multiplicative for <span class="SimpleMath">\(cb\)</span>. So <span class="SimpleMath">\(c\)</span> is made non-multiplicative for <span class="SimpleMath">\(w_2\)</span>. Similarly <span class="SimpleMath">\(c\)</span> is made non-multiplicative for <span class="SimpleMath">\(w_6 = ab\)</span>. The right multiplicative variables are now <span class="SimpleMath">\([[~],[b],[a],[a],[~],[b]]\)</span>, and <code class="code">InvolutiveBasisNP</code> continues with this information.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StrongRightOverlapDivision</code>( <var class="Arg">alg</var>, <var class="Arg">mons</var>, <var class="Arg">order</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation is the mirror image of <code class="code">StrongLeftOverlapDivision</code>.</p>
<p>When we compute an involutive basis <code class="code">rbasP</code> using the right overlap division we find that <code class="code">rbasP.polys = ibasP.polys</code>. However there is just one left multiplicative variable for each of the polynomials and the left disjoint cones condition is already satisfied. So, when using the strong right overlap division, we get the same basis.</p>
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.