Quelle chap17.html Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/cap/doc/chap17.html

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (CAP) - Chapter 17: Examples and Tests</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap17" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chap10.html">10</a> <a href="chap11.html">11</a> <a href="chap12.html">12</a> <a href="chap13.html">13</a> <a href="chap14.html">14</a> <a href="chap15.html">15</a> <a href="chap16.html">16</a> <a href="chap17.html">17</a> <a href="chap18.html">18</a> <a href="chapInd.html">Ind</a> </div>

<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap16.html">[Previous Chapter]</a> <a href="chap18.html">[Next Chapter]</a> </div>

<a href="chap17_mj.html">[MathJax on]</a>
<a id="X7967FE8E7BBDF485" name="X7967FE8E7BBDF485"></a>
<div class="ChapSects"><a href="chap17.html#X7967FE8E7BBDF485">17 Examples and Tests</a>
<div class="ContSect"> <a href="chap17.html#X7CA5B46383A5CE09">17.1 Dummy implementations</a>

<div class="ContSSBlock">
 <a href="chap17.html#X82A623E78640E822">17.1-1 Dummy categories</a>

 <a href="chap17.html#X7B19E3AE7AB1B31B">17.1-2 Dummy rings</a>

</div></div>
<div class="ContSect"> <a href="chap17.html#X7BAE6D0285667B1F">17.2 Finite skeletal discrete categories</a>

</div>
<div class="ContSect"> <a href="chap17.html#X78D1062D78BE08C1">17.3 Functors</a>

</div>
<div class="ContSect"> <a href="chap17.html#X7B339750826300B4">17.4 HandlePrecompiledTowers</a>

</div>
<div class="ContSect"> <a href="chap17.html#X7EA29B7D7BA60F42">17.5 Terminal category</a>

</div>
</div>

<h3>17 Examples and Tests</h3>

<a id="X7CA5B46383A5CE09" name="X7CA5B46383A5CE09"></a>

<h4>17.1 Dummy implementations</h4>

<a id="X82A623E78640E822" name="X82A623E78640E822"></a>

<h5>17.1-1 Dummy categories</h5>

<div class="example"><pre>
gap> LoadPackage( "CAP", false );
true
gap> list_of_operations_to_install := [
> "ObjectConstructor",
> "MorphismConstructor",
> "ObjectDatum",
> "MorphismDatum",
> "IsCongruentForMorphisms",
> "PreCompose",
> "IdentityMorphism",
> "DirectSum",
> ];;
gap> dummy := DummyCategory( rec(
> list_of_operations_to_install := list_of_operations_to_install,
> properties := [ "IsAdditiveCategory" ],
> ) );;
gap> ForAll( list_of_operations_to_install, o -> CanCompute( dummy, o ) );
true
gap> IsAdditiveCategory( dummy );
true
</pre></div>

<a id="X7B19E3AE7AB1B31B" name="X7B19E3AE7AB1B31B"></a>

<h5>17.1-2 Dummy rings</h5>

<div class="example"><pre>
gap> LoadPackage( "CAP", false );
true
gap> DummyRing( );
Dummy ring 1
gap> DummyRing( );
Dummy ring 2
gap> IsRing( DummyRing( ) );
true
gap> DummyCommutativeRing( );
Dummy commutative ring 1
gap> DummyCommutativeRing( );
Dummy commutative ring 2
gap> IsRing( DummyCommutativeRing( ) );
true
gap> IsCommutative( DummyCommutativeRing( ) );
true
gap> DummyField( );
Dummy field 1
gap> DummyField( );
Dummy field 2
gap> IsRing( DummyField( ) );
true
gap> IsField( DummyField( ) );
true
</pre></div>

<a id="X7BAE6D0285667B1F" name="X7BAE6D0285667B1F"></a>

<h4>17.2 Finite skeletal discrete categories</h4>

