Changeset afc8b6 in git for Singular/LIB


Ignore:
Timestamp:
Aug 5, 2004, 4:49:14 PM (20 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')
Children:
b630a780ee0428a67776401525d297cfd5e67868
Parents:
fb004c35e492eee30ecc9db2c44c74cdeb3f4200
Message:
*levandov: spellcheck, additions, cosmetic changes


git-svn-id: file:///usr/local/Singular/svn/trunk@7327 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/center.lib

    rfb004c rafc8b6  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: center.lib,v 1.7 2004-07-22 20:14:01 plural Exp $";
     2version="$Id: center.lib,v 1.8 2004-08-05 14:49:14 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    77OVERVIEW:
    88 This is a library for computing the central elements and centralisators of elements in various noncommutative algebras.
    9  Implementations are based on algorithms, written in the frame of the diploma thesis by Oleksandr Motsak
    10  (advisor: Prof. Ovsienko Sergiy Adamovich) at Kyiv Taras Shevchenko University:
    11  'An algorithm for the computation of the center of noncommutative polynomial algebra'.
     9 Implementation is partially based on algorithms, written in the frame of the diploma thesis by Oleksandr Motsak (advisors: Prof. S.A. Ovsienko, V.Levandovskyy) at Kyiv Taras Shevchenko University:  'An algorithm for the computation of the center of noncommutative polynomial algebra'.
    1210 @* The last version of this library can be found via internet.
    13 SUPPORT: Forschungsschwerpunkt
     11
     12SUPPORT: Forschungsschwerpunkt 'Mathematik und Praxis'
     13
    1414PROCEDURES:
    15         center(MaxDeg[,N]);             Computing of a Center of current algebra
    16         centralizator(f, MaxDeg[,N]);   Computing of a Centralizator of f in current algebra
    17 
    18         inCenter(l);                    Check for the commutativity of polynomials of list/ideal/poly l
    19         inCentralizator(l, f);          Check for the commutativity of polynomials of list/ideal/poly l with polynomial f       
     15        center(MaxDeg[,N]);             returns the center of basering,
     16        centralizer(f, MaxDeg[,N]);     returns the centralizer of f in basering,
     17        inCenter(l);                    checks the centrality of elements of list/ideal/poly l
     18        inCentralizer(l, f);            checks the commutativity wrt polynomialf of polynomials of list/ideal/poly l
    2019
    2120SEE ALSO:  ncalg_lib, nctools_lib
    22 KEYWORDS:  inCenter; inCentralizator; center; centralizator
     21KEYWORDS:  inCenter; inCentralizer; center; centralizer
    2322";
    2423
    … …  
    23932392
    23942393/******************************************************************************/
    2395 static proc inCentralizator_poly( poly p, poly f )
    2396 "
    2397   if p in Centralizator(f) => return 1
     2394static proc inCentralizer_poly( poly p, poly f )
     2395"
     2396  if p in Centralizer(f) => return 1
    23982397      otherwise     return 0
    23992398"
    … …  
    24032402          if( toprint() )
    24042403          {
    2405                 "POLY: ", string (p), " is NOT in Centralizator(f)";
     2404                "POLY: ", string (p), " is NOT in Centralizer(f)";
    24062405          };
    24072406          return (0);
    … …  
    24102409    if( toprint() )
    24112410    {
    2412         "POLY: ", string (p), " is in Centralizator(f)";
     2411        "POLY: ", string (p), " is in Centralizer(f)";
    24132412    };
    24142413        return (1);
    … …  
    24162415
    24172416/******************************************************************************/
    2418 static proc inCentralizator_list( def l, poly f )
     2417static proc inCentralizer_list( def l, poly f )
    24192418{
    24202419  for ( int @i = 1; @i <= size(l); @i++ )
    … …  
    24222421        if ( typeof(l[@i])=="poly" )
    24232422        {
    2424             if (! inCentralizator_poly(l[@i], f) )
     2423            if (! inCentralizer_poly(l[@i], f) )
    24252424                {
    24262425                  return(0);
    … …  
    24312430            if ( (typeof(l[@i])=="list") or (typeof(l[@i])=="ideal") )
    24322431            {
    2433                   if (! inCentralizator_list(l[@i], f) )
     2432                  if (! inCentralizer_list(l[@i], f) )
    24342433                  {
    24352434                        return(0);
    … …  
    25842583///////////////////////////////////////////////////////////////////////////////
    25852584///////////////////////////////////////////////////////////////////////////////
    2586 /// Centralizator's computations
    2587 
    2588 ///////////////////////////////////////////////////////////////////////////////
    2589 /* static */ proc centralizator_vectorspace( poly p, int MaxDeg )
     2585/// Centralizer's computations
     2586
     2587///////////////////////////////////////////////////////////////////////////////
     2588/* static */ proc centralizer_vectorspace( poly p, int MaxDeg )
    25902589{
    25912590        return( calc_k_base( PBW_base( MaxDeg, p )));
    … …  
    25932592
    25942593///////////////////////////////////////////////////////////////////////////////
    2595 /* static */ proc centralizator_min_vectorspace( poly p, int MaxDeg )
    2596 {
    2597         return( makeIdeal( zReduce( centralizator_vectorspace( p, MaxDeg))));
    2598 };
    2599 
    2600 ///////////////////////////////////////////////////////////////////////////////
    2601 /* static */ proc centralizator_min_iterative( poly p, int MaxDeg, list # )
    2602 "
    2603   computes the 'minimal' set of elements (of deg <= MaxDeg) generating centralizator of p in iterative way
     2594/* static */ proc centralizer_min_vectorspace( poly p, int MaxDeg )
     2595{
     2596        return( makeIdeal( zReduce( centralizer_vectorspace( p, MaxDeg))));
     2597};
     2598
     2599///////////////////////////////////////////////////////////////////////////////
     2600/* static */ proc centralizer_min_iterative( poly p, int MaxDeg, list # )
     2601"
     2602  computes the 'minimal' set of elements (of deg <= MaxDeg) generating centralizer of p in iterative way
    26042603  Note: based on calc_k_base
    26052604 
    26062605  !!! NEED DEBUG !!!
    2607   Note: no proof that it is really centralizator and moreover 'minimal' centralizator
     2606  Note: no proof that it is really centralizer and moreover 'minimal' centralizer
    26082607"
    26092608{
    … …  
    27232722
    27242723/******************************************************************************/
    2725 proc inCentralizator( def a, poly f )
    2726 "USAGE:   inCentralizator(a, f); a poly/list/ideal, f poly
    2727 RETURN:  integer (1 if a in centralizator(f), 0 otherwise)
    2728 EXAMPLE: example inCentralizator; shows examples"
     2724proc inCentralizer( def a, poly f )
     2725"USAGE:   inCentralizer(a, f); a poly/list/ideal, f poly
     2726RETURN:  integer (1 if a in centralizer(f), 0 otherwise)
     2727EXAMPLE: example inCentralizer; shows examples"
    27292728{
    27302729  if ( typeof(a) == "poly" )
    27312730  {
    2732         return (inCentralizator_poly(a, f));
     2731        return (inCentralizer_poly(a, f));
    27332732  };
    27342733
    27352734  if ( (typeof(a)=="list") or (typeof(a)=="ideal") )
    27362735  {
    2737         return (inCentralizator_list(a, f));
     2736        return (inCentralizer_list(a, f));
    27382737  };
    27392738}
    … …  
    27502749  poly a = z; /// lies in center
    27512750  poly b = y^2;
    2752   inCentralizator(a, f);
    2753   inCentralizator(b, f);
     2751  inCentralizer(a, f);
     2752  inCentralizer(b, f);
    27542753  list  l = list(1, a);
    2755   inCentralizator(l, f);
     2754  inCentralizer(l, f);
    27562755  ideal I = a, b;
    2757   inCentralizator(I, f);
     2756  inCentralizer(I, f);
    27582757};
    27592758
    … …  
    27692768            1. MaxDeg - maximal degree of desired elements or/and
    27702769            2. n - the minimal number of desired elements to find.
    2771 SEE ALSO:   centralizator; inCenter
     2770SEE ALSO:   centralizer; inCenter
    27722771EXAMPLE:    example center; shows an example"
    27732772{
    … …  
    28062805
    28072806///////////////////////////////////////////////////////////////////////////////
    2808 proc centralizator( poly p, int MaxDeg, list # )
    2809 "USAGE:      centralizator(F, MaxDeg[, N]); poly F, int MaxDeg, int N
     2807proc centralizer( poly p, int MaxDeg, list # )
     2808"USAGE:      centralizer(F, MaxDeg[, N]); poly F, int MaxDeg, int N
    28102809RETURN:     ideal generated by found elements
    2811 NOTE:       computes the 'minimal' set of elements of centralizator(F).
     2810NOTE:       computes the 'minimal' set of elements of centralizer(F).
    28122811            Since in general algorithms knows nothing about the number and degrees of
    28132812            desired polynomials one have to specify any kind of termination condition:
    28142813            1. MaxDeg - maximal degree of desired elements or/and
    28152814            2. n - the minimal number of desired elements to find.
    2816 SEE ALSO:   center; inCentralizator
    2817 EXAMPLE:    example centralizator; shows an example"
     2815SEE ALSO:   center; inCentralizer
     2816EXAMPLE:    example centralizer; shows an example"
    28182817{
    28192818       
    28202819        if( myInt(#) > 0 )
    28212820        {
    2822                 return( centralizator_min_iterative( p, MaxDeg, # ) );
     2821                return( centralizer_min_iterative( p, MaxDeg, # ) );
    28232822        };
    28242823       
    28252824        if( MaxDeg >= 0 )
    28262825        {
    2827 //              return( centralizator_min_iterative( p, MaxDeg, # ) );
    2828                 return( centralizator_min_vectorspace( p, MaxDeg ) );
     2826//              return( centralizer_min_iterative( p, MaxDeg, # ) );
     2827                return( centralizer_min_vectorspace( p, MaxDeg ) );
    28292828        };
    28302829       
    … …  
    28432842   poly f = 4*x*y+z^2-2*z; /// central polynomial
    28442843   f;
    2845    ideal c = centralizator(f, 2); /// find all elements of degree <= 2 which lies in centralizator of f
     2844   ideal c = centralizer(f, 2); /// find all elements of degree <= 2 which lies in centralizer of f
    28462845   c;
    2847    inCentralizator(c, f);
    2848    ideal cc = centralizator(f, -1, 2 ); /// find at least first two non trivial elements of the centralizator of f
     2846   inCentralizer(c, f);
     2847   ideal cc = centralizer(f, -1, 2 ); /// find at least first two non trivial elements of the centralizer of f
    28492848   cc;
    2850    inCentralizator(cc, f);
     2849   inCentralizer(cc, f);
    28512850   poly g = z^2-2*z; /// any polynomial
    28522851   g;
    2853    c = centralizator(g, 2); /// find all elements of degree <= 2 which lies in centralizator of g
     2852   c = centralizer(g, 2); /// find all elements of degree <= 2 which lies in centralizer of g
    28542853   c;
    2855    inCentralizator(c, g);
    2856    cc = centralizator(g, -1, 2 ); /// find at least first two non trivial elements of the centralizator of g
     2854   inCentralizer(c, g);
     2855   cc = centralizer(g, -1, 2 ); /// find at least first two non trivial elements of the centralizer of g
    28572856   cc;
    2858    inCentralizator(cc, g);
    2859 };
    2860 
    2861 
    2862 ///////////////////////////////////////////////////////////////////////////////
    2863 ///////////////////////////////////////////////////////////////////////////////
    2864 ///////////////////////////////////////////////////////////////////////////////
     2857   inCentralizer(cc, g);
     2858};
     2859
     2860
     2861///////////////////////////////////////////////////////////////////////////////
     2862///////////////////////////////////////////////////////////////////////////////
     2863///////////////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.