<h4>9.1 <span class="Heading">Affine spaces and basic operations</span></h4>
<p>An <em>affine space</em> is a point-line incidence geometry, satisfying few well known axioms. An axiomatic treatment can e.g. be found in <a href="chapBib.html#biBVY65a">[VY65a]</a> and <a href="chapBib.html#biBVY65b">[VY65b]</a>. As is the case with projective spaces, affine spaces are axiomatically point-line geometries, but may contain higher dimensional affine subspaces too. An affine space can also be described as the "geometry you get" when you remove a hyperplane from a projective space. Conversely, each affine space can be extended to a projective space in a unique way (by "adding its hyperplane at infinity"). In <strong class="pkg">FinInG</strong>, we deal with <em>finite Desarguesian affine spaces</em>, i.e. an affine space, such that its projective completion is Desarguesian. Other concepts can be easily defined using this projective completion. E.g. lines of the projective space which are concurrent in a point of the hyperplane at infinity, become now <em>parallel</em> in the affine space. In order to implement (Desarguesian) affine spaces in <strong class="pkg">FinInG</strong>, we have to represent the elements of the affine space (the affine subspaces), in a standard way. By definition, the points (i.e. the elements of type 1) of the <span class="SimpleMath">n</span>-dimensional affine space AG(n,q) are the vectors of the underlying <span class="SimpleMath">n</span>-dimensional vector space over the finite field GF(q). The <span class="SimpleMath">i</span>-dimensional subspaces of AG(n,q) (i.e. the elements of type <span class="SimpleMath">i-1</span>) are defined as the cosets of the <span class="SimpleMath">i</span>-dimensional subspaces of the underlying vector space. Hence, the common representation of such a subspace is</p>
<p class="pcenter">v+S,</p>
<p>where v is a vector and S is a subspace of a vector space. Equivalently one can also think of a subspace of an affine space as consisting of: (i) an affine point, representing the coset, and and (ii) a "direction", which is an element of an <span class="SimpleMath">n-1</span>-dimensional projective space, representing the hyperplane at infinity. In <strong class="pkg">FinInG</strong>, we represent an <span class="SimpleMath">i</span>-dimensional subspace, <span class="SimpleMath">1 ≤ i ≤ n-1</span> as</p>
<p class="pcenter">[v, mat]</p>
<p>where <var class="Arg">v</var> is a row vector and <var class="Arg">mat</var> is a matrix (representing a basis of the projective element representing the direction at infinity). For affine points, we simply use vectors.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsAffineSpace</code></td><td class="tdright">( category )</td></tr></table></div>
<p>This category is a subcategory of <code class="code">IsIncidenceGeometry</code>, and contains all finite Desarguesian affine spaces.</p>
<p><var class="Arg">d</var> must be a positive integer. In the first form, <var class="Arg">F</var> is a field and the function returns the affine space of dimension <var class="Arg">d</var> over <var class="Arg">F</var>. In the second form, <var class="Arg">q</var> is a prime power specifying the size of the field. The user may also use an alias, namely, the common abbreviation <code class="code">AG(d, q)</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BaseField</code>( <var class="Arg">as</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: returns the base field for the affine space <var class="Arg">as</var></p>
<p>The ambient space of an affine space <var class="Arg">as</var> is the affine space itself. Hence, simply <var class="Arg">as</var> will be returned.</p>
<p><var class="Arg">geo</var> is an affine space, <var class="Arg">v</var> is a row vector, and <var class="Arg">M</var> is a matrix. There are two representations necessary for affine subspaces in <strong class="pkg">FinInG</strong>: (i) points represented as vectors and (ii) subspaces of dimension at least 1 represented as a coset of a vector subspace:</p>
<p class="pcenter">v+S.</p>
<p>For the former, the underlying object is just a vector, whereas the second is a pair <span class="SimpleMath">[v, M]</span> where <span class="SimpleMath">v</span> is a vector and <span class="SimpleMath">M</span> is a matrix representing the basis of <span class="SimpleMath">S</span>. Now there is a canonical representative for the coset <span class="SimpleMath">v+ S</span>, and the matrix <span class="SimpleMath">M</span> is in semi-echelon form, therefore we can easily compare two affine subspaces. If no matrix is given in the arguments, then it is assumed that the user is constructing an affine point.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ElementsOfIncidenceStructure</code>( <var class="Arg">as</var>, <var class="Arg">j</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: the collection of elements of the affine space <var class="Arg">as</var> of type <var class="Arg">j</var></p>
<p>For the affine space <var class="Arg">as</var> of dimension <span class="SimpleMath">d</span> and the type <var class="Arg">j</var>, <span class="SimpleMath">1 ≤ j ≤ d</span> this operation returns the collection of <span class="SimpleMath">j-1</span> dimensional subspaces. An error message is produced when the projective space <var class="Arg">ps</var> has no elements of a required type.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ag := AffineSpace(9, 64);</span>
AG(9, 64)
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,1);</span>
<points of AG(9, 64)>
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,2);</span>
<lines of AG(9, 64)>
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,3);</span>
<planes of AG(9, 64)>
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,4);</span>
<solids of AG(9, 64)>
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,6);</span>
<affine. subspaces of dim. 5 of AG(9, 64)>
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,9);</span>
<affine. subspaces of dim. 8 of AG(9, 64)>
<span class="GAPprompt">gap></span> <span class="GAPinput">ElementsOfIncidenceStructure(ag,10);</span>
Error, <as> has no elements of type <j> called from
<function "unknown">( <arguments> )
called from read-eval loop at line 15 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
<span class="GAPbrkprompt">brk></span> <span class="GAPinput">quit;</span>
<p>Recall that for affine spaces, incidence is symmetrized containment, where the whole affine space is excluded as one of the arguments for the operation <code class="file">IsIncident</code>, since they it is not considered as an element of the geometry, but the whole affine space is allowed as one of the arguments for <code class="file">\in</code>. The method for <code class="file">\*</code> is using <code class="file">IsIncident</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">as := AG(3,16);</span>
AG(3, 16)
<span class="GAPprompt">gap></span> <span class="GAPinput">p := AffineSubspace(as,[1,0,0]*Z(16)^0);</span>
<a point in AG(3, 16)>
<span class="GAPprompt">gap></span> <span class="GAPinput">l := AffineSubspace(as,[1,0,0]*Z(16),[[0,1,1]]*Z(16)^0);</span>
<a line in AG(3, 16)>
<span class="GAPprompt">gap></span> <span class="GAPinput">plane := AffineSubspace(as,[1,0,0]*Z(16)^0,[[1,0,0],[0,1,1]]*Z(16)^0);</span>
<a plane in AG(3, 16)>
<span class="GAPprompt">gap></span> <span class="GAPinput">p in p;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">p in l;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">l in p;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">l in plane;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">plane in l;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">p in plane;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">p in as;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">l in as;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">plane in as;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">as in p;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsIncident(p,l);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsIncident(l,p);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsIncident(l,plane);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsIncident(plane,l);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsIncident(p,plane);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsIncident(plane,p);</span>
true
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AmbientSpace</code>( <var class="Arg">el</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: returns the ambient space of an element <var class="Arg">el</var> of an affine space</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BaseField</code>( <var class="Arg">el</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: returns the base field of an element <var class="Arg">el</var> of an affine space</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Meet</code>( <var class="Arg">u</var>, <var class="Arg">v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: an affine subspace or the empty list</p>
<p><var class="Arg">u</var> and <var class="Arg">v</var> are subspaces of an affine space. This function returns the meet of the two subspaces. If the two subspaces are disjoint, then Meet returns the empty list.</p>
<p>The arguments <var class="Arg">u</var> and <var class="Arg">v</var> must be affine subspaces of a common affine space. Two subspaces are parallel if and only if the direction space of the first is contained in the direction space of the second or vice-versa.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">as := AffineSpace(3, 3);</span>
AG(3, 3)
<span class="GAPprompt">gap></span> <span class="GAPinput">l := AffineSubspace(as,[0,0,0]*Z(3)^0,[[1,0,0]]*Z(3)^0);</span>
<a line in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">m := AffineSubspace(as,[1,0,0]*Z(3)^0,[[1,0,0]]*Z(3)^0);</span>
<a line in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">n := AffineSubspace(as,[1,0,0]*Z(3)^0,[[0,1,0]]*Z(3)^0);</span>
<a line in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsParallel(l,m);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsParallel(m,n);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsParallel(l,n);</span>
false
<p>The argument <var class="Arg">v</var> is an affine subspace of <var class="Arg">as</var>. This operation returns a collection for which an iterator is installed. The collection represents the set of elements of <var class="Arg">as</var> of the same type as <var class="Arg">v</var> which are parallel to <var class="Arg">v</var>; they have the same direction. If <var class="Arg">v</var> is a point, then this operation returns the collection of all points of <var class="Arg">as</var>. If one argument is given, then it is assumed that the affine space which we are working with is the ambient space of <var class="Arg">v</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">as := AffineSpace(3, 3);</span>
AG(3, 3)
<span class="GAPprompt">gap></span> <span class="GAPinput">l := Random( Lines( as ) );</span>
<a line in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">pclass := ParallelClass( l );</span>
<parallel class of lines in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">AsList(pclass);</span>
[ <a line in AG(3, 3)>, <a line in AG(3, 3)>, <a line in AG(3, 3)>,
<a line in AG(3, 3)>, <a line in AG(3, 3)>, <a line in AG(3, 3)>,
<a line in AG(3, 3)>, <a line in AG(3, 3)>, <a line in AG(3, 3)> ]
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ShadowOfElement</code>( <var class="Arg">as</var>, <var class="Arg">v</var>, <var class="Arg">type</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: the subspaces of the affine space <var class="Arg">as</var> of dimension <var class="Arg">type</var> which are incident with <var class="Arg">v</var></p>
<p><var class="Arg">as</var> is an affine space and <var class="Arg">v</var> is an element of <var class="Arg">as</var>. This operation computes and returns the subspaces of dimension <var class="Arg">type</var> which are incident with <var class="Arg">v</var>. In fact, this operation returns a collection which is only computed when iterated (e.g. when applying <code class="code">AsList</code> to the collection). Some shorthand notation for <code class="code">ShadowOfElement</code> is available for affine spaces: <code class="code">Points(as,v)</code>, <code class="code">Points(v)</code>, <code class="code">Lines(v)</code>, etc.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">as := AffineSpace(3, 3);</span>
AG(3, 3)
<span class="GAPprompt">gap></span> <span class="GAPinput">l := Random( Lines( as ) );</span>
<a line in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">planesonl := Planes(l);</span>
<shadow planes in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">AsList(planesonl);</span>
[ <a plane in AG(3, 3)>, <a plane in AG(3, 3)>, <a plane in AG(3, 3)>,
<a plane in AG(3, 3)> ]
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ShadowOfFlag</code>( <var class="Arg">as</var>, <var class="Arg">list</var>, <var class="Arg">type</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: the subspaces of the affine space <var class="Arg">as</var> of dimension <var class="Arg">type</var> which are incident with each element of <var class="Arg">list</var></p>
<p><var class="Arg">as</var> is an affine space and <var class="Arg">list</var> is a list of pairwise incident elements of <var class="Arg">as</var>. This operation computes and returns the subspaces of dimension <var class="Arg">type</var> which are incident with every element of <var class="Arg">list</var>. In fact, this operation returns a collection which is only computed when iterated (e.g. when applying <code class="code">AsList</code> to the collection).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">as := AffineSpace(3, 3);</span>
AG(3, 3)
<span class="GAPprompt">gap></span> <span class="GAPinput">l := Random( Lines( as ) );</span>
<a line in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">x := Random( Points( l ) );</span>
<a point in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">flag := FlagOfIncidenceStructure(as,[x,l]);</span>
<a flag of AffineSpace(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">shadow := ShadowOfFlag( as, flag, 3 );</span>
<shadow planes in AG(3, 3)>
<span class="GAPprompt">gap></span> <span class="GAPinput">AsList(shadow);</span>
Iterators of shadows of flags in affine spaces are not complete in this versio
n
[ <a plane in AG(3, 3)>, <a plane in AG(3, 3)>, <a plane in AG(3, 3)>,
<a plane in AG(3, 3)> ]
<h4>9.4 <span class="Heading">Iterators and enumerators</span></h4>
<p>Recall from Section <a href="chap4.html#X799F3A2A86F82E5B"><span class="RefLink">4.4</span></a> ("Enumerating subspaces of a projective space", Chapter <a href="chap4.html#X83BBAA668672A76D"><span class="RefLink">4</span></a>), that an iterator allows us to obtain elements from a collection one at a time in sequence, whereas an enumerator for a collection give us a way of picking out the i-th element. In <strong class="pkg">FinInG</strong> we have enumerators and iterators for subspace collections of affine spaces.</p>
<p>A <em>collineation</em> of an affine space is a permutation of the points which preserves the relation of collinearity within the affine space. The fundamental theorem of affine geometry states that the group AΓL(n,q) of collineations of an affine space AG(n,q) is generated by the translations <span class="SimpleMath">T</span>, the matrices of GL(n,q) and the automorphisms of the field GF(q). The translations <span class="SimpleMath">T</span> form a normal subgroup of AΓL(n,q), and AΓL(n,q) is the semidirect product of <span class="SimpleMath">T</span> and ΓL(n,q).</p>
<p>Suppose we have an affine transformation of the form <span class="SimpleMath">x+A</span> where <span class="SimpleMath">x</span> is a vector representing a translation, and <span class="SimpleMath">A</span> is a matrix in GL(n,q) Then by using the natural embedding of AGL(n,q) in PGL(n+1,q), we can write this collineation as a matrix: <tablestyle="color:#000"><tr> <td><table border=0 cellpadding=0 cellspacing=0px style="border-left:1px solid #000; border-right:1px solid #000; color:#000"><tr> <tdstyle ="border-top:1px solid #000; border-bottom:1px solid #000;"> </td><td><table border=0 cellpadding=0 cellspacing=0 style="color:#000;"> <tr> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30>0</td> </tr> <tr> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30>A</td> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30>0</td> </tr> <tr> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30> </td> <td align="center" valign="center" width=30>0</td> </tr> <tr> <td align="center" valign="center" width=30>---</td> <td align="center" valign="center" width=30>x</td> <td align="center" valign="center" width=30>---</td> <tdalign="center" valign="center" width=30>1</td> </tr> </table></td><tdstyle ="border-top:1px solid #000; border-bottom:1px solid #000;"> </td></tr></table></td> </tr></table></p>
<p>We can extend this idea to the full affine collineation group by adjoining the field automorphisms as we would for projective collineations. Here is an example:</p>
<p>As we have seen, in <strong class="pkg">FinInG</strong>, we represent an element of an affine collineation group as a projective semilinear element, i.e. as an object in the category <code class="code">ProjElsWithFrob</code>, so that we can use all the functionality that exists for such objects. However, an affine collineation group (i.e. a group of collineations of the affine space AG(n,q) is not by default constructed as a subgroup of PΓL(n+1,q), but the compatibility between the elements of both groups enables testing for such relations.</p>
<p>If <var class="Arg">as</var> is the affine space AG(n,q) This operation returns the affine linear group AGL(n,q) acting on <var class="Arg">as</var>. The elements of this group are projectivities of the associated projective space. In order to get the full group of collineations of the affine space, one needs to use the operation <code class="code">CollineationGroup</code>.</p>
<p>If <var class="Arg">as</var> is the affine space AG(n,q), then this operation returns the affine semilinear group AΓL(n,q). The elements of this group are collineations of the associated projective space. Note that if the defining field has prime order, then the groups AΓL(n,q) and AGL(n,q) coincide.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OnAffineSpaces</code>( <var class="Arg">subspace</var>, <var class="Arg">el</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ \^</code>( <var class="Arg">subspace</var>, <var class="Arg">el</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: an element of an affine space</p>
<p><var class="Arg">subspace</var> must be an element of an affine space and <var class="Arg">el</var> a collineation of an affine space (which is in fact also a collineation of an associated projective space). This is the action one should use for collineations of affine spaces, and it acts on subspaces of all types of affine spaces: points, lines, planes, etc.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">as := AG(3,27);</span>
AG(3, 27)
<span class="GAPprompt">gap></span> <span class="GAPinput">p := Random(Points(as));</span>
<a point in AG(3, 27)>
<span class="GAPprompt">gap></span> <span class="GAPinput">g := Random(CollineationGroup(as));</span>
< a collineation: [ [ Z(3^3)^25, Z(3^3)^11, Z(3^3)^23, 0*Z(3) ],
[ Z(3^3)^20, 0*Z(3), Z(3^3), 0*Z(3) ],
[ Z(3^3)^16, Z(3^3)^15, Z(3^3)^21, 0*Z(3) ],
[ Z(3^3)^20, Z(3^3)^4, 0*Z(3), Z(3)^0 ] ], F^3>
<span class="GAPprompt">gap></span> <span class="GAPinput">OnAffineSubspaces(p,g);</span>
<a point in AG(3, 27)>
<span class="GAPprompt">gap></span> <span class="GAPinput">p^g;</span>
<a point in AG(3, 27)>
<span class="GAPprompt">gap></span> <span class="GAPinput">l := Random(Lines(as));</span>
<a line in AG(3, 27)>
<span class="GAPprompt">gap></span> <span class="GAPinput">OnAffineSubspaces(l,g);</span>
<a line in AG(3, 27)>
<span class="GAPprompt">gap></span> <span class="GAPinput">l^g;</span>
<a line in AG(3, 27)>
<p>One technical aspect of the design behind affine spaces in <strong class="pkg">FinInG</strong> is having canonical transversals for subspaces of vector spaces. We provide some documentation below for the interested user.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsVectorSpaceTransversal</code></td><td class="tdright">( filter )</td></tr></table></div>
<p>The category <code class="code">IsVectorSpaceTransversal</code> represents a special object in <strong class="pkg">FinInG</strong> which carries a record with two components: <var class="Arg">space</var> and <var class="Arg">subspace</var>. This category is a subcategory of <code class="code">IsSubspacesOfVectorSpace</code>, however, we do not recommend the user to apply methods to objects in <code class="code">IsVectorSpaceTransversal</code>, which are normally used for the category <code class="code">IsSubspacesOfVectorSpace</code> (they won't work!). The objects in <code class="code">IsVectorSpaceTransversal</code> are only used in order to facilitate computing enumerators of subspace collections.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ VectorSpaceTransversal</code>( <var class="Arg">space</var>, <var class="Arg">mat</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a collection for representing a transversal of a subspaces of a vector space</p>
<p><var class="Arg">space</var> is a vector space <span class="SimpleMath">V</span> and <var class="Arg">mat</var> is a matrix whose rows are a basis for a subspace <span class="SimpleMath">U</span> of <span class="SimpleMath">V</span>. A transversal for <span class="SimpleMath">U</span> in <span class="SimpleMath">V</span> is a set of coset representatives for the quotient <span class="SimpleMath">V/U</span>. This collection comes equipped with an enumerator operation.</p>
<p><var class="Arg">space</var> is a vector space <span class="SimpleMath">V</span>, <var class="Arg">mat</var> is a matrix whose rows are a basis for a subspace <span class="SimpleMath">U</span> of <span class="SimpleMath">V</span>, and <var class="Arg">vector</var> is a vector <span class="SimpleMath">v</span> of <span class="SimpleMath">V</span>. A canonical representative <span class="SimpleMath">v'</span> is returned for the coset <span class="SimpleMath">U+v</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ComplementSpace</code>( <var class="Arg">space</var>, <var class="Arg">mat</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a collection for representing a transversal of a subspaces of a vector space</p>
<p><var class="Arg">space</var> is a vector space <span class="SimpleMath">V</span> and <var class="Arg">mat</var> is a matrix whose rows are a basis for a subspace <span class="SimpleMath">U</span> of <span class="SimpleMath">V</span>. The operation is almost a complete copy of the function <code class="code">BaseSteinitzVector</code> except that just a basis for the complement of <span class="SimpleMath">U</span> is returned instead of a full record.</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.