<div class="example"><pre>
gap> LoadPackage( "CAP", false );
true
gap> D := FiniteSkeletalDiscreteCategory( [ 1 .. 5 ] );
FiniteSkeletalDiscreteCategory( [ 1 .. 5 ] )
gap> one := ObjectConstructor( D, 1 );
<An object in FiniteSkeletalDiscreteCategory( [ 1 .. 5 ] )>
gap> IsWellDefinedForObjects( one );
true
gap> ObjectDatum( one ) = 1;
true
gap> Display( one );
1
gap> IsEqualForObjects( one, D[1] );
true
gap> id_one := IdentityMorphism( D, one );
<An identity morphism in FiniteSkeletalDiscreteCategory( [ 1 .. 5 ] )>
gap> IsWellDefinedForMorphisms( id_one );
true
gap> MorphismDatum( id_one ) = fail;
true
gap> Display( id_one );
1
|
| A morphism in FiniteSkeletalDiscreteCategory( [ 1 .. 5 ] )
v
1
gap> IsEqualForMorphisms( PreCompose( id_one, id_one ), id_one );
true
gap> Length( SetOfObjectsOfCategory( D ) );
5
gap> Length( SetOfMorphismsOfFiniteCategory( D ) );
5
</pre></div>

<a id="X78D1062D78BE08C1" name="X78D1062D78BE08C1"></a>

<h4>17.3 Functors</h4>

We create a binary functor F with one covariant and one contravariant component in two ways. Here is the first way to model a binary functor:

<div class="example"><pre>
gap> ring := HomalgRingOfIntegers( );;
gap> vec := LeftPresentations( ring );;
gap> F := CapFunctor( "CohomForVec", [ vec, [ vec, true ] ], vec );;
gap> obj_func := function( A, B ) return TensorProductOnObjects( A, DualOnObjects( B ) ); end;;
gap> mor_func := function( source, alpha, beta, range ) return TensorProductOnMorphismsWithGivenTensorProducts( source, alpha, DualOnMorphisms( beta ), range ); end;;
gap> AddObjectFunction( F, obj_func );;
gap> AddMorphismFunction( F, mor_func );;
</pre></div>

CAP regards F as a binary functor on a technical level, as we can see by looking at its input signature:

<div class="example"><pre>
gap> InputSignature( F );
[ [ Category of left presentations of Z, false ], [ Category of left presentations of Z, true ] ]
</pre></div>

We can see that <code class="code">ApplyFunctor</code> works both on two arguments and on one argument (in the product category).

<div class="example"><pre>
gap> V1 := TensorUnit( vec );;
gap> V3 := DirectSum( V1, V1, V1 );;
gap> pi1 := ProjectionInFactorOfDirectSum( [ V1, V1 ], 1 );;
gap> pi2 := ProjectionInFactorOfDirectSum( [ V3, V1 ], 1 );;
gap> value1 := ApplyFunctor( F, pi1, pi2 );;
gap> input := Product( pi1, Opposite( pi2 ) );;
gap> value2 := ApplyFunctor( F, input );;
gap> IsCongruentForMorphisms( value1, value2 );
true
</pre></div>

Here is the second way to model a binary functor:

<div class="example"><pre>
gap> F2 := CapFunctor( "CohomForVec2", Product( vec, Opposite( vec ) ), vec );;
gap> AddObjectFunction( F2, a -> obj_func( a[1], Opposite( a[2] ) ) );;
gap> AddMorphismFunction( F2, function( source, datum, range ) return mor_func( source, datum[1], Opposite( datum[2] ), range ); end );;
gap> value3 := ApplyFunctor( F2,input );;
gap> IsCongruentForMorphisms( value1, value3 );
true
</pre></div>

CAP regards F2 as a unary functor on a technical level, as we can see by looking at its input signature:

<div class="example"><pre>
gap> InputSignature( F2 );
[ [ Product of: Category of left presentations of Z, Opposite( Category of left presentations of Z ), false ] ]
</pre></div>

Installation of the first functor as a GAP-operation. It will be installed both as a unary and binary version.

<div class="example"><pre>
gap> InstallFunctor( F, "F_installation" );;
gap> F_installation( pi1, pi2 );;
gap> F_installation( input );;
gap> F_installationOnObjects( V1, V1 );;
gap> F_installationOnObjects( Product( V1, Opposite( V1 ) ) );;
gap> F_installationOnMorphisms( pi1, pi2 );;
gap> F_installationOnMorphisms( input );;
</pre></div>

