Changeset 8f643b7 in git


Ignore:
Timestamp:
Mar 21, 2006, 9:21:38 AM (18 years ago)
Author:
Michael Brickenstein <bricken@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
28b7e70fb7504bfa91d72ad1ee789e50a08f7e84
Parents:
9a7b03d261325d1fc155f5625fe1867b6ef6432c
Message:
*bricken: improved turaev/viro


git-svn-id: file:///usr/local/Singular/svn/trunk@9028 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
modules/python
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • modules/python/symm.py

    r9a7b03 r8f643b7  
    11from probstat import Cartesian
    2 from itertools import repeat,imap
    3 class chainmap(object):
    4   """this class represents an equivalent relation,
    5     which is implemented by repeated evaluatation of a map
    6     c[n]=m means that n is equivalent to m"""
    7   def __init__(self):
    8     self.mydict={}
    9   def canonical(self,var):
    10     while var in self.mydict:
    11       var=self.mydict[var]
    12     return var
    13   def all_rewritings(self,var):
    14     pass
    15   def rewrite(self, a,b):
    16     a=self.canonical(a)
    17     b=self.canonical(b)   
    18     if not a==b:
    19       self.mydict[a]=b
    20   def __getitem__(self,key):
    21     return self.canonical(key)
    22   def __setitem__(self, val, key):
    23     self.rewrite(val,key)
     2from itertools import repeat,imap, ifilter
     3from util import EquivalenceRelation
     4
    245class modPNumber:
    256  """simple class for Turaev/Viro colors,
    … …  
    4021    return str(self.val)
    4122
     23colors=3
     24value_range=[modPNumber(i,colors) for i in xrange(colors)]
    4225
    43 colors=3
    44 def constr_value_range(n):
    45   return [modPNumber(i,n) for i in xrange(n)]
    46 value_range=constr_value_range(colors)
     26wrel=EquivalenceRelation()
     27for i in value_range:
     28  wrel[i]=-i
     29weights_canonical_to_index=dict((weight,i+1) \
     30    for (i,weight) in enumerate(ifilter( \
     31        wrel.isCanonical,value_range)))
     32wtrans=dict((weight,weights_canonical_to_index[wrel.canonical(weight)]) for weight in \
     33    value_range)
     34weights=max([wtrans[i] for i in weights_canonical_to_index])
    4735
    48 chain=chainmap()
    49 l12=[1,2]
    5036
    5137def constr_variations():
    5238  return imap(tuple,Cartesian(list(repeat(value_range,6))))
     39relation=EquivalenceRelation()
    5340for (a,b,c,d,e,f) in constr_variations():
    54   chain[(a,b,c,d,e,f)]=(b,c,a,f,-d,-e)
    55   chain[(a,b,c,d,e,f)]=(a,-d,-e,-b,-c,-f)
    56 
    57 class chaintrans(object):
    58   def __init__(self, chain,full):
    59     self.table={}
    60     self.i=1
    61     full=list(full)
    62     for c in full:
    63       if not c in chain.mydict:
    64         self.insert(c)
    65     for c in full:
    66       self.table[c]=self.table[chain[c]]
    67   def __getitem__(self, key):
    68     return self.table[key]
    69   def insert(self,key):
    70     self.table[key]=self.i
    71     self.i=self.i+1
    72   def __str__(self):
    73     return str(self.table)
    74 
    75 
    76 
    77 vartrans=chaintrans(chain, constr_variations())
    78 #we only needed this class for construction, can replace it by a function
    79 vartrans=vartrans.table
    80 del chain
    81 
    82 #weights=2
     41  relation[(a,b,c,d,e,f)]=(b,c,a,f,-d,-e)
     42  relation[(a,b,c,d,e,f)]=(a,-d,-e,-b,-c,-f)
     43canonical_to_index=dict((symbol,weights+i+1) for (i,symbol) in \
     44    enumerate(ifilter( \
     45       relation.isCanonical,constr_variations())))
     46vartrans=dict((symbol,canonical_to_index[relation.canonical(symbol)]) for symbol in \
     47    constr_variations())
     48symbols=max([vartrans[i] for i in canonical_to_index])
    8349
    8450from interpreter import *
    … …  
    8854singular_var=singular.var
    8955
    90 def singvar(v):
     56def six_j_symbol(v):
    9157  i=vartrans[v]+weights
    92   return vartable[i-1]
     58  return var_cache[i-1]
    9359 
    94 wmap=chainmap()
    95 for i in value_range:
    96   wmap[i]=-i
    97 wtrans=chaintrans(wmap,value_range)
    98 wtrans=wtrans.table
    99 symbols=max([vartrans[i] for i in vartrans])
    100 weights=max([wtrans[i] for i in wtrans])
    101 
    102 del wmap
    10360
    10461def w(i):
    105   return vartable[wtrans[i]-1]
     62  return var_cache[wtrans[i]-1]
    10663r=create_ring(char=0,nvars=weights+symbols)
    10764r.set()
    … …  
    11168  acc=Polynomial(0)
    11269  for p in l:
    113     acc=acc+p
    114 
     70    acc+=p
    11571  return acc
    11672
    11773
    118 vartable=[singular_var(x+1) for x in range(singular.nvars(Ring()))]
     74var_cache=[singular_var(x+1) for x in range(singular.nvars(Ring()))]
    11975for (j1,j2,j3,j4,j5,j6,j7,j8,j9) in Cartesian(list(repeat(value_range,9))):
    12076  p=\
    121     singvar((j1,j2,j3,j7,j8,j9))*\
    122     singvar((j4,j5,j6,-j7,-j8,-j9))+\
     77    six_j_symbol((j1,j2,j3,j7,j8,j9))*\
     78    six_j_symbol((j4,j5,j6,-j7,-j8,-j9))+\
    12379    Number(-1)*\
    12480    polysum([\
    125       w(j)*singvar((j,j1,j2,-j4,-j5,j7))*\
    126       singvar((j,j2,j3,-j5,-j6,j9))*
    127       singvar((j,j3,j1,-j6,-j4,-j8))\
     81      w(j)*six_j_symbol((j,j1,j2,-j4,-j5,j7))*\
     82      six_j_symbol((j,j2,j3,-j5,-j6,j9))*
     83      six_j_symbol((j,j3,j1,-j6,-j4,-j8))\
    12884      for j in value_range])
    12985  myideal.append(p)
    13086
     87
     88back_table_v=dict((canonical_to_index[s],s) for s\
     89    in canonical_to_index)
     90back_table_w=dict((weights_canonical_to_index[w],w) for w\
     91    in weights_canonical_to_index)
     92back_table_joint=dict(back_table_v)
     93back_table_joint.update(back_table_w)
     94print "back", back_table_joint
     95print "original length",len(myideal)
    13196print "now calculating"
    132 
    133 print "original length",len(myideal)
    13497myideal=singular.simplify(myideal,4)
    13598print "simplified", len(myideal)
    13699gb=singular.slimgb(myideal)
    137100print gb
    138 print len(gb), "GB Elemente"
     101print len(gb), "GB elements"

  • modules/python/util.py

    r9a7b03 r8f643b7  
    1616  l=[char,varNames,[[ordering,degvec],["C",modulweights]], Ideal()]
    1717  return singular.ring(l)
    18  
     18
     19
     20class EquivalenceRelation(object):
     21  """this class represents an equivalent relation,
     22    which is implemented by repeated evaluatation of a map
     23    c[n]=m means that n is equivalent to m"""
     24  def __init__(self):
     25    self.mydict={}
     26  def canonical(self,var):
     27    while var in self.mydict:
     28      var=self.mydict[var]
     29    return var
     30  def isCanonical(self,var):
     31    if self.canonical(var)==var:
     32        return True
     33    else:
     34        return False
     35  def all_rewritings(self,var):
     36    pass
     37  def rewrite(self, a,b):
     38    a=self.canonical(a)
     39    b=self.canonical(b)   
     40    if not a==b:
     41      self.mydict[a]=b
     42  def __getitem__(self,key):
     43    return self.canonical(key)
     44  def __setitem__(self, val, key):
     45    self.rewrite(val,key)
     46   
     47   
     48class chaintrans(object):
     49  def __init__(self, chain,full):
     50    self.table={}
     51    self.i=1
     52    full=list(full)
     53    for c in full:
     54      if not c in chain.mydict:
     55        self.insert(c)
     56    for c in full:
     57      self.table[c]=self.table[chain[c]]
     58  def __getitem__(self, key):
     59    return self.table[key]
     60  def insert(self,key):
     61    self.table[key]=self.i
     62    self.i=self.i+1
     63  def __str__(self):
     64    return str(self.table)
Note: See TracChangeset for help on using the changeset viewer.