Installation of the second functor as a GAP-operation. It will be installed only as a unary version.

<div class="example"><pre>
gap> InstallFunctor( F2, "F_installation2" );;
gap> F_installation2( input );;
gap> F_installation2OnObjects( Product( V1, Opposite( V1 ) ) );;
gap> F_installation2OnMorphisms( input );;
</pre></div>

<a id="X7B339750826300B4" name="X7B339750826300B4"></a>

<h4>17.4 HandlePrecompiledTowers</h4>

<div class="example"><pre>
gap> LoadPackage( "CAP", false );
true
gap> dummy1 := CreateCapCategory( );;
gap> dummy2 := CreateCapCategory( );;
gap> dummy3 := CreateCapCategory( );;
gap> PrintAndReturn := function ( string )
> Print( string, "\n" ); return string; end;;
gap> dummy1!.compiler_hints := rec( );;
gap> dummy1!.compiler_hints.precompiled_towers := [
> rec(
> remaining_constructors_in_tower := [ "Constructor1" ],
> precompiled_functions_adder := cat ->
> PrintAndReturn( "Adding precompiled operations for Constructor1" ),
> ),
> rec(
> remaining_constructors_in_tower := [ "Constructor1", "Constructor2" ],
> precompiled_functions_adder := cat ->
> PrintAndReturn( "Adding precompiled operations for Constructor2" ),
> ),
> ];;
gap> HandlePrecompiledTowers( dummy2, dummy1, "Constructor1" );
Adding precompiled operations for Constructor1
gap> HandlePrecompiledTowers( dummy3, dummy2, "Constructor2" );
Adding precompiled operations for Constructor2
</pre></div>

<a id="X7EA29B7D7BA60F42" name="X7EA29B7D7BA60F42"></a>

<h4>17.5 Terminal category</h4>

<div class="example"><pre>
gap> LoadPackage( "CAP", false );
true
gap> T := TerminalCategoryWithMultipleObjects( );
TerminalCategoryWithMultipleObjects( )
gap> i := InitialObject( T );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> t := TerminalObject( T );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> z := ZeroObject( T );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Display( i );
InitialObject( )
gap> Display( t );
TerminalObject( )
gap> Display( z );
ZeroObject( )
gap> IsIdenticalObj( i, z );
false
gap> IsIdenticalObj( t, z );
false
gap> id_z := IdentityMorphism( z );
<A zero, identity morphism in TerminalCategoryWithMultipleObjects( )>
gap> fn_z := ZeroObjectFunctorial( T );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> IsEqualForMorphisms( id_z, fn_z );
false
gap> IsCongruentForMorphisms( id_z, fn_z );
true
gap> a := "a" / T;
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Display( a );
a
gap> IsWellDefined( a );
true
gap> aa := ObjectConstructor( T, "a" );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Display( aa );
a
gap> IsEqualForObjects( a, aa );
true
gap> IsIsomorphicForObjects( a, aa );
true
gap> IsIsomorphism( SomeIsomorphismBetweenObjects( a, aa ) );
true
gap> b := "b" / T;
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Display( b );
b
gap> IsEqualForObjects( a, b );
false
gap> IsIsomorphicForObjects( a, b );
true
gap> mor_ab := SomeIsomorphismBetweenObjects( a, b );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> IsIsomorphism( mor_ab );
true
gap> Display( mor_ab );
a
|
| SomeIsomorphismBetweenObjects
v
b
gap> Hom_ab := MorphismsOfExternalHom( a, b );;
gap> Length( Hom_ab );
1
gap> Hom_ab[1];
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( Hom_ab[1] );
a
|
| InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism
v
b
gap> Hom_ab[1] = mor_ab;
true
gap> HomStructure( mor_ab );
<A zero, identity morphism in TerminalCategoryWithSingleObject( )>
gap> m := MorphismConstructor( a, "m", b );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( m );
a
|
| m
v
b
gap> IsWellDefined( m );
true
gap> n := MorphismConstructor( a, "n", b );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( n );
a
|
| n
v
b
gap> IsEqualForMorphisms( m, n );
false
gap> IsCongruentForMorphisms( m, n );
true
gap> m = n;
true
gap> hom_mn := HomStructure( m, n );
<A zero, identity morphism in TerminalCategoryWithSingleObject( )>
gap> id := IdentityMorphism( a );
<A zero, identity morphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( id );
a
|
| IdentityMorphism( a )
v
a
gap> m = id;
false
gap> id = MorphismConstructor( a, "xyz", a );
true
gap> zero := ZeroMorphism( a, a );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( zero );
a
|
| ZeroMorphism( a, a )
v
a
gap> id = zero;
true
gap> IsLiftable( m, n );
true
gap> lift := Lift( m, n );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( lift );
a
|
| Lift( m, n )
v
a
gap> IsColiftable( m, n );
true
gap> colift := Colift( m, n );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> Display( colift );
b
|
| Colift( m, n )
v
b
gap> DirectProduct( T, [ ] );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Equalizer( T, z, [ ] );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Coproduct( T, [ ] );
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> Coequalizer( T, z, [ ] );
<A zero object in TerminalCategoryWithMultipleObjects( )>
</pre></div>

<div class="example"><pre>
gap> LoadPackage( "CAP", false );
true
gap> T := TerminalCategoryWithSingleObject( );
TerminalCategoryWithSingleObject( )
gap> i := InitialObject( T );
<A zero object in TerminalCategoryWithSingleObject( )>
gap> t := TerminalObject( T );
<A zero object in TerminalCategoryWithSingleObject( )>
gap> z := ZeroObject( T );
<A zero object in TerminalCategoryWithSingleObject( )>
gap> Display( i );
A zero object in TerminalCategoryWithSingleObject( ).
gap> Display( t );
A zero object in TerminalCategoryWithSingleObject( ).
gap> Display( z );
A zero object in TerminalCategoryWithSingleObject( ).
gap> IsIdenticalObj( i, z );
false
gap> IsIdenticalObj( t, z );
false
gap> IsWellDefined( z );
true
gap> Length( SetOfObjectsOfCategory( T ) );
1
gap> id_z := IdentityMorphism( z );
<A zero, identity morphism in TerminalCategoryWithSingleObject( )>
gap> fn_z := ZeroObjectFunctorial( T );
<A zero, identity morphism in TerminalCategoryWithSingleObject( )>
gap> IsWellDefined( fn_z );
true
gap> IsEqualForMorphisms( id_z, fn_z );
true
gap> IsCongruentForMorphisms( id_z, fn_z );
true
gap> Length( SetOfMorphismsOfFiniteCategory( T ) );
1
gap> IsLiftable( id_z, fn_z );
true
gap> Lift( id_z, fn_z );
<A zero, identity morphism in TerminalCategoryWithSingleObject( )>
gap> IsColiftable( id_z, fn_z );
true
gap> Colift( id_z, fn_z );
<A zero, identity morphism in TerminalCategoryWithSingleObject( )>
gap> DirectProduct( T, [ ] );
<A zero object in TerminalCategoryWithSingleObject( )>
gap> Equalizer( T, z, [ ] );
<A zero object in TerminalCategoryWithSingleObject( )>
gap> Coproduct( T, [ ] );
<A zero object in TerminalCategoryWithSingleObject( )>
gap> Coequalizer( T, z, [ ] );
<A zero object in TerminalCategoryWithSingleObject( )>
</pre></div>

<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap16.html">[Previous Chapter]</a> <a href="chap18.html">[Next Chapter]</a> </div>

<div class="chlinkbot">Goto Chapter: <a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chap10.html">10</a> <a href="chap11.html">11</a> <a href="chap12.html">12</a> <a href="chap13.html">13</a> <a href="chap14.html">14</a> <a href="chap15.html">15</a> <a href="chap16.html">16</a> <a href="chap17.html">17</a> <a href="chap18.html">18</a> <a href="chapInd.html">Ind</a> </div>

<hr />
generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a>
</body>
</html>

quality97%

¤ Dauer der Verarbeitung: 0.19 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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.